BASELINE: Update Chromium to 73.0.3683.37

Change-Id: I08c9af2948b645f671e5d933aca1f7a90ea372f2
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

21 files changed, 161 insertions, 138 deletions

diff --git a/chromium/media/formats/ac3/ac3_util.cc b/chromium/media/formats/ac3/ac3_util.cc
index 2c28262da9e..a9ffade2773 100644
--- a/chromium/media/formats/ac3/ac3_util.cc
+++ b/chromium/media/formats/ac3/ac3_util.cc
@@ -5,7 +5,7 @@
 #include "media/formats/ac3/ac3_util.h"
 
 #include "base/logging.h"
-#include "base/macros.h"
+#include "base/stl_util.h"
 #include "media/base/bit_reader.h"
 
 namespace media {
@@ -121,9 +121,9 @@ int GetAc3SyncFrameSampleCount() {
 
 // Returns the size in bytes of the given AC3 synchronization frame.
 int ParseAc3SyncFrameSize(Ac3Header& header) {
-  if (header.sample_rate_code() >= arraysize(kSampleRate) ||
+  if (header.sample_rate_code() >= base::size(kSampleRate) ||
       header.ac3_frame_size_code() >=
-          arraysize(kSyncFrameSizeInWordsFor44kHz)) {
+          base::size(kSyncFrameSizeInWordsFor44kHz)) {
     DVLOG(2) << __func__ << " Invalid frame header."
              << " fscod:" << header.sample_rate_code()
              << " frmsizecod:" << header.ac3_frame_size_code();
diff --git a/chromium/media/formats/common/stream_parser_test_base.h b/chromium/media/formats/common/stream_parser_test_base.h
index 2cc97c63c4f..fc47ccc5343 100644
--- a/chromium/media/formats/common/stream_parser_test_base.h
+++ b/chromium/media/formats/common/stream_parser_test_base.h
@@ -12,7 +12,7 @@
 
 #include "base/macros.h"
 #include "media/base/audio_decoder_config.h"
-#include "media/base/media_log.h"
+#include "media/base/media_util.h"
 #include "media/base/stream_parser.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/text_track_config.h"
@@ -66,7 +66,7 @@ class StreamParserTestBase {
   void OnNewSegment();
   void OnEndOfSegment();
 
-  MediaLog media_log_;
+  NullMediaLog media_log_;
   std::unique_ptr<StreamParser> parser_;
   std::stringstream results_stream_;
   AudioDecoderConfig last_audio_config_;
diff --git a/chromium/media/formats/mp2t/es_adapter_video_unittest.cc b/chromium/media/formats/mp2t/es_adapter_video_unittest.cc
index 7a6b97aeb14..3c078a2f03a 100644
--- a/chromium/media/formats/mp2t/es_adapter_video_unittest.cc
+++ b/chromium/media/formats/mp2t/es_adapter_video_unittest.cc
@@ -11,7 +11,7 @@
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/macros.h"
+#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "media/base/media_util.h"
@@ -45,9 +45,9 @@ BufferQueue GenerateFakeBuffers(const int* frame_pts_ms,
 
   BufferQueue buffers(frame_count);
   for (size_t k = 0; k < frame_count; k++) {
-    buffers[k] = StreamParserBuffer::CopyFrom(
-        dummy_buffer, arraysize(dummy_buffer),
-        is_key_frame[k], DemuxerStream::VIDEO, 0);
+    buffers[k] =
+        StreamParserBuffer::CopyFrom(dummy_buffer, base::size(dummy_buffer),
+                                     is_key_frame[k], DemuxerStream::VIDEO, 0);
     if (frame_pts_ms[k] < 0) {
       buffers[k]->set_timestamp(kNoTimestamp);
     } else {
@@ -120,7 +120,7 @@ TEST_F(EsAdapterVideoTest, FrameDurationSimpleGop) {
     true, false, false, false,
     false, false, false, false };
   BufferQueue buffer_queue =
-      GenerateFakeBuffers(pts_ms, is_key_frame, arraysize(pts_ms));
+      GenerateFakeBuffers(pts_ms, is_key_frame, base::size(pts_ms));
 
   EXPECT_EQ("(1,Y) (2,N) (3,N) (4,N) (5,N) (6,N) (7,N) (7,N)",
             RunAdapterTest(buffer_queue));
@@ -133,7 +133,7 @@ TEST_F(EsAdapterVideoTest, FrameDurationComplexGop) {
     true, false, false, false, false,
     false, false, false, false, false };
   BufferQueue buffer_queue =
-      GenerateFakeBuffers(pts_ms, is_key_frame, arraysize(pts_ms));
+      GenerateFakeBuffers(pts_ms, is_key_frame, base::size(pts_ms));
 
   EXPECT_EQ("(30,Y) (30,N) (30,N) (30,N) (30,N) "
             "(30,N) (30,N) (30,N) (30,N) (30,N)",
@@ -144,7 +144,7 @@ TEST_F(EsAdapterVideoTest, LeadingNonKeyFrames) {
   int pts_ms[] = {30, 40, 50, 120, 150, 180};
   bool is_key_frame[] = {false, false, false, true, false, false};
   BufferQueue buffer_queue =
-      GenerateFakeBuffers(pts_ms, is_key_frame, arraysize(pts_ms));
+      GenerateFakeBuffers(pts_ms, is_key_frame, base::size(pts_ms));
 
   EXPECT_EQ("(30,Y) (30,Y) (30,Y) (30,Y) (30,N) (30,N)",
             RunAdapterTest(buffer_queue));
@@ -154,7 +154,7 @@ TEST_F(EsAdapterVideoTest, LeadingKeyFrameWithNoTimestamp) {
   int pts_ms[] = {-1, 40, 50, 120, 150, 180};
   bool is_key_frame[] = {true, false, false, true, false, false};
   BufferQueue buffer_queue =
-      GenerateFakeBuffers(pts_ms, is_key_frame, arraysize(pts_ms));
+      GenerateFakeBuffers(pts_ms, is_key_frame, base::size(pts_ms));
 
   EXPECT_EQ("(40,Y) (40,Y) (30,Y) (30,N) (30,N)",
             RunAdapterTest(buffer_queue));
@@ -164,7 +164,7 @@ TEST_F(EsAdapterVideoTest, LeadingFramesWithNoTimestamp) {
   int pts_ms[] = {-1, -1, 50, 120, 150, 180};
   bool is_key_frame[] = {false, false, false, true, false, false};
   BufferQueue buffer_queue =
-      GenerateFakeBuffers(pts_ms, is_key_frame, arraysize(pts_ms));
+      GenerateFakeBuffers(pts_ms, is_key_frame, base::size(pts_ms));
 
   EXPECT_EQ("(70,Y) (30,Y) (30,N) (30,N)",
             RunAdapterTest(buffer_queue));
diff --git a/chromium/media/formats/mp2t/es_parser_mpeg1audio_unittest.cc b/chromium/media/formats/mp2t/es_parser_mpeg1audio_unittest.cc
index a7edeaf522f..d3e4dd8a899 100644
--- a/chromium/media/formats/mp2t/es_parser_mpeg1audio_unittest.cc
+++ b/chromium/media/formats/mp2t/es_parser_mpeg1audio_unittest.cc
@@ -8,7 +8,7 @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/time/time.h"
-#include "media/base/media_log.h"
+#include "media/base/media_util.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/formats/mp2t/es_parser_mpeg1audio.h"
 #include "media/formats/mp2t/es_parser_test_base.h"
@@ -28,7 +28,7 @@ class EsParserMpeg1AudioTest : public EsParserTestBase,
   bool Process(const std::vector<Packet>& pes_packets, bool force_timing);
 
  private:
-  MediaLog media_log_;
+  NullMediaLog media_log_;
   DISALLOW_COPY_AND_ASSIGN(EsParserMpeg1AudioTest);
 };
 
diff --git a/chromium/media/formats/mp2t/mp2t_stream_parser_unittest.cc b/chromium/media/formats/mp2t/mp2t_stream_parser_unittest.cc
index f3189e9e176..bd1590adc08 100644
--- a/chromium/media/formats/mp2t/mp2t_stream_parser_unittest.cc
+++ b/chromium/media/formats/mp2t/mp2t_stream_parser_unittest.cc
@@ -20,9 +20,9 @@
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/encryption_pattern.h"
-#include "media/base/media_log.h"
 #include "media/base/media_track.h"
 #include "media/base/media_tracks.h"
+#include "media/base/media_util.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/test_data_util.h"
 #include "media/base/text_track_config.h"
@@ -179,7 +179,7 @@ class Mp2tStreamParserTest : public testing::Test {
   }
 
  protected:
-  MediaLog media_log_;
+  NullMediaLog media_log_;
   std::unique_ptr<Mp2tStreamParser> parser_;
   int segment_count_;
   int config_count_;
diff --git a/chromium/media/formats/mp2t/timestamp_unroller_unittest.cc b/chromium/media/formats/mp2t/timestamp_unroller_unittest.cc
index 952ab1c4106..8fd0e3fd12e 100644
--- a/chromium/media/formats/mp2t/timestamp_unroller_unittest.cc
+++ b/chromium/media/formats/mp2t/timestamp_unroller_unittest.cc
@@ -7,7 +7,7 @@
 #include <vector>
 
 #include "base/logging.h"
-#include "base/macros.h"
+#include "base/stl_util.h"
 #include "base/test/perf_test_suite.h"
 #include "media/formats/mp2t/timestamp_unroller.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -52,7 +52,7 @@ TEST(TimestampUnrollerTest, SingleStream) {
   };
 
   std::vector<int64_t> timestamps_vector(timestamps,
-                                         timestamps + arraysize(timestamps));
+                                         timestamps + base::size(timestamps));
   RunUnrollTest(timestamps_vector);
 }
 
diff --git a/chromium/media/formats/mp4/avc.cc b/chromium/media/formats/mp4/avc.cc
index 31f4df2112b..5a0bb690bef 100644
--- a/chromium/media/formats/mp4/avc.cc
+++ b/chromium/media/formats/mp4/avc.cc
@@ -134,10 +134,21 @@ bool AVC::InsertParamSetsAnnexB(const AVCDecoderConfigurationRecord& avc_config,
   RCHECK(AVC::ConvertConfigToAnnexB(avc_config, &param_sets));
 
   if (subsamples && !subsamples->empty()) {
-    int subsample_index = FindSubsampleIndex(*buffer, subsamples,
-                                             &(*config_insert_point));
-    // Update the size of the subsample where SPS/PPS is to be inserted.
-    (*subsamples)[subsample_index].clear_bytes += param_sets.size();
+    if (config_insert_point != buffer->end()) {
+      int subsample_index =
+          FindSubsampleIndex(*buffer, subsamples, &(*config_insert_point));
+      // Update the size of the subsample where SPS/PPS is to be inserted.
+      (*subsamples)[subsample_index].clear_bytes += param_sets.size();
+    } else {
+      int subsample_index = (*subsamples).size() - 1;
+      if ((*subsamples)[subsample_index].cypher_bytes == 0) {
+        // Extend the last clear range to include the inserted data.
+        (*subsamples)[subsample_index].clear_bytes += param_sets.size();
+      } else {
+        // Append a new subsample to cover the inserted data.
+        (*subsamples).emplace_back(param_sets.size(), 0);
+      }
+    }
   }
 
   buffer->insert(config_insert_point,
diff --git a/chromium/media/formats/mp4/avc_unittest.cc b/chromium/media/formats/mp4/avc_unittest.cc
index 944ca1b7599..3fed74fb2df 100644
--- a/chromium/media/formats/mp4/avc_unittest.cc
+++ b/chromium/media/formats/mp4/avc_unittest.cc
@@ -8,8 +8,8 @@
 
 #include <ostream>
 
-#include "base/macros.h"
 #include "base/optional.h"
+#include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "media/base/decrypt_config.h"
@@ -436,7 +436,7 @@ TEST_F(AVCConversionTest, ValidAnnexBConstructs) {
       {"SDC I", false},
   };
 
-  for (size_t i = 0; i < arraysize(test_cases); ++i) {
+  for (size_t i = 0; i < base::size(test_cases); ++i) {
     std::vector<uint8_t> buf;
     std::vector<SubsampleEntry> subsamples;
     StringToAnnexB(test_cases[i].case_string, &buf, NULL);
@@ -484,7 +484,7 @@ TEST_F(AVCConversionTest, InvalidAnnexBConstructs) {
   BitstreamConverter::AnalysisResult expected;
   expected.is_conformant = false;
 
-  for (size_t i = 0; i < arraysize(test_cases); ++i) {
+  for (size_t i = 0; i < base::size(test_cases); ++i) {
     std::vector<uint8_t> buf;
     std::vector<SubsampleEntry> subsamples;
     StringToAnnexB(test_cases[i].case_string, &buf, NULL);
@@ -532,7 +532,7 @@ TEST_F(AVCConversionTest, InsertParamSetsAnnexB) {
   expected.is_conformant = true;
   expected.is_keyframe = true;
 
-  for (size_t i = 0; i < arraysize(test_cases); ++i) {
+  for (size_t i = 0; i < base::size(test_cases); ++i) {
     std::vector<uint8_t> buf;
     std::vector<SubsampleEntry> subsamples;
 
diff --git a/chromium/media/formats/mp4/box_definitions.cc b/chromium/media/formats/mp4/box_definitions.cc
index 9c4a22021d0..ebe972f0b99 100644
--- a/chromium/media/formats/mp4/box_definitions.cc
+++ b/chromium/media/formats/mp4/box_definitions.cc
@@ -14,6 +14,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "media/base/media_switches.h"
+#include "media/base/media_util.h"
 #include "media/base/video_types.h"
 #include "media/base/video_util.h"
 #include "media/formats/common/opus_constants.h"
@@ -610,7 +611,7 @@ bool AVCDecoderConfigurationRecord::Parse(BoxReader* reader) {
 bool AVCDecoderConfigurationRecord::Parse(const uint8_t* data, int data_size) {
   BufferReader reader(data, data_size);
   // TODO(wolenetz): Questionable MediaLog usage, http://crbug.com/712310
-  MediaLog media_log;
+  NullMediaLog media_log;
   return ParseInternal(&reader, &media_log);
 }
 
diff --git a/chromium/media/formats/mp4/box_reader.h b/chromium/media/formats/mp4/box_reader.h
index 2da377323fd..9ef8ae86c6c 100644
--- a/chromium/media/formats/mp4/box_reader.h
+++ b/chromium/media/formats/mp4/box_reader.h
@@ -59,7 +59,7 @@ class MEDIA_EXPORT BufferReader {
            count <= buf_size_ - pos_;
   }
 
-  // Read a value from the stream, perfoming endian correction, and advance the
+  // Read a value from the stream, performing endian correction, and advance the
   // stream pointer.
   bool Read1(uint8_t* v) WARN_UNUSED_RESULT;
   bool Read2(uint16_t* v) WARN_UNUSED_RESULT;
diff --git a/chromium/media/formats/mp4/dolby_vision.cc b/chromium/media/formats/mp4/dolby_vision.cc
index fd32c85fffd..eac78312da1 100644
--- a/chromium/media/formats/mp4/dolby_vision.cc
+++ b/chromium/media/formats/mp4/dolby_vision.cc
@@ -5,6 +5,7 @@
 #include "media/formats/mp4/dolby_vision.h"
 
 #include "base/logging.h"
+#include "media/base/media_util.h"
 #include "media/base/video_codecs.h"
 #include "media/formats/mp4/box_definitions.h"
 #include "media/formats/mp4/box_reader.h"
@@ -35,7 +36,7 @@ bool DolbyVisionConfiguration::Parse(BoxReader* reader) {
 bool DolbyVisionConfiguration::ParseForTesting(const uint8_t* data,
                                                int data_size) {
   BufferReader reader(data, data_size);
-  MediaLog media_log;
+  NullMediaLog media_log;
   return ParseInternal(&reader, &media_log);
 }
 
diff --git a/chromium/media/formats/mp4/hevc.cc b/chromium/media/formats/mp4/hevc.cc
index b2f606db1fd..c45f556c1ba 100644
--- a/chromium/media/formats/mp4/hevc.cc
+++ b/chromium/media/formats/mp4/hevc.cc
@@ -11,6 +11,7 @@
 
 #include "base/logging.h"
 #include "media/base/decrypt_config.h"
+#include "media/base/media_util.h"
 #include "media/formats/mp4/avc.h"
 #include "media/formats/mp4/box_definitions.h"
 #include "media/formats/mp4/box_reader.h"
@@ -49,7 +50,7 @@ bool HEVCDecoderConfigurationRecord::Parse(BoxReader* reader) {
 bool HEVCDecoderConfigurationRecord::Parse(const uint8_t* data, int data_size) {
   BufferReader reader(data, data_size);
   // TODO(wolenetz): Questionable MediaLog usage, http://crbug.com/712310
-  MediaLog media_log;
+  NullMediaLog media_log;
   return ParseInternal(&reader, &media_log);
 }
 
diff --git a/chromium/media/formats/mp4/sample_to_group_iterator_unittest.cc b/chromium/media/formats/mp4/sample_to_group_iterator_unittest.cc
index 2c3e2fbefc1..92426e56320 100644
--- a/chromium/media/formats/mp4/sample_to_group_iterator_unittest.cc
+++ b/chromium/media/formats/mp4/sample_to_group_iterator_unittest.cc
@@ -9,7 +9,7 @@
 
 #include <memory>
 
-#include "base/macros.h"
+#include "base/stl_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
@@ -24,7 +24,7 @@ class SampleToGroupIteratorTest : public testing::Test {
  public:
   SampleToGroupIteratorTest() {
     // Build sample group description index table from kSampleToGroupTable.
-    for (size_t i = 0; i < arraysize(kCompactSampleToGroupTable); ++i) {
+    for (size_t i = 0; i < base::size(kCompactSampleToGroupTable); ++i) {
       for (uint32_t j = 0; j < kCompactSampleToGroupTable[i].sample_count;
            ++j) {
         sample_to_group_table_.push_back(
@@ -34,7 +34,7 @@ class SampleToGroupIteratorTest : public testing::Test {
 
     sample_to_group_.entries.assign(
         kCompactSampleToGroupTable,
-        kCompactSampleToGroupTable + arraysize(kCompactSampleToGroupTable));
+        kCompactSampleToGroupTable + base::size(kCompactSampleToGroupTable));
     sample_to_group_iterator_.reset(
         new SampleToGroupIterator(sample_to_group_));
   }
diff --git a/chromium/media/formats/mp4/track_run_iterator.cc b/chromium/media/formats/mp4/track_run_iterator.cc
index ffd711396c6..e3b059f67ca 100644
--- a/chromium/media/formats/mp4/track_run_iterator.cc
+++ b/chromium/media/formats/mp4/track_run_iterator.cc
@@ -9,9 +9,9 @@
 #include <limits>
 #include <memory>
 
-#include "base/macros.h"
 #include "base/numerics/checked_math.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/stl_util.h"
 #include "media/base/demuxer_memory_limit.h"
 #include "media/base/encryption_scheme.h"
 #include "media/base/media_util.h"
@@ -721,7 +721,7 @@ std::unique_ptr<DecryptConfig> TrackRunIterator::GetDecryptConfig() {
     if (ApplyConstantIv(sample_idx, &sample_encryption_entry)) {
       std::string iv(reinterpret_cast<const char*>(
                          sample_encryption_entry.initialization_vector),
-                     arraysize(sample_encryption_entry.initialization_vector));
+                     base::size(sample_encryption_entry.initialization_vector));
       switch (run_itr_->encryption_scheme.mode()) {
         case EncryptionScheme::CIPHER_MODE_UNENCRYPTED:
           return nullptr;
@@ -744,7 +744,7 @@ std::unique_ptr<DecryptConfig> TrackRunIterator::GetDecryptConfig() {
       run_itr_->sample_encryption_entries[sample_idx];
   std::string iv(reinterpret_cast<const char*>(
                      sample_encryption_entry.initialization_vector),
-                 arraysize(sample_encryption_entry.initialization_vector));
+                 base::size(sample_encryption_entry.initialization_vector));
 
   size_t total_size = 0;
   if (!sample_encryption_entry.subsamples.empty() &&
diff --git a/chromium/media/formats/mp4/track_run_iterator_unittest.cc b/chromium/media/formats/mp4/track_run_iterator_unittest.cc
index 03f68b491e8..c06c1f47858 100644
--- a/chromium/media/formats/mp4/track_run_iterator_unittest.cc
+++ b/chromium/media/formats/mp4/track_run_iterator_unittest.cc
@@ -10,7 +10,7 @@
 #include <memory>
 
 #include "base/logging.h"
-#include "base/macros.h"
+#include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "media/base/mock_media_log.h"
 #include "media/formats/mp4/box_definitions.h"
@@ -344,7 +344,7 @@ class TrackRunIteratorTest : public testing::Test {
     sinf->info.track_encryption.is_encrypted = true;
     sinf->info.track_encryption.default_iv_size = 8;
     sinf->info.track_encryption.default_kid.assign(kKeyId,
-                                                   kKeyId + arraysize(kKeyId));
+                                                   kKeyId + base::size(kKeyId));
   }
 
   // Add SampleGroupDescription Box to track level sample table and to
@@ -361,7 +361,7 @@ class TrackRunIteratorTest : public testing::Test {
     track_cenc_group.entries[0].iv_size = 8;
     track_cenc_group.entries[0].key_id.assign(
         kTrackCencSampleGroupKeyId,
-        kTrackCencSampleGroupKeyId + arraysize(kTrackCencSampleGroupKeyId));
+        kTrackCencSampleGroupKeyId + base::size(kTrackCencSampleGroupKeyId));
 
     frag->sample_group_description.grouping_type = FOURCC_SEIG;
     frag->sample_group_description.entries.resize(3);
@@ -372,11 +372,11 @@ class TrackRunIteratorTest : public testing::Test {
     frag->sample_group_description.entries[1].key_id.assign(
         kFragmentCencSampleGroupKeyId,
         kFragmentCencSampleGroupKeyId +
-            arraysize(kFragmentCencSampleGroupKeyId));
+            base::size(kFragmentCencSampleGroupKeyId));
     frag->sample_group_description.entries[2].is_encrypted = true;
     frag->sample_group_description.entries[2].iv_size = 16;
     frag->sample_group_description.entries[2].key_id.assign(
-        kKeyId, kKeyId + arraysize(kKeyId));
+        kKeyId, kKeyId + base::size(kKeyId));
 
     frag->sample_to_group.grouping_type = FOURCC_SEIG;
     frag->sample_to_group.entries.assign(sample_to_group_entries,
@@ -400,12 +400,12 @@ class TrackRunIteratorTest : public testing::Test {
       frag->sample_encryption.sample_encryption_data.assign(
           kSampleEncryptionDataWithSubsamples,
           kSampleEncryptionDataWithSubsamples +
-              arraysize(kSampleEncryptionDataWithSubsamples));
+              base::size(kSampleEncryptionDataWithSubsamples));
     } else {
       frag->sample_encryption.sample_encryption_data.assign(
           kSampleEncryptionDataWithoutSubsamples,
           kSampleEncryptionDataWithoutSubsamples +
-              arraysize(kSampleEncryptionDataWithoutSubsamples));
+              base::size(kSampleEncryptionDataWithoutSubsamples));
     }
 
     // Update sample sizes and aux info header.
@@ -438,7 +438,7 @@ class TrackRunIteratorTest : public testing::Test {
     sinf->info.track_encryption.default_constant_iv_size = 16;
     memcpy(sinf->info.track_encryption.default_constant_iv, kIv3, 16);
     sinf->info.track_encryption.default_kid.assign(kKeyId,
-                                                   kKeyId + arraysize(kKeyId));
+                                                   kKeyId + base::size(kKeyId));
   }
 
   void AddConstantIvsToCencSampleGroup(Track* track, TrackFragment* frag) {
@@ -467,7 +467,7 @@ class TrackRunIteratorTest : public testing::Test {
     frag->sample_encryption.sample_encryption_data.assign(
         kSampleEncryptionDataWithSubsamplesAndConstantIv,
         kSampleEncryptionDataWithSubsamplesAndConstantIv +
-            arraysize(kSampleEncryptionDataWithSubsamplesAndConstantIv));
+            base::size(kSampleEncryptionDataWithSubsamplesAndConstantIv));
 
     // Update sample sizes and aux info header.
     frag->runs.resize(1);
@@ -715,14 +715,14 @@ TEST_F(TrackRunIteratorTest,
   EXPECT_EQ(iter_->GetMaxClearOffset(), moof.tracks[1].runs[0].data_offset);
   std::unique_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
   EXPECT_EQ(
-      std::string(reinterpret_cast<const char*>(kKeyId), arraysize(kKeyId)),
+      std::string(reinterpret_cast<const char*>(kKeyId), base::size(kKeyId)),
       config->key_id());
-  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv1), arraysize(kIv1)),
+  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv1), base::size(kIv1)),
             config->iv());
   EXPECT_EQ(config->subsamples().size(), 0u);
   iter_->AdvanceSample();
   config = iter_->GetDecryptConfig();
-  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv2), arraysize(kIv2)),
+  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv2), base::size(kIv2)),
             config->iv());
   EXPECT_EQ(config->subsamples().size(), 0u);
 }
@@ -743,7 +743,7 @@ TEST_F(TrackRunIteratorTest,
       // With Iv size 16 bytes.
       {1, SampleToGroupEntry::kFragmentGroupDescriptionIndexBase + 3}};
   AddCencSampleGroup(&moov_.tracks[1], &moof.tracks[1], kSampleToGroupTable,
-                     arraysize(kSampleToGroupTable));
+                     base::size(kSampleToGroupTable));
 
   ASSERT_TRUE(iter_->Init(moof));
   // The run for track 2 will be the second, which is parsed according to
@@ -758,14 +758,14 @@ TEST_F(TrackRunIteratorTest,
   EXPECT_EQ(iter_->sample_offset(), 200);
   EXPECT_EQ(iter_->GetMaxClearOffset(), moof.tracks[1].runs[0].data_offset);
   std::unique_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
-  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv1), arraysize(kIv1)),
+  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv1), base::size(kIv1)),
             config->iv());
   EXPECT_EQ(config->subsamples().size(), 1u);
   EXPECT_EQ(config->subsamples()[0].clear_bytes, 1u);
   EXPECT_EQ(config->subsamples()[0].cypher_bytes, 2u);
   iter_->AdvanceSample();
   config = iter_->GetDecryptConfig();
-  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv3), arraysize(kIv3)),
+  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv3), base::size(kIv3)),
             config->iv());
   EXPECT_EQ(config->subsamples().size(), 2u);
   EXPECT_EQ(config->subsamples()[0].clear_bytes, 1u);
@@ -788,21 +788,22 @@ TEST_F(TrackRunIteratorTest, DecryptConfigTestWithAuxInfo) {
   EXPECT_EQ(iter_->track_id(), 2u);
   EXPECT_TRUE(iter_->is_encrypted());
   ASSERT_TRUE(iter_->AuxInfoNeedsToBeCached());
-  EXPECT_EQ(static_cast<uint32_t>(iter_->aux_info_size()), arraysize(kAuxInfo));
+  EXPECT_EQ(static_cast<uint32_t>(iter_->aux_info_size()),
+            base::size(kAuxInfo));
   EXPECT_EQ(iter_->aux_info_offset(), 50);
   EXPECT_EQ(iter_->GetMaxClearOffset(), 50);
   EXPECT_FALSE(iter_->CacheAuxInfo(NULL, 0));
   EXPECT_FALSE(iter_->CacheAuxInfo(kAuxInfo, 3));
   EXPECT_TRUE(iter_->AuxInfoNeedsToBeCached());
-  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
+  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, base::size(kAuxInfo)));
   EXPECT_FALSE(iter_->AuxInfoNeedsToBeCached());
   EXPECT_EQ(iter_->sample_offset(), 200);
   EXPECT_EQ(iter_->GetMaxClearOffset(), moof.tracks[0].runs[0].data_offset);
   std::unique_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
   EXPECT_EQ(
-      std::string(reinterpret_cast<const char*>(kKeyId), arraysize(kKeyId)),
+      std::string(reinterpret_cast<const char*>(kKeyId), base::size(kKeyId)),
       config->key_id());
-  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv1), arraysize(kIv1)),
+  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv1), base::size(kIv1)),
             config->iv());
   EXPECT_TRUE(config->subsamples().empty());
   iter_->AdvanceSample();
@@ -821,14 +822,15 @@ TEST_F(TrackRunIteratorTest, CencSampleGroupTest) {
       // Associated with the first entry in SampleGroupDescription Box.
       {1, SampleToGroupEntry::kFragmentGroupDescriptionIndexBase + 1}};
   AddCencSampleGroup(&moov_.tracks[0], &moof.tracks[0], kSampleToGroupTable,
-                     arraysize(kSampleToGroupTable));
+                     base::size(kSampleToGroupTable));
 
   iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   ASSERT_TRUE(InitMoofWithArbitraryAuxInfo(&moof));
 
   std::string cenc_sample_group_key_id(
       kFragmentCencSampleGroupKeyId,
-      kFragmentCencSampleGroupKeyId + arraysize(kFragmentCencSampleGroupKeyId));
+      kFragmentCencSampleGroupKeyId +
+          base::size(kFragmentCencSampleGroupKeyId));
   // The first sample is encrypted and the second sample is unencrypted.
   EXPECT_TRUE(iter_->is_encrypted());
   EXPECT_EQ(cenc_sample_group_key_id, iter_->GetDecryptConfig()->key_id());
