Update EME MediaKeyNeededEvent.initData for ISO BMFF to match current spec.

media/mp4/mp4_stream_parser.cc

 // 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.
 
 #include "media/mp4/mp4_stream_parser.h"
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/time.h"
@@ skipping 181 matching lines @@
             (entry.format == FOURCC_ENCA &&
              entry.sinf.format.format == FOURCC_MP4A))) {
         LOG(ERROR) << "Unsupported audio format.";
         return false;
       }
       // Check if it is MPEG4 AAC defined in ISO 14496 Part 3.
       if (entry.esds.object_type != kISO_14496_3) {
         LOG(ERROR) << "Unsupported audio object type.";
         return false;
       }
-      RCHECK(EmitKeyNeeded(entry.sinf.info.track_encryption));
 
       audio_config.Initialize(kCodecAAC, entry.samplesize,
                               aac.channel_layout(),
                               aac.GetOutputSamplesPerSecond(has_sbr_),
                               NULL, 0, false);
       has_audio_ = true;
       audio_track_id_ = track->header.track_id;
     }
     if (track->media.handler.type == kVideo && !video_config.IsValidConfig()) {
       RCHECK(!samp_descr.video_entries.empty());
       if (desc_idx >= samp_descr.video_entries.size())
         desc_idx = 0;
       const VideoSampleEntry& entry = samp_descr.video_entries[desc_idx];
 
       if (!(entry.format == FOURCC_AVC1 ||
             (entry.format == FOURCC_ENCV &&
              entry.sinf.format.format == FOURCC_AVC1))) {
         LOG(ERROR) << "Unsupported video format.";
         return false;
       }
-      RCHECK(EmitKeyNeeded(entry.sinf.info.track_encryption));
 
       // TODO(strobe): Recover correct crop box
       gfx::Size coded_size(entry.width, entry.height);
       gfx::Rect visible_rect(coded_size);
       gfx::Size natural_size = GetNaturalSize(visible_rect.size(),
                                               entry.pixel_aspect.h_spacing,
                                               entry.pixel_aspect.v_spacing);
       video_config.Initialize(kCodecH264, H264PROFILE_MAIN,  VideoFrame::YV12,
                               coded_size, visible_rect, natural_size,
                               // No decoder-specific buffer needed for AVC;
@@ skipping 19 matching lines @@
                                      moov_->header.timescale);
   } else if (moov_->header.duration > 0) {
     duration = TimeDeltaFromRational(moov_->header.duration,
                                      moov_->header.timescale);
   } else {
     duration = kInfiniteDuration();
   }
 
   if (!init_cb_.is_null())
     base::ResetAndReturn(&init_cb_).Run(true, duration);
+
+  RCHECK(EmitKeyNeeded(moov_->pssh));
   return true;
 }
 
 bool MP4StreamParser::ParseMoof(BoxReader* reader) {
   RCHECK(moov_.get());  // Must already have initialization segment
   MovieFragment moof;
   RCHECK(moof.Parse(reader));
   RCHECK(runs_->Init(moof));
+  RCHECK(EmitKeyNeeded(moov_->pssh));
   new_segment_cb_.Run(runs_->GetMinDecodeTimestamp());
   ChangeState(kEmittingSamples);
   return true;
 }
 
-bool MP4StreamParser::EmitKeyNeeded(const TrackEncryption& track_encryption) {
-  // TODO(strobe): Send the correct value for initData. The format of initData
-  // has not yet been defined; see
-  // https://www.w3.org/Bugs/Public/show_bug.cgi?id=17673.
-  if (!track_encryption.is_encrypted) return true;
-  scoped_array<uint8> kid(new uint8[track_encryption.default_kid.size()]);
-  memcpy(kid.get(), &track_encryption.default_kid[0],
-         track_encryption.default_kid.size());
-  return need_key_cb_.Run(kid.Pass(), track_encryption.default_kid.size());
+bool MP4StreamParser::EmitKeyNeeded(

[ddorwin, 2012/09/21 04:04:28]

The name implies one will always be emitted, as used to be the case. Add
IfNecessary or IfEncrypted or IfPotentiallyEncrypted?

[strobe_, 2012/09/21 18:29:46]

Done.

+    const std::vector<ProtectionSystemSpecificHeader>& headers) {
+  // TODO(strobe): ensure that the value of init_data (all PSSH headers
+  // concatenated in arbitrary order) matches the EME spec.
+  // See https://www.w3.org/Bugs/Public/show_bug.cgi?id=17673.
+  if (headers.empty())
+    return true;

[ddorwin, 2012/09/21 04:04:28]

You should probably define the return value as "sent successfully if necessary
or not necessary" or something like that. It's really that false means an error
occurred. Without clarification, I would not expect true from emit() if it
didn't emit.

[strobe_, 2012/09/21 18:29:46]

Done.

+
+  size_t total_size = 0;
+  for (size_t i = 0; i < headers.size(); i++)
+    total_size += headers[i].raw_box.size();
+
+  scoped_array<uint8> init_data(new uint8[total_size]);
+  size_t pos = 0;
+  for (size_t i = 0; i < headers.size(); i++) {
+    memcpy(&init_data.get()[pos], &headers[i].raw_box[0],
+           headers[i].raw_box.size());
+    pos += headers[i].raw_box.size();
+  }
+  return need_key_cb_.Run(init_data.Pass(), total_size);

[ddorwin, 2012/09/21 04:04:28]

Future CL:
We should probably change the name of this function and callback. This callback
means "I found some initData". It's TBD how to dedupe initData, especially since
they don't map directly to key IDs for ISO.

[strobe_, 2012/09/21 18:29:46]

Agreed.

 }
 
 bool MP4StreamParser::PrepareAVCBuffer(
     const AVCDecoderConfigurationRecord& avc_config,
     std::vector<uint8>* frame_buf,
     std::vector<SubsampleEntry>* subsamples) const {
   // Convert the AVC NALU length fields to Annex B headers, as expected by
   // decoding libraries. Since this may enlarge the size of the buffer, we also
   // update the clear byte count for each subsample if encryption is used to
   // account for the difference in size between the length prefix and Annex B
@@ skipping 176 matching lines @@
   return !err;
 }
 
 void MP4StreamParser::ChangeState(State new_state) {
   DVLOG(2) << "Changing state: " << new_state;
   state_ = new_state;
 }
 
 }  // namespace mp4
 }  // namespace media