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 180 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);
       bool is_encrypted = entry.sinf.info.track_encryption.is_encrypted;
       video_config.Initialize(kCodecH264, H264PROFILE_MAIN,  VideoFrame::YV12,
                               coded_size, visible_rect, natural_size,
@@ skipping 13 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(EmitNeedKeyIfNecessary(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(EmitNeedKeyIfNecessary(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::EmitNeedKeyIfNecessary(
+    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;
+
+  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);
 }
 
 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 195 matching lines @@
   return !err;
 }
 
 void MP4StreamParser::ChangeState(State new_state) {
   DVLOG(2) << "Changing state: " << new_state;
   state_ = new_state;
 }
 
 }  // namespace mp4
 }  // namespace media