@@ -852,18 +854,19 @@ TEST_F(TrackRunIteratorTest, CencSampleGroupWithTrackEncryptionBoxTest) {
       // Associated with the 1st entry in track SampleGroupDescription Box.
       {2, 1}};
   AddCencSampleGroup(&moov_.tracks[0], &moof.tracks[0], kSampleToGroupTable,
-                     arraysize(kSampleToGroupTable));
+                     base::size(kSampleToGroupTable));
 
   iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   ASSERT_TRUE(InitMoofWithArbitraryAuxInfo(&moof));
 
-  std::string track_encryption_key_id(kKeyId, kKeyId + arraysize(kKeyId));
+  std::string track_encryption_key_id(kKeyId, kKeyId + base::size(kKeyId));
   std::string track_cenc_sample_group_key_id(
       kTrackCencSampleGroupKeyId,
-      kTrackCencSampleGroupKeyId + arraysize(kTrackCencSampleGroupKeyId));
+      kTrackCencSampleGroupKeyId + base::size(kTrackCencSampleGroupKeyId));
   std::string fragment_cenc_sample_group_key_id(
       kFragmentCencSampleGroupKeyId,
-      kFragmentCencSampleGroupKeyId + arraysize(kFragmentCencSampleGroupKeyId));
+      kFragmentCencSampleGroupKeyId +
+          base::size(kFragmentCencSampleGroupKeyId));
 
   for (size_t i = 0; i < kSampleToGroupTable[0].sample_count; ++i) {
     EXPECT_TRUE(iter_->is_encrypted());
@@ -911,18 +914,18 @@ TEST_F(TrackRunIteratorTest, SharedAuxInfoTest) {
   ASSERT_TRUE(iter_->Init(moof));
   EXPECT_EQ(iter_->track_id(), 1u);
   EXPECT_EQ(iter_->aux_info_offset(), 50);
-  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
+  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, base::size(kAuxInfo)));
   std::unique_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
