Remove the IPC to request DemuxerConfigs when config changes

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/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/buffers.h"
 
 namespace media {
 
 // Timeout value for media codec operations. Because the first
 // DequeInputBuffer() can take about 150 milliseconds, use 250 milliseconds
 // here. See http://b/9357571.
 static const int kMediaCodecTimeoutInMilliseconds = 250;
 
+static void CopyDemuxerConfig(DemuxerConfigs* src, DemuxerConfigs* dest) {
+  dest->audio_codec = src->audio_codec;
+  dest->audio_channels = src->audio_channels;
+  dest->audio_sampling_rate = src->audio_sampling_rate;
+  dest->is_audio_encrypted = src->is_audio_encrypted;
+  dest->audio_extra_data = src->audio_extra_data;
+  dest->video_codec = src->video_codec;
+  dest->video_size = src->video_size;
+  dest->is_video_encrypted = src->is_video_encrypted;
+  dest->video_extra_data = src->video_extra_data;
+}
+
 MediaDecoderJob::MediaDecoderJob(
     const scoped_refptr<base::SingleThreadTaskRunner>& decoder_task_runner,
     MediaCodecBridge* media_codec_bridge,
     const base::Closure& request_data_cb)
     : ui_task_runner_(base::MessageLoopProxy::current()),
       decoder_task_runner_(decoder_task_runner),
       media_codec_bridge_(media_codec_bridge),
       needs_flush_(false),
       input_eos_encountered_(false),
       output_eos_encountered_(false),
@@ skipping 63 matching lines @@
   if (HasData()) {
     DVLOG(1) << __FUNCTION__ << " : using previously received data";
     ui_task_runner_->PostTask(FROM_HERE, prefetch_cb);
     return;
   }
 
   DVLOG(1) << __FUNCTION__ << " : requesting data";
   RequestData(prefetch_cb);
 }
 
-bool MediaDecoderJob::Decode(
+DemuxerConfigs* MediaDecoderJob::Decode(
     base::TimeTicks start_time_ticks,
     base::TimeDelta start_presentation_timestamp,
     const DecoderCallback& callback) {
   DCHECK(decode_cb_.is_null());
   DCHECK(on_data_received_cb_.is_null());
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   decode_cb_ = callback;
 
   if (!HasData()) {
     RequestData(base::Bind(&MediaDecoderJob::DecodeCurrentAccessUnit,
                            base::Unretained(this),
                            start_time_ticks,
                            start_presentation_timestamp));
-    return true;
+    return NULL;
   }
 
   if (DemuxerStream::kConfigChanged == CurrentAccessUnit().status) {
     // Clear received data because we need to handle a config change.
     decode_cb_.Reset();
-    ClearData();
-    return false;
+    size_t index = CurrentReceivedDataChunkIndex();
+    CHECK_EQ(1u, received_data_[index].demuxer_configs.size());
+    DemuxerConfigs* config = new DemuxerConfigs();
+    CopyDemuxerConfig(&(received_data_[index].demuxer_configs[0]), config);

[wolenetz, 2014/05/06 19:06:11]

Perhaps my C++ fu is failing me, but:

Since DemuxerConfigs is a struct, can't we just do *config =
received_data_[index].demuxer_configs[0] here?

Or even better just put it in the constructor like DemuxerConfigs* config = new
DemuxerConfigs(received_data_[index].demuxer_configs[0])?

Or (my preferred option) conform to chromium smart pointer guidelines
(http://www.chromium.org/developers/smart-pointer-guidelines) and replace the
last three lines of this method with:
return scoped_ptr<DemuxerConfigs>(new
DemuxerConfigs(received_data_[index].demuxer_configs[0]));
(and change the method declaration + definition to return a
scoped_ptr<DemuxerConfigs> instead of a DemuxerConfigs*.

Each of these options would address my concern that CopyDemuxerConfig(), defined
in this file, is fragile to DemuxerConfigs changes, defined in
demuxer_stream_player_params.h. If we must keep CopyDemuxerConfig,
s/Config/Configs/ please.

[qinmin, 2014/05/06 19:29:34]

Done. passing a scoped_ptr to the caller now


On 2014/05/06 19:06:11, wolenetz wrote:

+    return config;
   }
 
   DecodeCurrentAccessUnit(start_time_ticks, start_presentation_timestamp);
-  return true;
+  return NULL;
 }
 
 void MediaDecoderJob::StopDecode() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(is_decoding());
   stop_decode_pending_ = true;
 }
 
 void MediaDecoderJob::Flush() {
   DCHECK(decode_cb_.is_null());
@@ skipping 313 matching lines @@
   };
 
   stop_decode_pending_ = false;
   base::ResetAndReturn(&decode_cb_).Run(
       status, current_presentation_timestamp, max_presentation_timestamp);
 }
 
 const AccessUnit& MediaDecoderJob::CurrentAccessUnit() const {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(HasData());
-  int index = NoAccessUnitsRemainingInChunk(true) ?
+  size_t index = CurrentReceivedDataChunkIndex();
+  return received_data_[index].access_units[access_unit_index_[index]];
+}
+
+size_t MediaDecoderJob::CurrentReceivedDataChunkIndex() const {
+  return NoAccessUnitsRemainingInChunk(true) ?
       inactive_demuxer_data_index() : current_demuxer_data_index_;
-  return received_data_[index].access_units[access_unit_index_[index]];
 }
 
 bool MediaDecoderJob::NoAccessUnitsRemainingInChunk(
     bool is_active_chunk) const {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   size_t index = is_active_chunk ? current_demuxer_data_index_ :
       inactive_demuxer_data_index();
   return received_data_[index].access_units.size() <= access_unit_index_[index];
 }
 
@@ skipping 25 matching lines @@
 }
 
 void MediaDecoderJob::InitializeReceivedData() {
   for (size_t i = 0; i < 2; ++i) {
     received_data_[i] = DemuxerData();
     access_unit_index_[i] = 0;
   }
 }
 
 }  // namespace media