Rename MediaPlayerHostMsg_{DemuxerReady,ReadFromDemuxerAck}_Params to Media{Configs,Data}.

content/renderer/media/android/media_source_delegate.cc

 // Copyright 2013 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 "content/renderer/media/android/media_source_delegate.h"
 
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/renderer/media/android/webmediaplayer_proxy_android.h"
 #include "content/renderer/media/webmediaplayer_util.h"
 #include "content/renderer/media/webmediasource_impl.h"
 #include "media/base/android/demuxer_stream_player_params.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_log.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 
 using media::DemuxerStream;
-using media::MediaPlayerHostMsg_DemuxerReady_Params;
-using media::MediaPlayerHostMsg_ReadFromDemuxerAck_Params;
+using media::DemuxerConfigs;
+using media::DemuxerData;
 using WebKit::WebMediaPlayer;
 using WebKit::WebString;
 
 namespace {
 
 // The size of the access unit to transfer in an IPC in case of MediaSource.
 // 16: approximately 250ms of content in 60 fps movies.
 const size_t kAccessUnitSizeForMediaSource = 16;
 
 const uint8 kVorbisPadding[] = { 0xff, 0xff, 0xff, 0xff };
@@ skipping 267 matching lines @@
 void MediaSourceDelegate::OnReadFromDemuxerInternal(
     media::DemuxerStream::Type type) {
   DCHECK_BELONG_TO_MEDIA_LOOP();
   DVLOG(1) << "OnReadFromDemuxer(" << type << ") : " << player_id_;
   if (IsSeeking())
     return;  // Drop the request during seeking.
 
   DCHECK(type == DemuxerStream::AUDIO || type == DemuxerStream::VIDEO);
   // The access unit size should have been initialized properly at this stage.
   DCHECK_GT(access_unit_size_, 0u);
-  scoped_ptr<MediaPlayerHostMsg_ReadFromDemuxerAck_Params> params(
-      new MediaPlayerHostMsg_ReadFromDemuxerAck_Params());
-  params->type = type;
-  params->access_units.resize(access_unit_size_);
-  ReadFromDemuxerStream(type, params.Pass(), 0);
+  scoped_ptr<DemuxerData> data(new DemuxerData());
+  data->type = type;
+  data->access_units.resize(access_unit_size_);
+  ReadFromDemuxerStream(type, data.Pass(), 0);
 }
 
-void MediaSourceDelegate::ReadFromDemuxerStream(
-    media::DemuxerStream::Type type,
-    scoped_ptr<MediaPlayerHostMsg_ReadFromDemuxerAck_Params> params,
-    size_t index) {
+void MediaSourceDelegate::ReadFromDemuxerStream(media::DemuxerStream::Type type,
+                                                scoped_ptr<DemuxerData> data,
+                                                size_t index) {
   DCHECK_BELONG_TO_MEDIA_LOOP();
   // DemuxerStream::Read() always returns the read callback asynchronously.
   DemuxerStream* stream =
       (type == DemuxerStream::AUDIO) ? audio_stream_ : video_stream_;
   stream->Read(base::Bind(
       &MediaSourceDelegate::OnBufferReady,
-      media_weak_this_.GetWeakPtr(), type, base::Passed(&params), index));
+      media_weak_this_.GetWeakPtr(), type, base::Passed(&data), index));
 }
 
 void MediaSourceDelegate::OnBufferReady(
     media::DemuxerStream::Type type,
-    scoped_ptr<MediaPlayerHostMsg_ReadFromDemuxerAck_Params> params,
+    scoped_ptr<DemuxerData> data,
     size_t index,
     DemuxerStream::Status status,
     const scoped_refptr<media::DecoderBuffer>& buffer) {
   DCHECK_BELONG_TO_MEDIA_LOOP();
   DVLOG(1) << "OnBufferReady(" << index << ", " << status << ", "
            << ((!buffer || buffer->end_of_stream()) ?
                -1 : buffer->timestamp().InMilliseconds())
            << ") : " << player_id_;
   DCHECK(demuxer_);
 
   // No new OnReadFromDemuxer() will be called during seeking. So this callback
   // must be from previous OnReadFromDemuxer() call and should be ignored.
   if (IsSeeking()) {
     DVLOG(1) << "OnBufferReady(): Ignore previous read during seeking.";
     return;
   }
 
   bool is_audio = (type == DemuxerStream::AUDIO);
   if (status != DemuxerStream::kAborted &&
-      index >= params->access_units.size()) {
+      index >= data->access_units.size()) {
     LOG(ERROR) << "The internal state inconsistency onBufferReady: "
                << (is_audio ? "Audio" : "Video") << ", index " << index
-               <<", size " << params->access_units.size()
+               << ", size " << data->access_units.size()
                << ", status " << static_cast<int>(status);
     NOTREACHED();
     return;
   }
 
   switch (status) {
     case DemuxerStream::kAborted:
       DVLOG(1) << "OnBufferReady() : Aborted";
-      params->access_units[index].status = status;
-      params->access_units.resize(index + 1);
+      data->access_units[index].status = status;
+      data->access_units.resize(index + 1);
       break;
 
     case DemuxerStream::kConfigChanged:
       // In case of kConfigChanged, need to read decoder_config once
       // for the next reads.
       // TODO(kjyoun): Investigate if we need to use this new config. See
       // http://crbug.com/255783
       if (is_audio) {
         audio_stream_->audio_decoder_config();
       } else {
         gfx::Size size = video_stream_->video_decoder_config().coded_size();
         DVLOG(1) << "Video config is changed: " << size.width() << "x"
                  << size.height();
       }
-      params->access_units[index].status = status;
-      params->access_units.resize(index + 1);
+      data->access_units[index].status = status;
+      data->access_units.resize(index + 1);
       break;
 
     case DemuxerStream::kOk:
-      params->access_units[index].status = status;
+      data->access_units[index].status = status;
       if (buffer->end_of_stream()) {
-        params->access_units[index].end_of_stream = true;
-        params->access_units.resize(index + 1);
+        data->access_units[index].end_of_stream = true;
+        data->access_units.resize(index + 1);
         break;
       }
       // TODO(ycheo): We assume that the inputed stream will be decoded
       // right away.
       // Need to implement this properly using MediaPlayer.OnInfoListener.
       if (is_audio) {
         statistics_.audio_bytes_decoded += buffer->data_size();
       } else {
         statistics_.video_bytes_decoded += buffer->data_size();
         statistics_.video_frames_decoded++;
       }
-      params->access_units[index].timestamp = buffer->timestamp();
-      params->access_units[index].data = std::vector<uint8>(
+      data->access_units[index].timestamp = buffer->timestamp();
+      data->access_units[index].data = std::vector<uint8>(
           buffer->data(),
           buffer->data() + buffer->data_size());
 #if !defined(GOOGLE_TV)
       // Vorbis needs 4 extra bytes padding on Android. Check
       // NuMediaExtractor.cpp in Android source code.
       if (is_audio && media::kCodecVorbis ==
           audio_stream_->audio_decoder_config().codec()) {
-        params->access_units[index].data.insert(
-            params->access_units[index].data.end(), kVorbisPadding,
+        data->access_units[index].data.insert(
+            data->access_units[index].data.end(), kVorbisPadding,
             kVorbisPadding + 4);
       }
 #endif
       if (buffer->decrypt_config()) {
-        params->access_units[index].key_id = std::vector<char>(
+        data->access_units[index].key_id = std::vector<char>(
             buffer->decrypt_config()->key_id().begin(),
             buffer->decrypt_config()->key_id().end());
-        params->access_units[index].iv = std::vector<char>(
+        data->access_units[index].iv = std::vector<char>(
             buffer->decrypt_config()->iv().begin(),
             buffer->decrypt_config()->iv().end());
-        params->access_units[index].subsamples =
+        data->access_units[index].subsamples =
             buffer->decrypt_config()->subsamples();
       }
-      if (++index < params->access_units.size()) {
-        ReadFromDemuxerStream(type, params.Pass(), index);
+      if (++index < data->access_units.size()) {
+        ReadFromDemuxerStream(type, data.Pass(), index);
         return;
       }
       break;
 
     default:
       NOTREACHED();
   }
 
 #if defined(GOOGLE_TV)
-  send_read_from_demuxer_ack_cb_.Run(params.Pass());
+  send_read_from_demuxer_ack_cb_.Run(data.Pass());
 #else
-  SendReadFromDemuxerAck(params.Pass());
+  SendReadFromDemuxerAck(data.Pass());
 #endif
 }
 
-void MediaSourceDelegate::SendReadFromDemuxerAck(
-    scoped_ptr<MediaPlayerHostMsg_ReadFromDemuxerAck_Params> params) {
+void MediaSourceDelegate::SendReadFromDemuxerAck(scoped_ptr<DemuxerData> data) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   if (!IsSeeking() && proxy_)
-    proxy_->ReadFromDemuxerAck(player_id_, *params);
+    proxy_->ReadFromDemuxerAck(player_id_, *data);
 }
 
 void MediaSourceDelegate::OnDemuxerError(media::PipelineStatus status) {
   DVLOG(1) << "OnDemuxerError(" << status << ") : " << player_id_;
   // |update_network_state_cb_| is bound to the main thread.
   if (status != media::PIPELINE_OK && !update_network_state_cb_.is_null())
     update_network_state_cb_.Run(PipelineErrorToNetworkState(status));
 }
 
 void MediaSourceDelegate::OnDemuxerInitDone(media::PipelineStatus status) {
@@ skipping 213 matching lines @@
   if (HasEncryptedStream() && !key_added_)
     return false;
   return true;
 }
 
 void MediaSourceDelegate::NotifyDemuxerReady() {
   DCHECK_BELONG_TO_MEDIA_LOOP();
   DVLOG(1) << "NotifyDemuxerReady() : " << player_id_;
   DCHECK(CanNotifyDemuxerReady());
 
-  scoped_ptr<MediaPlayerHostMsg_DemuxerReady_Params> params(
-      new MediaPlayerHostMsg_DemuxerReady_Params());
+  scoped_ptr<DemuxerConfigs> configs(new DemuxerConfigs());
   if (audio_stream_) {
     media::AudioDecoderConfig config = audio_stream_->audio_decoder_config();
-    params->audio_codec = config.codec();
-    params->audio_channels =
+    configs->audio_codec = config.codec();
+    configs->audio_channels =
         media::ChannelLayoutToChannelCount(config.channel_layout());
-    params->audio_sampling_rate = config.samples_per_second();
-    params->is_audio_encrypted = config.is_encrypted();
-    params->audio_extra_data = std::vector<uint8>(
+    configs->audio_sampling_rate = config.samples_per_second();
+    configs->is_audio_encrypted = config.is_encrypted();
+    configs->audio_extra_data = std::vector<uint8>(
         config.extra_data(), config.extra_data() + config.extra_data_size());
   }
   if (video_stream_) {
     media::VideoDecoderConfig config = video_stream_->video_decoder_config();
-    params->video_codec = config.codec();
-    params->video_size = config.natural_size();
-    params->is_video_encrypted = config.is_encrypted();
-    params->video_extra_data = std::vector<uint8>(
+    configs->video_codec = config.codec();
+    configs->video_size = config.natural_size();
+    configs->is_video_encrypted = config.is_encrypted();
+    configs->video_extra_data = std::vector<uint8>(
         config.extra_data(), config.extra_data() + config.extra_data_size());
   }
-  params->duration_ms = GetDurationMs();
-  params->key_system = HasEncryptedStream() ? key_system_ : "";
+  configs->duration_ms = GetDurationMs();
+  configs->key_system = HasEncryptedStream() ? key_system_ : "";
 
 #if defined(GOOGLE_TV)
-  send_demuxer_ready_cb_.Run(params.Pass());
+  send_demuxer_ready_cb_.Run(configs.Pass());
 #else
-  SendDemuxerReady(params.Pass());
+  SendDemuxerReady(configs.Pass());
 #endif
 }
 
-void MediaSourceDelegate::SendDemuxerReady(
-    scoped_ptr<MediaPlayerHostMsg_DemuxerReady_Params> params) {
+void MediaSourceDelegate::SendDemuxerReady(scoped_ptr<DemuxerConfigs> configs) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   if (proxy_)
-    proxy_->DemuxerReady(player_id_, *params);
+    proxy_->DemuxerReady(player_id_, *configs);
 }
 
 int MediaSourceDelegate::GetDurationMs() {
   DCHECK_BELONG_TO_MEDIA_LOOP();
   if (!chunk_demuxer_)
     return -1;
 
   double duration_ms = chunk_demuxer_->GetDuration() * 1000;
   if (duration_ms > std::numeric_limits<int32>::max()) {
     LOG(WARNING) << "Duration from ChunkDemuxer is too large; probably "
@@ skipping 41 matching lines @@
   base::AutoLock auto_lock(seeking_lock_);
   seeking_ = seeking;
 }
 
 bool MediaSourceDelegate::IsSeeking() const {
   base::AutoLock auto_lock(seeking_lock_);
   return seeking_;
 }
 
 }  // namespace content