-  ASSERT_EQ(arraysize(kIv1), config->iv().size());
+  ASSERT_EQ(base::size(kIv1), config->iv().size());
   EXPECT_TRUE(!memcmp(kIv1, config->iv().data(), config->iv().size()));
   iter_->AdvanceSample();
   EXPECT_EQ(iter_->GetMaxClearOffset(), 50);
   iter_->AdvanceRun();
   EXPECT_EQ(iter_->GetMaxClearOffset(), 50);
   EXPECT_EQ(iter_->aux_info_offset(), 50);
-  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
+  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, base::size(kAuxInfo)));
   EXPECT_EQ(iter_->GetMaxClearOffset(), 200);
-  ASSERT_EQ(arraysize(kIv1), config->iv().size());
+  ASSERT_EQ(base::size(kIv1), config->iv().size());
   EXPECT_TRUE(!memcmp(kIv1, config->iv().data(), config->iv().size()));
   iter_->AdvanceSample();
   EXPECT_EQ(iter_->GetMaxClearOffset(), 201);
@@ -957,13 +960,13 @@ TEST_F(TrackRunIteratorTest, UnexpectedOrderingTest) {
   EXPECT_EQ(iter_->track_id(), 2u);
   EXPECT_EQ(iter_->aux_info_offset(), 50);
   EXPECT_EQ(iter_->sample_offset(), 200);
-  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
+  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, base::size(kAuxInfo)));
   EXPECT_EQ(iter_->GetMaxClearOffset(), 100);
   iter_->AdvanceRun();
   EXPECT_EQ(iter_->track_id(), 1u);
   EXPECT_EQ(iter_->aux_info_offset(), 20000);
   EXPECT_EQ(iter_->sample_offset(), 100);
