Convert MediaLog from being ref counted to owned by WebMediaPlayer.

media/formats/mp4/box_reader.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 <stddef.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 73 matching lines @@
 bool BufferReader::Read4sInto8s(int64_t* v) {
   // Beware of the need for sign extension.
   int32_t tmp;
   RCHECK(Read4s(&tmp));
   *v = tmp;
   return true;
 }
 
 BoxReader::BoxReader(const uint8_t* buf,
                      const size_t buf_size,
-                     const scoped_refptr<MediaLog>& media_log,
+                     MediaLog* media_log,
                      bool is_EOS)
     : BufferReader(buf, buf_size),
       media_log_(media_log),
       box_size_(0),
       box_size_known_(false),
       type_(FOURCC_NULL),
       version_(0),
       flags_(0),
       scanned_(false),
       is_EOS_(is_EOS) {}
 
 BoxReader::BoxReader(const BoxReader& other) = default;
 
 BoxReader::~BoxReader() {
   if (scanned_ && !children_.empty()) {
     for (ChildMap::iterator itr = children_.begin();
          itr != children_.end(); ++itr) {
       DVLOG(1) << "Skipping unknown box: " << FourCCToString(itr->first);
     }
   }
 }
 
 // static
 BoxReader* BoxReader::ReadTopLevelBox(const uint8_t* buf,
                                       const size_t buf_size,
-                                      const scoped_refptr<MediaLog>& media_log,
+                                      MediaLog* media_log,
                                       bool* err) {
   std::unique_ptr<BoxReader> reader(
       new BoxReader(buf, buf_size, media_log, false));
   if (!reader->ReadHeader(err))
     return NULL;
 
   // BoxReader::ReadHeader is expected to return false if box_size > buf_size.
   // This may happen if a partial mp4 box is appended, or if the box header is
   // corrupt.
   CHECK(reader->box_size() <= static_cast<uint64_t>(buf_size));
 
   if (!IsValidTopLevelBox(reader->type(), media_log)) {
     *err = true;
     return NULL;
   }
 
   return reader.release();
 }
 
 // static
 bool BoxReader::StartTopLevelBox(const uint8_t* buf,
                                  const size_t buf_size,
-                                 const scoped_refptr<MediaLog>& media_log,
+                                 MediaLog* media_log,
                                  FourCC* type,
                                  size_t* box_size,
                                  bool* err) {
   BoxReader reader(buf, buf_size, media_log, false);
   if (!reader.ReadHeader(err)) return false;
   if (!IsValidTopLevelBox(reader.type(), media_log)) {
     *err = true;
     return false;
   }
   *type = reader.type();
   *box_size = reader.box_size();
   return true;
 }
 
 // static
 BoxReader* BoxReader::ReadConcatentatedBoxes(const uint8_t* buf,
                                              const size_t buf_size) {
-  BoxReader* reader = new BoxReader(buf, buf_size, new MediaLog(), true);
+  // TODO(wolenetz): Questionable MediaLog usage, http://crbug.com/712310
+  MediaLog media_log;
+  BoxReader* reader = new BoxReader(buf, buf_size, &media_log, true);
 
   // Concatenated boxes are passed in without a wrapping parent box. Set
   // |box_size_| to the concatenated buffer length to mimic having already
   // parsed the parent box.
   reader->box_size_ = buf_size;
   reader->box_size_known_ = true;
 
   return reader;
 }
 
 // static
-bool BoxReader::IsValidTopLevelBox(const FourCC& type,
-                                   const scoped_refptr<MediaLog>& media_log) {
+bool BoxReader::IsValidTopLevelBox(const FourCC& type, MediaLog* media_log) {
   switch (type) {
     case FOURCC_FTYP:
     case FOURCC_PDIN:
     case FOURCC_BLOC:
     case FOURCC_MOOV:
     case FOURCC_MOOF:
     case FOURCC_MFRA:
     case FOURCC_MDAT:
     case FOURCC_FREE:
     case FOURCC_SKIP:
@@ skipping 112 matching lines @@
 
   // Note that the pos_ head has advanced to the byte immediately after the
   // header, which is where we want it.
   box_size_ = base::checked_cast<size_t>(box_size);
   box_size_known_ = true;
   return true;
 }
 
 }  // namespace mp4
 }  // namespace media