Encrypted Media: Rename NeedKey to EncryptedMediaInitData.

media/formats/mp4/mp4_stream_parser.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/mp4_stream_parser.h"
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/time/time.h"
@@ skipping 24 matching lines @@
       audio_track_id_(0),
       video_track_id_(0),
       audio_object_types_(audio_object_types),
       has_sbr_(has_sbr),
       is_audio_track_encrypted_(false),
       is_video_track_encrypted_(false) {
 }
 
 MP4StreamParser::~MP4StreamParser() {}
 
-void MP4StreamParser::Init(const InitCB& init_cb,
-                           const NewConfigCB& config_cb,
-                           const NewBuffersCB& new_buffers_cb,
-                           bool /* ignore_text_tracks */ ,
-                           const NeedKeyCB& need_key_cb,
-                           const NewMediaSegmentCB& new_segment_cb,
-                           const base::Closure& end_of_segment_cb,
-                           const LogCB& log_cb) {
+void MP4StreamParser::Init(
+    const InitCB& init_cb,
+    const NewConfigCB& config_cb,
+    const NewBuffersCB& new_buffers_cb,
+    bool /* ignore_text_tracks */,
+    const EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
+    const NewMediaSegmentCB& new_segment_cb,
+    const base::Closure& end_of_segment_cb,
+    const LogCB& log_cb) {
   DCHECK_EQ(state_, kWaitingForInit);
   DCHECK(init_cb_.is_null());
   DCHECK(!init_cb.is_null());
   DCHECK(!config_cb.is_null());
   DCHECK(!new_buffers_cb.is_null());
-  DCHECK(!need_key_cb.is_null());
+  DCHECK(!encrypted_media_init_data_cb.is_null());
   DCHECK(!end_of_segment_cb.is_null());
 
   ChangeState(kParsingBoxes);
   init_cb_ = init_cb;
   config_cb_ = config_cb;
   new_buffers_cb_ = new_buffers_cb;
-  need_key_cb_ = need_key_cb;
+  encrypted_media_init_data_cb_ = encrypted_media_init_data_cb;
   new_segment_cb_ = new_segment_cb;
   end_of_segment_cb_ = end_of_segment_cb;
   log_cb_ = log_cb;
 }
 
 void MP4StreamParser::Reset() {
   queue_.Reset();
   runs_.reset();
   moof_head_ = 0;
   mdat_tail_ = 0;
@@ skipping 233 matching lines @@
         moov_->extends.header.fragment_duration, moov_->header.timescale);
   } else if (moov_->header.duration > 0 &&
              moov_->header.duration != kuint64max) {
     params.duration =
         TimeDeltaFromRational(moov_->header.duration, moov_->header.timescale);
   }
 
   if (!init_cb_.is_null())
     base::ResetAndReturn(&init_cb_).Run(true, params);
 
-  EmitNeedKeyIfNecessary(moov_->pssh);
+  if (!moov_->pssh.empty())
+    OnEncryptedMediaInitData(moov_->pssh);
+
   return true;
 }
 
 bool MP4StreamParser::ParseMoof(BoxReader* reader) {
   RCHECK(moov_.get());  // Must already have initialization segment
   MovieFragment moof;
   RCHECK(moof.Parse(reader));
   if (!runs_)
     runs_.reset(new TrackRunIterator(moov_.get(), log_cb_));
   RCHECK(runs_->Init(moof));
   RCHECK(ComputeHighestEndOffset(moof));
-  EmitNeedKeyIfNecessary(moof.pssh);
+
+  if (!moof.pssh.empty())
+    OnEncryptedMediaInitData(moof.pssh);
+
   new_segment_cb_.Run();
   ChangeState(kWaitingForSampleData);
   return true;
 }
 
-void MP4StreamParser::EmitNeedKeyIfNecessary(
+void MP4StreamParser::OnEncryptedMediaInitData(
     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;
-
   size_t total_size = 0;
   for (size_t i = 0; i < headers.size(); i++)
     total_size += headers[i].raw_box.size();
 
   std::vector<uint8> init_data(total_size);
   size_t pos = 0;
   for (size_t i = 0; i < headers.size(); i++) {
     memcpy(&init_data[pos], &headers[i].raw_box[0],
            headers[i].raw_box.size());
     pos += headers[i].raw_box.size();
   }
-  need_key_cb_.Run(kCencInitDataType, init_data);
+  encrypted_media_init_data_cb_.Run(kCencInitDataType, init_data);
 }
 
 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 256 matching lines @@
       runs.AdvanceSample();
     }
     runs.AdvanceRun();
   }
 
   return true;
 }
 
 }  // namespace mp4
 }  // namespace media