-  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
+  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, base::size(kAuxInfo)));
   EXPECT_EQ(iter_->GetMaxClearOffset(), 100);
   iter_->AdvanceSample();
   EXPECT_EQ(iter_->GetMaxClearOffset(), 101);
@@ -972,7 +975,7 @@ TEST_F(TrackRunIteratorTest, UnexpectedOrderingTest) {
   EXPECT_EQ(iter_->aux_info_offset(), 201);
   EXPECT_EQ(iter_->sample_offset(), 10000);
   EXPECT_EQ(iter_->GetMaxClearOffset(), 201);
-  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
+  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, base::size(kAuxInfo)));
   EXPECT_EQ(iter_->GetMaxClearOffset(), 10000);
 }
 
@@ -1031,17 +1034,17 @@ TEST_F(TrackRunIteratorTest, DecryptConfigTestWithConstantIvNoAuxInfo) {
   EXPECT_EQ(iter_->sample_offset(), 200);
   std::unique_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
   EXPECT_EQ(
-      std::string(reinterpret_cast<const char*>(kKeyId), arraysize(kKeyId)),
+      std::string(reinterpret_cast<const char*>(kKeyId), base::size(kKeyId)),
       config->key_id());
-  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv3), arraysize(kIv3)),
+  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv3), base::size(kIv3)),
             config->iv());
   EXPECT_TRUE(config->subsamples().empty());
   iter_->AdvanceSample();
   config = iter_->GetDecryptConfig();
   EXPECT_EQ(
-      std::string(reinterpret_cast<const char*>(kKeyId), arraysize(kKeyId)),
+      std::string(reinterpret_cast<const char*>(kKeyId), base::size(kKeyId)),
       config->key_id());
