Convert MediaLog from being ref counted to owned by WebMediaPlayer.

media/formats/mp4/box_reader_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/formats/mp4/box_reader.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <memory>
@@ skipping 65 matching lines @@
 
   SkipBox();
   ~SkipBox() override;
 };
 
 SkipBox::SkipBox() {}
 SkipBox::~SkipBox() {}
 
 class BoxReaderTest : public testing::Test {
  public:
-  BoxReaderTest() : media_log_(new StrictMock<MockMediaLog>()) {}
+  BoxReaderTest() {}
 
  protected:
   std::vector<uint8_t> GetBuf() {
     return std::vector<uint8_t>(kSkipBox, kSkipBox + sizeof(kSkipBox));
   }
 
   void TestTopLevelBox(const uint8_t* data, size_t data_size, uint32_t fourCC) {
     std::vector<uint8_t> buf(data, data + data_size);
 
     bool err;
     std::unique_ptr<BoxReader> reader(
-        BoxReader::ReadTopLevelBox(&buf[0], buf.size(), media_log_, &err));
+        BoxReader::ReadTopLevelBox(&buf[0], buf.size(), &media_log_, &err));
 
     EXPECT_FALSE(err);
     EXPECT_TRUE(reader);
     EXPECT_EQ(fourCC, reader->type());
     EXPECT_EQ(reader->box_size(), data_size);
   }
 
   template <typename ChildType>
   void TestParsing32bitOverflow(const uint8_t* buffer,
                                 size_t size,
@@ skipping 11 matching lines @@
     ASSERT_TRUE(base::IsValueInRangeForNumericType<uint8_t>(size));
     ASSERT_LE(buffer[3], size);
 
     // Update the size (keep it simple).
     ASSERT_TRUE(
         base::IsValueInRangeForNumericType<uint8_t>(buffer_wrapper.size()));
     buffer_wrapper[3] = buffer_wrapper.size();
 
     bool err;
     std::unique_ptr<BoxReader> reader(BoxReader::ReadTopLevelBox(
-        &buffer_wrapper[0], buffer_wrapper.size(), media_log_, &err));
+        &buffer_wrapper[0], buffer_wrapper.size(), &media_log_, &err));
     EXPECT_FALSE(err);
     EXPECT_TRUE(reader);
     EXPECT_EQ(FOURCC_EMSG, reader->type());
 
 // Overflow is only triggered/caught on 32-bit systems. 64-bit systems will
 // instead fail parsing because tests are written such that |buffer| never
 // contains enough bytes for parsing to succeed.
 #if defined(ARCH_CPU_32_BITS)
     const int kOverflowLogCount = 1;
 #else
     const int kOverflowLogCount = 0;
 #endif
 
     if (!overflow_error.empty())
       EXPECT_MEDIA_LOG(HasSubstr(overflow_error)).Times(kOverflowLogCount);
 
     std::vector<ChildType> children;
     EXPECT_FALSE(reader->ReadAllChildrenAndCheckFourCC(&children));
   }
 
-  scoped_refptr<StrictMock<MockMediaLog>> media_log_;
+  StrictMock<MockMediaLog> media_log_;
 };
 
 TEST_F(BoxReaderTest, ExpectedOperationTest) {
   std::vector<uint8_t> buf = GetBuf();
   bool err;
   std::unique_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), media_log_, &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), &media_log_, &err));
   EXPECT_FALSE(err);
   EXPECT_TRUE(reader.get());
 
   SkipBox box;
   EXPECT_TRUE(box.Parse(reader.get()));
   EXPECT_EQ(0x01, reader->version());
   EXPECT_EQ(0x020304u, reader->flags());
   EXPECT_EQ(0x05, box.a);
   EXPECT_EQ(0x06, box.b);
   EXPECT_EQ(0x0708, box.c);
   EXPECT_EQ(static_cast<int32_t>(0xf90a0b0c), box.d);
   EXPECT_EQ(static_cast<int32_t>(0xfd0e0f10), box.e);
 
   EXPECT_EQ(2u, box.kids.size());
   EXPECT_EQ(0xdeadbeef, box.kids[0].val);
   EXPECT_EQ(0xfacecafe, box.kids[1].val);
 
   // Accounting for the extra byte outside of the box above
   EXPECT_EQ(buf.size(), static_cast<uint64_t>(reader->box_size() + 1));
 }
 
 TEST_F(BoxReaderTest, OuterTooShortTest) {
   std::vector<uint8_t> buf = GetBuf();
   bool err;
 
   // Create a soft failure by truncating the outer box.
   std::unique_ptr<BoxReader> r(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size() - 2, media_log_, &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size() - 2, &media_log_, &err));
 
   EXPECT_FALSE(err);
   EXPECT_FALSE(r.get());
 }
 
 TEST_F(BoxReaderTest, InnerTooLongTest) {
   std::vector<uint8_t> buf = GetBuf();
   bool err;
 
   // Make an inner box too big for its outer box.
   buf[25] = 1;
   std::unique_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), media_log_, &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), &media_log_, &err));
 
   SkipBox box;
   EXPECT_FALSE(box.Parse(reader.get()));
 }
 
 TEST_F(BoxReaderTest, WrongFourCCTest) {
   std::vector<uint8_t> buf = GetBuf();
   bool err;
 
   // Set an unrecognized top-level FourCC.
   buf[4] = 0x44;
   buf[5] = 0x41;
   buf[6] = 0x4c;
   buf[7] = 0x45;
 
   EXPECT_MEDIA_LOG(HasSubstr("Unrecognized top-level box type DALE"));
 
   std::unique_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), media_log_, &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), &media_log_, &err));
   EXPECT_FALSE(reader.get());
   EXPECT_TRUE(err);
 }
 
 TEST_F(BoxReaderTest, ScanChildrenTest) {
   std::vector<uint8_t> buf = GetBuf();
   bool err;
   std::unique_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), media_log_, &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), &media_log_, &err));
 
   EXPECT_TRUE(reader->SkipBytes(16) && reader->ScanChildren());
 
   FreeBox free;
   EXPECT_TRUE(reader->ReadChild(&free));
   EXPECT_FALSE(reader->ReadChild(&free));
   EXPECT_TRUE(reader->MaybeReadChild(&free));
 
   std::vector<PsshBox> kids;
 
   EXPECT_TRUE(reader->ReadChildren(&kids));
   EXPECT_EQ(2u, kids.size());
   kids.clear();
   EXPECT_FALSE(reader->ReadChildren(&kids));
   EXPECT_TRUE(reader->MaybeReadChildren(&kids));
 }
 
 TEST_F(BoxReaderTest, ReadAllChildrenTest) {
   std::vector<uint8_t> buf = GetBuf();
   // Modify buffer to exclude its last 'free' box
   buf[3] = 0x38;
   bool err;
   std::unique_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), media_log_, &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), &media_log_, &err));
 
   std::vector<PsshBox> kids;
   EXPECT_TRUE(reader->SkipBytes(16) && reader->ReadAllChildren(&kids));
   EXPECT_EQ(2u, kids.size());
   EXPECT_EQ(kids[0].val, 0xdeadbeef);   // Ensure order is preserved
 }
 
 TEST_F(BoxReaderTest, SkippingBloc) {
   static const uint8_t kData[] = {0x00, 0x00, 0x00, 0x09, 'b',
                                   'l',  'o',  'c',  0x00};
@@ skipping 37 matching lines @@
   // integer overflows. The nested box should not specify more than the
   // number of remaining bytes in the enclosing box.
   static const uint8_t kData[] = {
       0x00, 0x00, 0x00, 0x24, 'e',  'm',  's',  'g',   // outer box
       0x7f, 0xff, 0xff, 0xff, 'j',  'u',  'n',  'k',   // nested box
       0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x3b, 0x03,  // random data for rest
       0x00, 0x01, 0x00, 0x03, 0x00, 0x03, 0x00, 0x04, 0x05, 0x06, 0x07, 0x08};
 
   bool err;
   std::unique_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(kData, sizeof(kData), media_log_, &err));
