Fix TrackRunIterator to generate a parse error when it encounters a reserved dependency value.

media/formats/mp4/track_run_iterator.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/track_run_iterator.h"
 
 #include <algorithm>
 
 #include "media/base/buffers.h"
 #include "media/formats/mp4/rcheck.h"
@@ skipping 70 matching lines @@
 }
 
 TrackRunIterator::TrackRunIterator(const Movie* moov,
                                    const LogCB& log_cb)
     : moov_(moov), log_cb_(log_cb), sample_offset_(0) {
   CHECK(moov);
 }
 
 TrackRunIterator::~TrackRunIterator() {}
 
-static void PopulateSampleInfo(const TrackExtends& trex,
+static bool PopulateSampleInfo(const TrackExtends& trex,
                                const TrackFragmentHeader& tfhd,
                                const TrackFragmentRun& trun,
                                const int64 edit_list_offset,
                                const uint32 i,
                                SampleInfo* sample_info,
-                               const SampleDependsOn sdtp_sample_depends_on) {
+                               const SampleDependsOn sdtp_sample_depends_on,
+                               const LogCB& log_cb) {
   if (i < trun.sample_sizes.size()) {
     sample_info->size = trun.sample_sizes[i];
   } else if (tfhd.default_sample_size > 0) {
     sample_info->size = tfhd.default_sample_size;
   } else {
     sample_info->size = trex.default_sample_size;
   }
 
   if (i < trun.sample_durations.size()) {
     sample_info->duration = trun.sample_durations[i];
@@ skipping 41 matching lines @@
 
     case kSampleDependsOnOthers:
       sample_info->is_keyframe = false;
       break;
 
     case kSampleDependsOnNoOther:
       sample_info->is_keyframe = true;
       break;
 
     case kSampleDependsOnReserved:
-      CHECK(false);
+      MEDIA_LOG(log_cb) << "Reserved value used in sample dependency info.";
+      return false;
   }
+  return true;
 }
 
 // In well-structured encrypted media, each track run will be immediately
 // preceded by its auxiliary information; this is the only optimal storage
 // pattern in terms of minimum number of bytes from a serial stream needed to
 // begin playback. It also allows us to optimize caching on memory-constrained
 // architectures, because we can cache the relatively small auxiliary
 // information for an entire run and then discard data from the input stream,
 // instead of retaining the entire 'mdat' box.
 //
@@ skipping 122 matching lines @@
             tri.aux_info_total_size += tri.aux_info_sizes[k];
           }
         }
       } else {
         tri.aux_info_start_offset = -1;
         tri.aux_info_total_size = 0;
       }
 
       tri.samples.resize(trun.sample_count);
       for (size_t k = 0; k < trun.sample_count; k++) {
-        PopulateSampleInfo(*trex, traf.header, trun, edit_list_offset,
-                           k, &tri.samples[k], traf.sdtp.sample_depends_on(k));
+        if (!PopulateSampleInfo(*trex, traf.header, trun, edit_list_offset,
+                                k, &tri.samples[k],
+                                traf.sdtp.sample_depends_on(k),
+                                log_cb_)) {
+          return false;
+        }
+
         run_start_dts += tri.samples[k].duration;
 
         if (!is_sample_to_group_valid) {
           // Set group description index to 0 to read encryption information
           // from TrackEncryption Box.
           tri.samples[k].cenc_group_description_index = 0;
           continue;
         }
 
         // ISO-14496-12 Section 8.9.2.3 and 8.9.4 : group description index
@@ skipping 249 matching lines @@
 }
 
 uint8 TrackRunIterator::GetIvSize(size_t sample_index) const {
   uint32 index = GetGroupDescriptionIndex(sample_index);
   return (index == 0) ? track_encryption().default_iv_size
                       : GetSampleEncryptionInfoEntry(index).iv_size;
 }
 
 }  // namespace mp4
 }  // namespace media