Deprecate LogCB in favor of using MediaLog

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 <string.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/formats/mp4/box_reader.h"
@@ skipping 68 matching lines @@
  protected:
   std::vector<uint8> GetBuf() {
     return std::vector<uint8>(kSkipBox, kSkipBox + sizeof(kSkipBox));
   }
 };
 
 TEST_F(BoxReaderTest, ExpectedOperationTest) {
   std::vector<uint8> buf = GetBuf();
   bool err;
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), new MediaLog(), &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>(0xf90a0b0c), box.d);
   EXPECT_EQ(static_cast<int32>(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>(reader->size() + 1));
 }
 
 TEST_F(BoxReaderTest, OuterTooShortTest) {
   std::vector<uint8> buf = GetBuf();
   bool err;
 
   // Create a soft failure by truncating the outer box.
-  scoped_ptr<BoxReader> r(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size() - 2, LogCB(), &err));
+  scoped_ptr<BoxReader> r(BoxReader::ReadTopLevelBox(&buf[0], buf.size() - 2,
+                                                     new MediaLog(), &err));
 
   EXPECT_FALSE(err);
   EXPECT_FALSE(r.get());
 }
 
 TEST_F(BoxReaderTest, InnerTooLongTest) {
   std::vector<uint8> buf = GetBuf();
   bool err;
 
   // Make an inner box too big for its outer box.
   buf[25] = 1;
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), new MediaLog(), &err));
 
   SkipBox box;
   EXPECT_FALSE(box.Parse(reader.get()));
 }
 
 TEST_F(BoxReaderTest, WrongFourCCTest) {
   std::vector<uint8> buf = GetBuf();
   bool err;
 
   // Set an unrecognized top-level FourCC.
   buf[5] = 1;
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), new MediaLog(), &err));
   EXPECT_FALSE(reader.get());
   EXPECT_TRUE(err);
 }
 
 TEST_F(BoxReaderTest, ScanChildrenTest) {
   std::vector<uint8> buf = GetBuf();
   bool err;
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), new MediaLog(), &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> buf = GetBuf();
   // Modify buffer to exclude its last 'free' box
   buf[3] = 0x38;
   bool err;
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), new MediaLog(), &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
 }
 
 static void TestTopLevelBox(const uint8* data, int size, uint32 fourCC) {
 
   std::vector<uint8> buf(data, data + size);
 
   bool err;
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), new MediaLog(), &err));
 
   EXPECT_FALSE(err);
   EXPECT_TRUE(reader);
   EXPECT_EQ(fourCC, reader->type());
   EXPECT_EQ(reader->size(), size);
 }
 
 TEST_F(BoxReaderTest, SkippingBloc) {
   static const uint8 kData[] = {
     0x00, 0x00, 0x00, 0x09,  'b',  'l',  'o',  'c', 0x00
@@ skipping 25 matching lines @@
     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
     0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,  // usertype
     0x00,
   };
 
   TestTopLevelBox(kData, sizeof(kData), FOURCC_UUID);
 }
 
 }  // namespace mp4
 }  // namespace media