+      BoxReader::ReadTopLevelBox(kData, sizeof(kData), &media_log_, &err));
 
   EXPECT_FALSE(err);
   EXPECT_TRUE(reader);
   EXPECT_EQ(FOURCC_EMSG, reader->type());
   EXPECT_FALSE(reader->ScanChildren());
 }
 
 TEST_F(BoxReaderTest, ScanChildrenWithInvalidChild) {
   // This data is not a valid 'emsg' box. It is just used as a top-level box
   // as ReadTopLevelBox() has a restricted set of boxes it allows.
   // The nested 'elst' box is used as it includes a count of EditListEntry's.
   // The sample specifies a large number of EditListEntry's, but only 1 is
   // actually included in the box. This test verifies that the code checks
   // properly that the buffer contains the specified number of EditListEntry's
   static const uint8_t kData[] = {
       0x00, 0x00, 0x00, 0x2c, 'e',  'm',  's',  'g',  // outer box
       0x00, 0x00, 0x00, 0x24, 'e',  'l',  's',  't',  // nested box
       0x01, 0x00, 0x00, 0x00,                         // version = 1, flags = 0
       0x00, 0x00, 0x00, 0x0a,  // count = 10, but only 1 actually included
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
   bool err;
   std::unique_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(kData, sizeof(kData), media_log_, &err));
+      BoxReader::ReadTopLevelBox(kData, sizeof(kData), &media_log_, &err));
 
   EXPECT_FALSE(err);
   EXPECT_TRUE(reader);
   EXPECT_EQ(FOURCC_EMSG, reader->type());
   EXPECT_TRUE(reader->ScanChildren());
 
   // 'elst' specifies lots of EditListEntry's but only includes 1. Thus
   // parsing it should fail.
   EditList child;
   EXPECT_FALSE(reader->ReadChild(&child));
 }
 
 TEST_F(BoxReaderTest, ReadAllChildrenWithChildLargerThanParent) {
   static const uint8_t kData[] = {
       0x00, 0x00, 0x00, 0x10, 's', 'k', 'i', 'p',  // outer box
       0x00, 0x00, 0x00, 0x10, 'p', 's', 's', 'h',  // nested box
   };
 
   bool err;
   std::unique_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(kData, sizeof(kData), media_log_, &err));
+      BoxReader::ReadTopLevelBox(kData, sizeof(kData), &media_log_, &err));
 
   EXPECT_FALSE(err);
   EXPECT_TRUE(reader);
   EXPECT_EQ(FOURCC_SKIP, reader->type());
 
   std::vector<PsshBox> tmp;
   EXPECT_FALSE(reader->ReadAllChildren(&tmp));
 }
 
 TEST_F(BoxReaderTest, TrunSampleCount32bitOverflow) {
@@ skipping 89 matching lines @@
       0x00, 0x00, 0x00, 0x00,
   };
 
   // Verify we catch the overflow to avoid OOB reads/writes.
   TestParsing32bitOverflow<SampleGroupDescription>(
       kData, sizeof(kData), "Extreme SGPD count exceeds implementation limit.");
 }
 
 }  // namespace mp4
 }  // namespace media