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

media/base/android/media_source_player_unittest.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 <string>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "media/base/android/media_codec_bridge.h"
@@ skipping 90 matching lines @@
     if (is_audio) {
       return reinterpret_cast<MediaDecoderJob*>(
           player_->audio_decoder_job_.get());
     }
     return reinterpret_cast<MediaDecoderJob*>(
         player_->video_decoder_job_.get());
   }
 
   // Starts an audio decoder job.
   void StartAudioDecoderJob() {
-    MediaPlayerHostMsg_DemuxerReady_Params params;
-    params.audio_codec = kCodecVorbis;
-    params.audio_channels = 2;
-    params.audio_sampling_rate = 44100;
-    params.is_audio_encrypted = false;
-    params.duration_ms = kDefaultDurationInMs;
+    DemuxerConfigs configs;
+    configs.audio_codec = kCodecVorbis;
+    configs.audio_channels = 2;
+    configs.audio_sampling_rate = 44100;
+    configs.is_audio_encrypted = false;
+    configs.duration_ms = kDefaultDurationInMs;
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("vorbis-extradata");
-    params.audio_extra_data = std::vector<uint8>(
+    configs.audio_extra_data = std::vector<uint8>(
         buffer->data(),
         buffer->data() + buffer->data_size());
-    Start(params);
+    Start(configs);
   }
 
   void StartVideoDecoderJob() {
-    MediaPlayerHostMsg_DemuxerReady_Params params;
-    params.video_codec = kCodecVP8;
-    params.video_size = gfx::Size(320, 240);
-    params.is_video_encrypted = false;
-    params.duration_ms = kDefaultDurationInMs;
-    Start(params);
+    DemuxerConfigs configs;
+    configs.video_codec = kCodecVP8;
+    configs.video_size = gfx::Size(320, 240);
+    configs.is_video_encrypted = false;
+    configs.duration_ms = kDefaultDurationInMs;
+    Start(configs);
   }
 
   // Starts decoding the data.
-  void Start(const MediaPlayerHostMsg_DemuxerReady_Params& params) {
-    player_->DemuxerReady(params);
+  void Start(const DemuxerConfigs& configs) {
+    player_->DemuxerReady(configs);
     player_->Start();
   }
 
-  MediaPlayerHostMsg_ReadFromDemuxerAck_Params
-      CreateReadFromDemuxerAckForAudio(int packet_id) {
-    MediaPlayerHostMsg_ReadFromDemuxerAck_Params ack_params;
-    ack_params.type = DemuxerStream::AUDIO;
-    ack_params.access_units.resize(1);
-    ack_params.access_units[0].status = DemuxerStream::kOk;
+  DemuxerData CreateReadFromDemuxerAckForAudio(int packet_id) {
+    DemuxerData data;
+    data.type = DemuxerStream::AUDIO;
+    data.access_units.resize(1);
+    data.access_units[0].status = DemuxerStream::kOk;
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(
         base::StringPrintf("vorbis-packet-%d", packet_id));
-    ack_params.access_units[0].data = std::vector<uint8>(
+    data.access_units[0].data = std::vector<uint8>(
         buffer->data(), buffer->data() + buffer->data_size());
     // Vorbis needs 4 extra bytes padding on Android to decode properly. Check
     // NuMediaExtractor.cpp in Android source code.
     uint8 padding[4] = { 0xff , 0xff , 0xff , 0xff };
-    ack_params.access_units[0].data.insert(
-        ack_params.access_units[0].data.end(), padding, padding + 4);
-    return ack_params;
+    data.access_units[0].data.insert(
+        data.access_units[0].data.end(), padding, padding + 4);
+    return data;
   }
 
-  MediaPlayerHostMsg_ReadFromDemuxerAck_Params
-        CreateReadFromDemuxerAckForVideo() {
-    MediaPlayerHostMsg_ReadFromDemuxerAck_Params ack_params;
-    ack_params.type = DemuxerStream::VIDEO;
-    ack_params.access_units.resize(1);
-    ack_params.access_units[0].status = DemuxerStream::kOk;
+  DemuxerData CreateReadFromDemuxerAckForVideo() {
+    DemuxerData data;
+    data.type = DemuxerStream::VIDEO;
+    data.access_units.resize(1);
+    data.access_units[0].status = DemuxerStream::kOk;
     scoped_refptr<DecoderBuffer> buffer =
         ReadTestDataFile("vp8-I-frame-320x240");
-    ack_params.access_units[0].data = std::vector<uint8>(
+    data.access_units[0].data = std::vector<uint8>(
         buffer->data(), buffer->data() + buffer->data_size());
-    return ack_params;
+    return data;
   }
 
-  MediaPlayerHostMsg_ReadFromDemuxerAck_Params CreateEOSAck(bool is_audio) {
-      MediaPlayerHostMsg_ReadFromDemuxerAck_Params ack_params;
-      ack_params.type = is_audio ? DemuxerStream::AUDIO : DemuxerStream::VIDEO;
-      ack_params.access_units.resize(1);
-      ack_params.access_units[0].status = DemuxerStream::kOk;
-      ack_params.access_units[0].end_of_stream = true;
-      return ack_params;
+  DemuxerData CreateEOSAck(bool is_audio) {
+      DemuxerData data;
+      data.type = is_audio ? DemuxerStream::AUDIO : DemuxerStream::VIDEO;
+      data.access_units.resize(1);
+      data.access_units[0].status = DemuxerStream::kOk;
+      data.access_units[0].end_of_stream = true;
+      return data;
     }
 
   base::TimeTicks StartTimeTicks() {
     return player_->start_time_ticks_;
   }
 
  protected:
   scoped_ptr<MockMediaPlayerManager> manager_;
   scoped_ptr<MediaSourcePlayer> player_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSourcePlayerTest);
 };
 
 TEST_F(MediaSourcePlayerTest, StartAudioDecoderWithValidConfig) {
   if (!MediaCodecBridge::IsAvailable())
     return;
 
   // Test audio decoder job will be created when codec is successfully started.
   StartAudioDecoderJob();
   EXPECT_TRUE(NULL != GetMediaDecoderJob(true));
   EXPECT_EQ(1, manager_->num_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartAudioDecoderWithInvalidConfig) {
   if (!MediaCodecBridge::IsAvailable())
     return;
 
   // Test audio decoder job will not be created when failed to start the codec.
-  MediaPlayerHostMsg_DemuxerReady_Params params;
-  params.audio_codec = kCodecVorbis;
-  params.audio_channels = 2;
-  params.audio_sampling_rate = 44100;
-  params.is_audio_encrypted = false;
-  params.duration_ms = kDefaultDurationInMs;
+  DemuxerConfigs configs;
+  configs.audio_codec = kCodecVorbis;
+  configs.audio_channels = 2;
+  configs.audio_sampling_rate = 44100;
+  configs.is_audio_encrypted = false;
+  configs.duration_ms = kDefaultDurationInMs;
   uint8 invalid_codec_data[] = { 0x00, 0xff, 0xff, 0xff, 0xff };
-  params.audio_extra_data.insert(params.audio_extra_data.begin(),
+  configs.audio_extra_data.insert(configs.audio_extra_data.begin(),
                                  invalid_codec_data, invalid_codec_data + 4);
-  Start(params);
+  Start(configs);
   EXPECT_EQ(NULL, GetMediaDecoderJob(true));
   EXPECT_EQ(0, manager_->num_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartVideoCodecWithValidSurface) {
   if (!MediaCodecBridge::IsAvailable())
     return;
 
   // Test video decoder job will be created when surface is valid.
   scoped_refptr<gfx::SurfaceTexture> surface_texture(
@@ skipping 75 matching lines @@
   player_->OnSeekRequestAck(manager_->last_seek_request_id());
   EXPECT_TRUE(NULL != GetMediaDecoderJob(false));
   EXPECT_EQ(1, manager_->num_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartAfterSeekFinish) {
   if (!MediaCodecBridge::IsAvailable())
     return;
 
   // Test decoder job will not start until all pending seek event is handled.
-  MediaPlayerHostMsg_DemuxerReady_Params params;
-  params.audio_codec = kCodecVorbis;
-  params.audio_channels = 2;
-  params.audio_sampling_rate = 44100;
-  params.is_audio_encrypted = false;
-  params.duration_ms = kDefaultDurationInMs;
-  player_->DemuxerReady(params);
+  DemuxerConfigs configs;
+  configs.audio_codec = kCodecVorbis;
+  configs.audio_channels = 2;
+  configs.audio_sampling_rate = 44100;
+  configs.is_audio_encrypted = false;
+  configs.duration_ms = kDefaultDurationInMs;
+  player_->DemuxerReady(configs);
   EXPECT_EQ(NULL, GetMediaDecoderJob(true));
   EXPECT_EQ(0, manager_->num_requests());
 
   // Initiate a seek
   player_->SeekTo(base::TimeDelta());
   EXPECT_EQ(1u, manager_->last_seek_request_id());
 
   player_->Start();
   EXPECT_EQ(NULL, GetMediaDecoderJob(true));
   EXPECT_EQ(0, manager_->num_requests());
@@ skipping 37 matching lines @@
   EXPECT_EQ(2, manager_->num_requests());
   EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
 }
 
 TEST_F(MediaSourcePlayerTest, DecoderJobsCannotStartWithoutAudio) {
   if (!MediaCodecBridge::IsAvailable())
     return;
 
   // Test that when Start() is called, video decoder jobs will wait for audio
   // decoder job before start decoding the data.
-  MediaPlayerHostMsg_DemuxerReady_Params params;
-  params.audio_codec = kCodecVorbis;
-  params.audio_channels = 2;
-  params.audio_sampling_rate = 44100;
-  params.is_audio_encrypted = false;
+  DemuxerConfigs configs;
+  configs.audio_codec = kCodecVorbis;
+  configs.audio_channels = 2;
+  configs.audio_sampling_rate = 44100;
+  configs.is_audio_encrypted = false;
   scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("vorbis-extradata");
-  params.audio_extra_data = std::vector<uint8>(
+  configs.audio_extra_data = std::vector<uint8>(
       buffer->data(),
       buffer->data() + buffer->data_size());
-  params.video_codec = kCodecVP8;
-  params.video_size = gfx::Size(320, 240);
-  params.is_video_encrypted = false;
-  params.duration_ms = kDefaultDurationInMs;
-  Start(params);
+  configs.video_codec = kCodecVP8;
+  configs.video_size = gfx::Size(320, 240);
+  configs.is_video_encrypted = false;
+  configs.duration_ms = kDefaultDurationInMs;
+  Start(configs);
   EXPECT_EQ(0, manager_->num_requests());
 
   scoped_refptr<gfx::SurfaceTexture> surface_texture(
       new gfx::SurfaceTexture(0));
   gfx::ScopedJavaSurface surface(surface_texture.get());
   player_->SetVideoSurface(surface.Pass());
   EXPECT_EQ(1u, manager_->last_seek_request_id());
   player_->OnSeekRequestAck(manager_->last_seek_request_id());
 
   MediaDecoderJob* audio_decoder_job = GetMediaDecoderJob(true);
@@ skipping 63 matching lines @@
   EXPECT_EQ(2, manager_->num_requests());
 
   // Send EOS.
   player_->ReadFromDemuxerAck(CreateEOSAck(false));
   manager_->message_loop()->Run();
   // No more request for data should be made.
   EXPECT_EQ(2, manager_->num_requests());
 }
 
 }  // namespace media