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

media/base/android/media_decoder_job.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 "media/base/android/media_decoder_job.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/android/media_codec_bridge.h"
@@ skipping 16 matching lines @@
       needs_flush_(false),
       input_eos_encountered_(false),
       weak_this_(this),
       request_data_cb_(request_data_cb),
       access_unit_index_(0),
       stop_decode_pending_(false) {
 }
 
 MediaDecoderJob::~MediaDecoderJob() {}
 
-void MediaDecoderJob::OnDataReceived(
-    const MediaPlayerHostMsg_ReadFromDemuxerAck_Params& params) {
+void MediaDecoderJob::OnDataReceived(const DemuxerData& data) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(!on_data_received_cb_.is_null());
 
   base::Closure done_cb = base::ResetAndReturn(&on_data_received_cb_);
 
   if (stop_decode_pending_) {
     OnDecodeCompleted(DECODE_STOPPED, kNoTimestamp(), 0);
     return;
   }
 
   access_unit_index_ = 0;
-  received_data_ = params;
+  received_data_ = data;
   done_cb.Run();
 }
 
 bool MediaDecoderJob::HasData() const {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   return access_unit_index_ < received_data_.access_units.size();
 }
 
 void MediaDecoderJob::Prefetch(const base::Closure& prefetch_cb) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
@@ skipping 23 matching lines @@
                            base::Unretained(this),
                            start_time_ticks,
                            start_presentation_timestamp));
     return true;
   }
 
   if (DemuxerStream::kConfigChanged ==
       received_data_.access_units[access_unit_index_].status) {
     // Clear received data because we need to handle a config change.
     decode_cb_.Reset();
-    received_data_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
+    received_data_ = DemuxerData();
     access_unit_index_ = 0;
     return false;
   }
 
   DecodeNextAccessUnit(start_time_ticks, start_presentation_timestamp);
   return true;
 }
 
 void MediaDecoderJob::StopDecode() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(is_decoding());
   stop_decode_pending_ = true;
 }
 
 void MediaDecoderJob::Flush() {
   DCHECK(decode_cb_.is_null());
 
   // Do nothing, flush when the next Decode() happens.
   needs_flush_ = true;
 
-  received_data_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
+  received_data_ = DemuxerData();
   access_unit_index_ = 0;
   on_data_received_cb_.Reset();
 }
 
 void MediaDecoderJob::Release() {
   // If is_decoding() returns false, there is nothing running on the decoder
   // thread. So it is safe to delete the MediaDecoderJob on the UI thread.
   // However, if we post a task to the decoder thread to delete object, then we
   // cannot immediately pass the surface to a new MediaDecoderJob instance
   // because the java surface is still owned by the old object. New decoder
@@ skipping 45 matching lines @@
         &unit.subsamples[0], unit.subsamples.size(), unit.timestamp);
   }
 
   return DECODE_SUCCEEDED;
 }
 
 void MediaDecoderJob::RequestData(const base::Closure& done_cb) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(on_data_received_cb_.is_null());
 
-  received_data_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
+  received_data_ = DemuxerData();
   access_unit_index_ = 0;
   on_data_received_cb_ = done_cb;
 
   request_data_cb_.Run();
 }
 
 void MediaDecoderJob::DecodeNextAccessUnit(
     const base::TimeTicks& start_time_ticks,
     const base::TimeDelta& start_presentation_timestamp) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
@@ skipping 105 matching lines @@
       status != MediaDecoderJob::DECODE_INPUT_END_OF_STREAM) {
     access_unit_index_++;
   }
 
   stop_decode_pending_ = false;
   base::ResetAndReturn(&decode_cb_).Run(status, presentation_timestamp,
                                         audio_output_bytes);
 }
 
 }  // namespace media