-  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv3), arraysize(kIv3)),
+  EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv3), base::size(kIv3)),
             config->iv());
   EXPECT_TRUE(config->subsamples().empty());
 }
@@ -1063,7 +1066,7 @@ TEST_F(TrackRunIteratorTest, DecryptConfigTestWithSampleGroupsAndConstantIv) {
       // Associated with the 1st entry in track SampleGroupDescription Box.
       {1, 1}};
   AddCencSampleGroup(&moov_.tracks[1], &moof.tracks[1], kSampleToGroupTable,
-                     arraysize(kSampleToGroupTable));
+                     base::size(kSampleToGroupTable));
   AddConstantIvsToCencSampleGroup(&moov_.tracks[1], &moof.tracks[1]);
   iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   ASSERT_TRUE(iter_->Init(moof));
@@ -1071,9 +1074,9 @@ TEST_F(TrackRunIteratorTest, DecryptConfigTestWithSampleGroupsAndConstantIv) {
   // The run for track 2 will be the second.
   iter_->AdvanceRun();
 
-  std::string track_encryption_iv(kIv3, kIv3 + arraysize(kIv3));
-  std::string track_cenc_sample_group_iv(kIv4, kIv4 + arraysize(kIv4));
-  std::string fragment_cenc_sample_group_iv(kIv5, kIv5 + arraysize(kIv5));
+  std::string track_encryption_iv(kIv3, kIv3 + base::size(kIv3));
+  std::string track_cenc_sample_group_iv(kIv4, kIv4 + base::size(kIv4));
+  std::string fragment_cenc_sample_group_iv(kIv5, kIv5 + base::size(kIv5));
 
   for (size_t i = 0; i < kSampleToGroupTable[0].sample_count; ++i) {
     EXPECT_TRUE(iter_->is_encrypted());
diff --git a/chromium/media/formats/mpeg/adts_constants.cc b/chromium/media/formats/mpeg/adts_constants.cc
index bc898908fa3..d868fccb5c9 100644
--- a/chromium/media/formats/mpeg/adts_constants.cc
+++ b/chromium/media/formats/mpeg/adts_constants.cc
@@ -4,7 +4,7 @@
 
 #include "media/formats/mpeg/adts_constants.h"
 
-#include "base/macros.h"
+#include "base/stl_util.h"
 
 namespace media {
 
@@ -13,7 +13,7 @@ namespace media {
 const int kADTSFrequencyTable[] = {96000, 88200, 64000, 48000, 44100,
                                    32000, 24000, 22050, 16000, 12000,
                                    11025, 8000,  7350};
-const size_t kADTSFrequencyTableSize = arraysize(kADTSFrequencyTable);
+const size_t kADTSFrequencyTableSize = base::size(kADTSFrequencyTable);
 
 // The following conversion table is extracted from ISO 14496 Part 3 -
 // Table 1.17 - Channel Configuration.
@@ -22,6 +22,6 @@ const media::ChannelLayout kADTSChannelLayoutTable[] = {
     media::CHANNEL_LAYOUT_STEREO,   media::CHANNEL_LAYOUT_SURROUND,
     media::CHANNEL_LAYOUT_4_0,      media::CHANNEL_LAYOUT_5_0_BACK,
     media::CHANNEL_LAYOUT_5_1_BACK, media::CHANNEL_LAYOUT_7_1};
-const size_t kADTSChannelLayoutTableSize = arraysize(kADTSChannelLayoutTable);
+const size_t kADTSChannelLayoutTableSize = base::size(kADTSChannelLayoutTable);
 
 }  // namespace media
diff --git a/chromium/media/formats/webm/webm_cluster_parser.cc b/chromium/media/formats/webm/webm_cluster_parser.cc
index f4aa78c76cf..297906cca65 100644
--- a/chromium/media/formats/webm/webm_cluster_parser.cc
+++ b/chromium/media/formats/webm/webm_cluster_parser.cc
@@ -9,8 +9,8 @@
 #include <vector>
 
 #include "base/logging.h"
-#include "base/macros.h"
 #include "base/numerics/checked_math.h"
+#include "base/stl_util.h"
 #include "base/sys_byteorder.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/timestamp_constants.h"
@@ -243,7 +243,7 @@ base::TimeDelta WebMClusterParser::ReadOpusDuration(const uint8_t* data,
 
   int opusConfig = (data[0] & kTocConfigMask) >> 3;
   CHECK_GE(opusConfig, 0);
-  CHECK_LT(opusConfig, static_cast<int>(arraysize(kOpusFrameDurationsMu)));
+  CHECK_LT(opusConfig, static_cast<int>(base::size(kOpusFrameDurationsMu)));
 
   DCHECK_GT(frame_count, 0);
   base::TimeDelta duration = base::TimeDelta::FromMicroseconds(
diff --git a/chromium/media/formats/webm/webm_cluster_parser_unittest.cc b/chromium/media/formats/webm/webm_cluster_parser_unittest.cc
index 7ce98a52461..ddacc0d5b27 100644
--- a/chromium/media/formats/webm/webm_cluster_parser_unittest.cc
+++ b/chromium/media/formats/webm/webm_cluster_parser_unittest.cc
@@ -15,7 +15,7 @@
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/macros.h"
+#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decrypt_config.h"
@@ -412,8 +412,9 @@ TEST_F(WebMClusterParserTest, HeldBackBufferHoldsBackAllTracks) {
     9,  // Cluster end emits all buffers and 3rd video's duration is estimated
   };
 
-  ASSERT_EQ(arraysize(kBlockInfo), arraysize(kExpectedBuffersOnPartialCluster));
-  int block_count = arraysize(kBlockInfo);
+  ASSERT_EQ(base::size(kBlockInfo),
+            base::size(kExpectedBuffersOnPartialCluster));
+  int block_count = base::size(kBlockInfo);
 
   // Iteratively create a cluster containing the first N+1 blocks and parse all
   // but the last byte of the cluster (except when N==|block_count|, just parse
@@ -459,7 +460,7 @@ TEST_F(WebMClusterParserTest, HeldBackBufferHoldsBackAllTracks) {
 TEST_F(WebMClusterParserTest, Reset) {
   InSequence s;
 
-  int block_count = arraysize(kDefaultBlockInfo);
+  int block_count = base::size(kDefaultBlockInfo);
   std::unique_ptr<Cluster> cluster(
       CreateCluster(0, kDefaultBlockInfo, block_count));
 
@@ -479,7 +480,7 @@ TEST_F(WebMClusterParserTest, Reset) {
 }
 
 TEST_F(WebMClusterParserTest, ParseClusterWithSingleCall) {
-  int block_count = arraysize(kDefaultBlockInfo);
+  int block_count = base::size(kDefaultBlockInfo);
   std::unique_ptr<Cluster> cluster(
       CreateCluster(0, kDefaultBlockInfo, block_count));
 
@@ -489,7 +490,7 @@ TEST_F(WebMClusterParserTest, ParseClusterWithSingleCall) {
 }
 
 TEST_F(WebMClusterParserTest, ParseClusterWithMultipleCalls) {
-  int block_count = arraysize(kDefaultBlockInfo);
+  int block_count = base::size(kDefaultBlockInfo);
   std::unique_ptr<Cluster> cluster(
       CreateCluster(0, kDefaultBlockInfo, block_count));
 
@@ -535,7 +536,7 @@ TEST_F(WebMClusterParserTest, ParseBlockGroup) {
       {kAudioTrackNum, 0, 23, false, NULL, 0, true},
       {kVideoTrackNum, 33, 34, false, NULL, 0, true},
   };
-  int block_count = arraysize(kBlockInfo);
+  int block_count = base::size(kBlockInfo);
 
   const uint8_t kClusterData[] = {
     0x1F, 0x43, 0xB6, 0x75, 0x9B,  // Cluster(size=27)
@@ -564,7 +565,7 @@ TEST_F(WebMClusterParserTest, ParseSimpleBlockAndBlockGroupMixture) {
       {kAudioTrackNum, 46, 23, false, NULL, 0, false},
       {kVideoTrackNum, 67, 33, false, NULL, 0, false},
   };
-  int block_count = arraysize(kBlockInfo);
+  int block_count = base::size(kBlockInfo);
   std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
@@ -586,7 +587,7 @@ TEST_F(WebMClusterParserTest, IgnoredTracks) {
       {kAudioTrackNum, 46, 23, true, NULL, 0, false},
       {kVideoTrackNum, 67, 34, true, NULL, 0, false},
   };
-  int input_block_count = arraysize(kInputBlockInfo);
+  int input_block_count = base::size(kInputBlockInfo);
 
   const BlockInfo kOutputBlockInfo[] = {
       {kAudioTrackNum, 0, 23, true, NULL, 0, false},
@@ -595,7 +596,7 @@ TEST_F(WebMClusterParserTest, IgnoredTracks) {
       {kAudioTrackNum, 46, 23, true, NULL, 0, false},
       {kVideoTrackNum, 67, 34, true, NULL, 0, false},
   };
-  int output_block_count = arraysize(kOutputBlockInfo);
+  int output_block_count = base::size(kOutputBlockInfo);
 
   std::unique_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
@@ -626,7 +627,7 @@ TEST_F(WebMClusterParserTest, ParseTextTracks) {
       {kTextTrackNum, 55, 44, false, NULL, 0, true},
       {kVideoTrackNum, 67, 34, true, NULL, 0, false},
   };
-  int input_block_count = arraysize(kInputBlockInfo);
+  int input_block_count = base::size(kInputBlockInfo);
 
   std::unique_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
@@ -651,7 +652,7 @@ TEST_F(WebMClusterParserTest, TextTracksSimpleBlock) {
   const BlockInfo kInputBlockInfo[] = {
     { kTextTrackNum,  33, 42, true },
   };
-  int input_block_count = arraysize(kInputBlockInfo);
+  int input_block_count = base::size(kInputBlockInfo);
 
   std::unique_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
@@ -687,7 +688,7 @@ TEST_F(WebMClusterParserTest, ParseMultipleTextTracks) {
       {kVideoTrackNum, 67, 34, true, NULL, 0, false},
       {kSubtitleTextTrackNum, 67, 33, false, NULL, 0, false},
   };
-  int input_block_count = arraysize(kInputBlockInfo);
+  int input_block_count = base::size(kInputBlockInfo);
 
   std::unique_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
@@ -771,7 +772,7 @@ TEST_F(WebMClusterParserTest, ParseInvalidTextBlockGroupWithoutDuration) {
   const BlockInfo kBlockInfo[] = {
       {kTextTrackNum, 33, -42, false, NULL, 0, false},
   };
-  int block_count = arraysize(kBlockInfo);
+  int block_count = base::size(kBlockInfo);
   std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_LT(result, 0);
@@ -801,7 +802,7 @@ TEST_F(WebMClusterParserTest, ParseWithDefaultDurationsSimpleBlocks) {
        false},
   };
 
-  int block_count = arraysize(kBlockInfo);
+  int block_count = base::size(kBlockInfo);
   std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
 
   // Send slightly less than the full cluster so all but the last block is
@@ -841,7 +842,7 @@ TEST_F(WebMClusterParserTest, ParseWithoutAnyDurationsSimpleBlocks) {
       {kVideoTrackNum, 100, kExpectedVideoEstimationInMs, true, NULL, 0, false},
   };
 
-  int block_count1 = arraysize(kBlockInfo1);
+  int block_count1 = base::size(kBlockInfo1);
   std::unique_ptr<Cluster> cluster1(
       CreateCluster(0, kBlockInfo1, block_count1));
 
@@ -879,7 +880,7 @@ TEST_F(WebMClusterParserTest, ParseWithoutAnyDurationsSimpleBlocks) {
       {kVideoTrackNum, 201, kExpectedVideoEstimationInMs, true, NULL, 0, false},
   };
 
-  int block_count2 = arraysize(kBlockInfo2);
+  int block_count2 = base::size(kBlockInfo2);
   std::unique_ptr<Cluster> cluster2(
       CreateCluster(0, kBlockInfo2, block_count2));
   EXPECT_MEDIA_LOG(
@@ -913,7 +914,7 @@ TEST_F(WebMClusterParserTest, ParseWithoutAnyDurationsBlockGroups) {
        false},
   };
 
-  int block_count1 = arraysize(kBlockInfo1);
+  int block_count1 = base::size(kBlockInfo1);
   std::unique_ptr<Cluster> cluster1(
       CreateCluster(0, kBlockInfo1, block_count1));
 
@@ -951,7 +952,7 @@ TEST_F(WebMClusterParserTest, ParseWithoutAnyDurationsBlockGroups) {
        false},
   };
 
-  int block_count2 = arraysize(kBlockInfo2);
+  int block_count2 = base::size(kBlockInfo2);
   std::unique_ptr<Cluster> cluster2(
       CreateCluster(0, kBlockInfo2, block_count2));
   EXPECT_MEDIA_LOG(
@@ -989,7 +990,7 @@ TEST_F(WebMClusterParserTest,
        false},
   };
 
-  int block_count = arraysize(kBlockInfo);
+  int block_count = base::size(kBlockInfo);
   std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
 
   // Send slightly less than the full cluster so all but the last block is
@@ -1024,7 +1025,7 @@ TEST_F(WebMClusterParserTest,
     },
   };
 
-  int block_count = arraysize(kBlockInfo);
+  int block_count = base::size(kBlockInfo);
   std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(
       WebMClusterParser::kDefaultAudioBufferDurationInMs));
@@ -1044,7 +1045,7 @@ TEST_F(WebMClusterParserTest,
     { kVideoTrackNum, 0, kTestVideoFrameDefaultDurationInMs, true },
   };
 
-  int block_count = arraysize(kBlockInfo);
+  int block_count = base::size(kBlockInfo);
   std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
@@ -1067,7 +1068,7 @@ TEST_F(WebMClusterParserTest, ReadOpusDurationsSimpleBlockAtEndOfCluster) {
                                      packet_ptr->data(),
                                      packet_ptr->size()}};
 
-    int block_count = arraysize(kBlockInfo);
+    int block_count = base::size(kBlockInfo);
     std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
     int duration_ms = packet_ptr->duration_ms();  // Casts from double.
     if (duration_ms > 120) {
@@ -1113,7 +1114,7 @@ TEST_F(WebMClusterParserTest, PreferOpusDurationsOverBlockDurations) {
                                 packet_ptr->data(),
                                 packet_ptr->size()}};
 
-    int block_count = arraysize(block_infos);
+    int block_count = base::size(block_infos);
     std::unique_ptr<Cluster> cluster(
         CreateCluster(0, block_infos, block_count));
     int result = parser_->Parse(cluster->data(), cluster->size());
@@ -1147,14 +1148,13 @@ TEST_F(WebMClusterParserTest, DontReadEncodedDurationWhenEncrypted) {
                                                     std::string(), kCodecOpus));
 
   // Single Block with BlockDuration and encrypted data.
-  const BlockInfo kBlockInfo[] = {{kAudioTrackNum,
-                                   0,
+  const BlockInfo kBlockInfo[] = {{kAudioTrackNum, 0,
                                    kTestAudioFrameDefaultDurationInMs,
                                    false,            // Not a SimpleBlock
                                    kEncryptedFrame,  // Encrypted frame data
-                                   arraysize(kEncryptedFrame)}};
+                                   base::size(kEncryptedFrame)}};
 
-  int block_count = arraysize(kBlockInfo);
+  int block_count = base::size(kBlockInfo);
   std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
diff --git a/chromium/media/formats/webm/webm_content_encodings_client.cc b/chromium/media/formats/webm/webm_content_encodings_client.cc
index 35749ebb445..6e58adf0343 100644
--- a/chromium/media/formats/webm/webm_content_encodings_client.cc
+++ b/chromium/media/formats/webm/webm_content_encodings_client.cc
@@ -52,8 +52,7 @@ WebMParserClient* WebMContentEncodingsClient::OnListStart(int id) {
     return this;
   }
 
-  // This should not happen if WebMListParser is working properly.
-  DCHECK(false);
+  MEDIA_LOG(ERROR, media_log_) << "Unsupported element " << id;
   return NULL;
 }
 
@@ -130,8 +129,7 @@ bool WebMContentEncodingsClient::OnListEnd(int id) {
     return true;
   }
 
-  // This should not happen if WebMListParser is working properly.
-  DCHECK(false);
+  MEDIA_LOG(ERROR, media_log_) << "Unsupported element " << id;
   return false;
 }
 
@@ -240,8 +238,7 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64_t val) {
     return true;
   }
 
-  // This should not happen if WebMListParser is working properly.
-  DCHECK(false);
+  MEDIA_LOG(ERROR, media_log_) << "Unsupported element " << id;
   return false;
 }
 
@@ -252,20 +249,24 @@ bool WebMContentEncodingsClient::OnBinary(int id,
                                           int size) {
   DCHECK(cur_content_encoding_.get());
   DCHECK(data);
-  DCHECK_GT(size, 0);
 
-  if (id == kWebMIdContentEncKeyID) {
-    if (!cur_content_encoding_->encryption_key_id().empty()) {
-      MEDIA_LOG(ERROR, media_log_) << "Unexpected multiple ContentEncKeyID";
-      return false;
-    }
-    cur_content_encoding_->SetEncryptionKeyId(data, size);
-    return true;
+  if (id != kWebMIdContentEncKeyID) {
+    MEDIA_LOG(ERROR, media_log_) << "Unsupported element " << id;
+    return false;
   }
 
-  // This should not happen if WebMListParser is working properly.
-  DCHECK(false);
-  return false;
+  if (!cur_content_encoding_->encryption_key_id().empty()) {
+    MEDIA_LOG(ERROR, media_log_) << "Unexpected multiple ContentEncKeyID";
+    return false;
+  }
+
+  if (size <= 0) {
+    MEDIA_LOG(ERROR, media_log_) << "Invalid ContentEncKeyID size: " << size;
+    return false;
+  }
+
+  cur_content_encoding_->SetEncryptionKeyId(data, size);
+  return true;
 }
 
 }  // namespace media
diff --git a/chromium/media/formats/webm/webm_parser.cc b/chromium/media/formats/webm/webm_parser.cc
index fe6b72f3cb2..d17781cdc48 100644
--- a/chromium/media/formats/webm/webm_parser.cc
+++ b/chromium/media/formats/webm/webm_parser.cc
@@ -7,9 +7,9 @@
 // This file contains code to parse WebM file elements. It was created
 // from information in the Matroska spec.
 // http://www.matroska.org/technical/specs/index.html
-// This file contains code for encrypted WebM. Current WebM
-// encrypted request for comments specification is here
-// http://wiki.webmproject.org/encryption/webm-encryption-rfc
+//
+// WebM Container Guidelines is at https://www.webmproject.org/docs/container/
+// WebM Encryption spec is at: https://www.webmproject.org/docs/webm-encryption/
 
 #include <stddef.h>
 
@@ -17,8 +17,8 @@
 #include <limits>
 
 #include "base/logging.h"
-#include "base/macros.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/stl_util.h"
 #include "media/formats/webm/webm_constants.h"
 
 namespace media {
@@ -50,6 +50,11 @@ struct ListElementInfo {
 // appear in the list, a parsing error is signalled. Some elements are
 // marked as SKIP because they are valid, but we don't care about them
 // right now.
+//
+// TODO(xhwang): There are many Matroska elements listed here which are not
+// supported by WebM. Since this is a WebM parser, maybe we should not list them
+// here so that the parsing clients doesn't need to handle them.
+
 static const ElementIdInfo kEBMLHeaderIds[] = {
   {UINT, kWebMIdEBMLVersion},
   {UINT, kWebMIdEBMLReadVersion},
@@ -388,7 +393,7 @@ static const ElementIdInfo kSimpleTagIds[] = {
 };
 
 #define LIST_ELEMENT_INFO(id, level, id_info) \
-    { (id), (level), (id_info), arraysize(id_info) }
+  { (id), (level), (id_info), base::size(id_info) }
 
 static const ListElementInfo kListElementInfo[] = {
     LIST_ELEMENT_INFO(kWebMIdCluster, 1, kClusterIds),
@@ -562,7 +567,7 @@ static ElementType FindIdType(int id,
 
 // Finds ListElementInfo for a specific ID.
 static const ListElementInfo* FindListInfo(int id) {
-  for (size_t i = 0; i < arraysize(kListElementInfo); ++i) {
+  for (size_t i = 0; i < base::size(kListElementInfo); ++i) {
     if (id == kListElementInfo[i].id_)
       return &kListElementInfo[i];
   }
@@ -987,7 +992,7 @@ bool WebMListParser::OnListEnd() {
 bool WebMListParser::IsSiblingOrAncestor(int id_a, int id_b) const {
   if (id_a == kWebMIdCluster) {
     // kWebMIdCluster siblings.
-    for (size_t i = 0; i < arraysize(kSegmentIds); i++) {
+    for (size_t i = 0; i < base::size(kSegmentIds); i++) {
       if (kSegmentIds[i].id_ == id_b)
         return true;
     }
diff --git a/chromium/media/formats/webm/webm_parser_unittest.cc b/chromium/media/formats/webm/webm_parser_unittest.cc
index 11f3380417b..ae1f63f0843 100644
--- a/chromium/media/formats/webm/webm_parser_unittest.cc
+++ b/chromium/media/formats/webm/webm_parser_unittest.cc
@@ -9,7 +9,7 @@
 
 #include <memory>
 
-#include "base/macros.h"
+#include "base/stl_util.h"
 #include "media/formats/webm/cluster_builder.h"
 #include "media/formats/webm/webm_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -346,7 +346,7 @@ TEST_F(WebMParserTest, ReservedIds) {
   const uint8_t* kBuffers[] = {k1ByteReservedId, k2ByteReservedId,
                                k3ByteReservedId, k4ByteReservedId};
 
-  for (size_t i = 0; i < arraysize(kBuffers); i++) {
+  for (size_t i = 0; i < base::size(kBuffers); i++) {
     int id;
     int64_t element_size;
     int buffer_size = 2 + i;
@@ -374,7 +374,7 @@ TEST_F(WebMParserTest, ReservedSizes) {
                                k5ByteReservedSize, k6ByteReservedSize,
                                k7ByteReservedSize, k8ByteReservedSize};
 
-  for (size_t i = 0; i < arraysize(kBuffers); i++) {
+  for (size_t i = 0; i < base::size(kBuffers); i++) {
     int id;
     int64_t element_size;
     int buffer_size = 2 + i;