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

media/base/android/media_source_player.cc

 // Copyright (c) 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 "media/base/android/media_source_player.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 173 matching lines @@
       (HasVideo() && !video_decoder_job_)) {
     return;
   }
 
   audio_finished_ = false;
   video_finished_ = false;
   sync_decoder_jobs_ = true;
   SyncAndStartDecoderJobs();
 }
 
-void MediaSourcePlayer::DemuxerReady(
-    const MediaPlayerHostMsg_DemuxerReady_Params& params) {
-  duration_ = base::TimeDelta::FromMilliseconds(params.duration_ms);
+void MediaSourcePlayer::DemuxerReady(const MediaConfigs& configs) {
+  duration_ = base::TimeDelta::FromMilliseconds(configs.duration_ms);
   clock_.SetDuration(duration_);
 
-  audio_codec_ = params.audio_codec;
-  num_channels_ = params.audio_channels;
-  sampling_rate_ = params.audio_sampling_rate;
-  is_audio_encrypted_ = params.is_audio_encrypted;
-  audio_extra_data_ = params.audio_extra_data;
+  audio_codec_ = configs.audio_codec;
+  num_channels_ = configs.audio_channels;
+  sampling_rate_ = configs.audio_sampling_rate;
+  is_audio_encrypted_ = configs.is_audio_encrypted;
+  audio_extra_data_ = configs.audio_extra_data;
   if (HasAudio()) {
     DCHECK_GT(num_channels_, 0);
     audio_timestamp_helper_.reset(new AudioTimestampHelper(sampling_rate_));
     audio_timestamp_helper_->SetBaseTimestamp(GetCurrentTime());
   } else {
     audio_timestamp_helper_.reset();
   }
 
-  video_codec_ = params.video_codec;
-  width_ = params.video_size.width();
-  height_ = params.video_size.height();
-  is_video_encrypted_ = params.is_video_encrypted;
+  video_codec_ = configs.video_codec;
+  width_ = configs.video_size.width();
+  height_ = configs.video_size.height();
+  is_video_encrypted_ = configs.is_video_encrypted;
 
   OnMediaMetadataChanged(duration_, width_, height_, true);
 
   if (pending_event_ & CONFIG_CHANGE_EVENT_PENDING) {
     if (reconfig_audio_decoder_)
       ConfigureAudioDecoderJob();
 
     // If there is a pending surface change, we can merge it with the config
     // change.
     if (reconfig_video_decoder_) {
       pending_event_ &= ~SURFACE_CHANGE_EVENT_PENDING;
       ConfigureVideoDecoderJob();
     }
     pending_event_ &= ~CONFIG_CHANGE_EVENT_PENDING;
     if (playing_)
       StartInternal();
   }
 }
 
-void MediaSourcePlayer::ReadFromDemuxerAck(
-    const MediaPlayerHostMsg_ReadFromDemuxerAck_Params& params) {
-  DCHECK_LT(0u, params.access_units.size());
-  if (params.type == DemuxerStream::AUDIO)
+void MediaSourcePlayer::ReadFromDemuxerAck(const MediaData& data) {
+  DCHECK_LT(0u, data.access_units.size());
+  if (data.type == DemuxerStream::AUDIO)
     waiting_for_audio_data_ = false;
   else
     waiting_for_video_data_ = false;
 
   // If there is a pending seek request, ignore the data from the chunk demuxer.
   // The data will be requested later when OnSeekRequestAck() is called.
   if (pending_event_ & SEEK_EVENT_PENDING)
     return;
 
-  if (params.type == DemuxerStream::AUDIO) {
+  if (data.type == DemuxerStream::AUDIO) {
     DCHECK_EQ(0u, audio_access_unit_index_);
-    received_audio_ = params;
+    received_audio_ = data;
   } else {
     DCHECK_EQ(0u, video_access_unit_index_);
-    received_video_ = params;
+    received_video_ = data;
   }
 
   if (pending_event_ != NO_EVENT_PENDING || !playing_)
     return;
 
   if (sync_decoder_jobs_) {
     SyncAndStartDecoderJobs();
     return;
   }
 
-  if (params.type == DemuxerStream::AUDIO)
+  if (data.type == DemuxerStream::AUDIO)
     DecodeMoreAudio();
   else
     DecodeMoreVideo();
 }
 
 void MediaSourcePlayer::DurationChanged(const base::TimeDelta& duration) {
   duration_ = duration;
   clock_.SetDuration(duration_);
 }
 
@@ skipping 150 matching lines @@
 
 void MediaSourcePlayer::DecodeMoreAudio() {
   DCHECK(!audio_decoder_job_->is_decoding());
   DCHECK(HasAudioData());
 
   if (DemuxerStream::kConfigChanged ==
       received_audio_.access_units[audio_access_unit_index_].status) {
     // Wait for demuxer ready message.
     reconfig_audio_decoder_ = true;
     pending_event_ |= CONFIG_CHANGE_EVENT_PENDING;
-    received_audio_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
+    received_audio_ = MediaData();
     audio_access_unit_index_ = 0;
     ProcessPendingEvents();
     return;
   }
 
   audio_decoder_job_->Decode(
       received_audio_.access_units[audio_access_unit_index_],
       start_time_ticks_, start_presentation_timestamp_,
       base::Bind(&MediaSourcePlayer::MediaDecoderCallback,
                  weak_this_.GetWeakPtr(), true));
 }
 
 void MediaSourcePlayer::DecodeMoreVideo() {
   DVLOG(1) << "DecodeMoreVideo()";
   DCHECK(!video_decoder_job_->is_decoding());
   DCHECK(HasVideoData());
 
   if (DemuxerStream::kConfigChanged ==
       received_video_.access_units[video_access_unit_index_].status) {
     // Wait for demuxer ready message.
     reconfig_video_decoder_ = true;
     pending_event_ |= CONFIG_CHANGE_EVENT_PENDING;
-    received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
+    received_video_ = MediaData();
     video_access_unit_index_ = 0;
     ProcessPendingEvents();
     return;
   }
 
   DVLOG(3) << "VideoDecoderJob::Decode(" << video_access_unit_index_ << ", "
            << start_time_ticks_.ToInternalValue() << ", "
            << start_presentation_timestamp_.InMilliseconds() << ")";
   video_decoder_job_->Decode(
       received_video_.access_units[video_access_unit_index_],
@@ skipping 16 matching lines @@
   }
 }
 
 void MediaSourcePlayer::ClearDecodingData() {
   DVLOG(1) << "ClearDecodingData()";
   if (audio_decoder_job_)
     audio_decoder_job_->Flush();
   if (video_decoder_job_)
     video_decoder_job_->Flush();
   start_time_ticks_ = base::TimeTicks();
-  received_audio_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
-  received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
+  received_audio_ = MediaData();
+  received_video_ = MediaData();
   audio_access_unit_index_ = 0;
   video_access_unit_index_ = 0;
   waiting_for_audio_data_ = false;
   waiting_for_video_data_ = false;
 }
 
 bool MediaSourcePlayer::HasVideo() {
   return kUnknownVideoCodec != video_codec_;
 }
 
@@ skipping 114 matching lines @@
 }
 
 void MediaSourcePlayer::RequestAudioData() {
   DVLOG(2) << "RequestAudioData()";
   DCHECK(HasAudio());
 
   if (waiting_for_audio_data_)
     return;
 
   manager()->OnReadFromDemuxer(player_id(), DemuxerStream::AUDIO);
-  received_audio_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
+  received_audio_ = MediaData();
   audio_access_unit_index_ = 0;
   waiting_for_audio_data_ = true;
 }
 
 void MediaSourcePlayer::RequestVideoData() {
   DVLOG(2) << "RequestVideoData()";
   DCHECK(HasVideo());
   if (waiting_for_video_data_)
     return;
 
   manager()->OnReadFromDemuxer(player_id(), DemuxerStream::VIDEO);
-  received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
+  received_video_ = MediaData();
   video_access_unit_index_ = 0;
   waiting_for_video_data_ = true;
 }
 
 bool MediaSourcePlayer::HasAudioData() const {
   return audio_access_unit_index_ < received_audio_.access_units.size();
 }
 
 bool MediaSourcePlayer::HasVideoData() const {
   return video_access_unit_index_ < received_video_.access_units.size();
 }
 
 void MediaSourcePlayer::SetVolumeInternal() {
   if (audio_decoder_job_ && volume_ >= 0)
     audio_decoder_job_.get()->SetVolume(volume_);
 }
 
 bool MediaSourcePlayer::IsProtectedSurfaceRequired() {
   return is_video_encrypted_ &&
       drm_bridge_ && drm_bridge_->IsProtectedSurfaceRequired();
 }
 
 }  // namespace media