Log MediaSource parsing errors to the MediaLog so they can appear in chrome:media-internals.

media/mp4/box_reader.h

 // Copyright (c) 2012 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.
 
 #ifndef MEDIA_MP4_BOX_READER_H_
 #define MEDIA_MP4_BOX_READER_H_
 
 #include <map>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "media/base/media_export.h"
+#include "media/base/media_log.h"
 #include "media/mp4/fourccs.h"
 #include "media/mp4/rcheck.h"
 
 namespace media {
 namespace mp4 {
 
 class BoxReader;
 
 struct MEDIA_EXPORT Box {
   virtual ~Box();
@@ skipping 47 matching lines @@
   ~BoxReader();
 
   // Create a BoxReader from a buffer. Note that this function may return NULL
   // if an intact, complete box was not available in the buffer. If |*err| is
   // set, there was a stream-level error when creating the box; otherwise, NULL
   // values are only expected when insufficient data is available.
   //
   // |buf| is retained but not owned, and must outlive the BoxReader instance.
   static BoxReader* ReadTopLevelBox(const uint8* buf,
                                     const int buf_size,
+                                    const LogCB& log_cb,
                                     bool* err);
 
   // Read the box header from the current buffer. This function returns true if
   // there is enough data to read the header and the header is sane; that is, it
   // does not check to ensure the entire box is in the buffer before returning
   // true. The semantics of |*err| are the same as above.
   //
   // |buf| is not retained.
   static bool StartTopLevelBox(const uint8* buf,
                                const int buf_size,
+                               const LogCB& log_cb,
                                FourCC* type,
                                int* box_size,
                                bool* err) WARN_UNUSED_RESULT;
 
   // Returns true if |type| is recognized to be a top-level box, false
   // otherwise. This returns true for some boxes which we do not parse.
   // Helpful in debugging misaligned appends.
-  static bool IsValidTopLevelBox(const FourCC& type);
+  static bool IsValidTopLevelBox(const FourCC& type,
+                                 const LogCB& log_cb);
 
   // Scan through all boxes within the current box, starting at the current
   // buffer position. Must be called before any of the *Child functions work.
   bool ScanChildren() WARN_UNUSED_RESULT;
 
   // Read exactly one child box from the set of children. The type of the child
   // will be determined by the BoxType() method of |child|.
   bool ReadChild(Box* child) WARN_UNUSED_RESULT;
 
   // Read one child if available. Returns false on error, true on successful
@@ skipping 17 matching lines @@
   // Populate the values of 'version()' and 'flags()' from a full box header.
   // Many boxes, but not all, use these values. This call should happen after
   // the box has been initialized, and does not re-read the main box header.
   bool ReadFullBoxHeader() WARN_UNUSED_RESULT;
 
   FourCC type() const   { return type_; }
   uint8 version() const { return version_; }
   uint32 flags() const  { return flags_; }
 
  private:
-  BoxReader(const uint8* buf, const int size);
+  BoxReader(const uint8* buf, const int size, const LogCB& log_cb);
 
   // Must be called immediately after init. If the return is false, this
   // indicates that the box header and its contents were not available in the
   // stream or were nonsensical, and that the box must not be used further. In
   // this case, if |*err| is false, the problem was simply a lack of data, and
   // should only be an error condition if some higher-level component knows that
   // no more data is coming (i.e. EOS or end of containing box). If |*err| is
   // true, the error is unrecoverable and the stream should be aborted.
   bool ReadHeader(bool* err);
 
+  LogCB log_cb_;
   FourCC type_;
   uint8 version_;
   uint32 flags_;
 
   typedef std::multimap<FourCC, BoxReader> ChildMap;
 
   // The set of child box FourCCs and their corresponding buffer readers. Only
   // valid if scanned_ is true.
   ChildMap children_;
   bool scanned_;
@@ skipping 28 matching lines @@
   return true;
 }
 
 template<typename T>
 bool BoxReader::ReadAllChildren(std::vector<T>* children) {
   DCHECK(!scanned_);
   scanned_ = true;
 
   bool err = false;
   while (pos() < size()) {
-    BoxReader child_reader(&buf_[pos_], size_ - pos_);
+    BoxReader child_reader(&buf_[pos_], size_ - pos_, log_cb_);
     if (!child_reader.ReadHeader(&err)) break;
     T child;
     RCHECK(child.Parse(&child_reader));
     children->push_back(child);
     pos_ += child_reader.size();
   }
 
   return !err;
 }
 
 }  // namespace mp4
 }  // namespace media
 
 #endif  // MEDIA_MP4_BOX_READER_H_