[Chromecast] Add new volume control API to CastMediaShlib

chromecast/media/cma/backend/audio_video_pipeline_device_unittest.cc

 // Copyright 2014 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 <stdint.h>
 
 #include <limits>
 #include <memory>
 #include <vector>
 
@@ skipping 17 matching lines @@
 #include "base/time/time.h"
 #include "chromecast/base/task_runner_impl.h"
 #include "chromecast/media/cma/base/decoder_buffer_adapter.h"
 #include "chromecast/media/cma/base/decoder_config_adapter.h"
 #include "chromecast/media/cma/test/frame_segmenter_for_test.h"
 #include "chromecast/public/cast_media_shlib.h"
 #include "chromecast/public/media/cast_decoder_buffer.h"
 #include "chromecast/public/media/decoder_config.h"
 #include "chromecast/public/media/media_pipeline_backend.h"
 #include "chromecast/public/media/media_pipeline_device_params.h"
+#include "chromecast/public/volume_control.h"
+#include "media/audio/audio_device_description.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/encryption_scheme.h"
 #include "media/base/video_decoder_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromecast {
 namespace media {
 
@@ skipping 133 matching lines @@
   void set_sync_type(MediaPipelineDeviceParams::MediaSyncType sync_type) {
     sync_type_ = sync_type;
   }
   void set_audio_type(MediaPipelineDeviceParams::AudioStreamType audio_type) {
     audio_type_ = audio_type;
   }
 
   void SetUp() override {
     CastMediaShlib::Initialize(
         base::CommandLine::ForCurrentProcess()->argv());
+    if (VolumeControl::Initialize) {
+      VolumeControl::Initialize(base::CommandLine::ForCurrentProcess()->argv());
+    }
   }
 
   void TearDown() override {
     // Pipeline must be destroyed before finalizing media shlib.
     backend_.reset();
     effects_backends_.clear();
+    if (VolumeControl::Finalize) {
+      VolumeControl::Finalize();
+    }
     CastMediaShlib::Finalize();
   }
 
   void ConfigureForFile(const std::string& filename);
   void ConfigureForAudioOnly(const std::string& filename);
   void ConfigureForVideoOnly(const std::string& filename, bool raw_h264);
 
   // Pattern loops, waiting >= pattern[i].delay against media clock between
   // pauses, then pausing for >= pattern[i].length against MessageLoop
   // A pause with delay <0 signals to stop sequence and do not loop
@@ skipping 402 matching lines @@
       stopped_(false),
       ran_playing_playback_checks_(false),
       backwards_pts_change_(false),
       pause_pattern_() {}
 
 AudioVideoPipelineDeviceTest::~AudioVideoPipelineDeviceTest() {}
 
 void AudioVideoPipelineDeviceTest::Initialize() {
   // Create the media device.
   task_runner_.reset(new TaskRunnerImpl());
-  MediaPipelineDeviceParams params(sync_type_, audio_type_, task_runner_.get());
+  MediaPipelineDeviceParams params(
+      sync_type_, audio_type_, task_runner_.get(), AudioContentType::kMedia,
+      ::media::AudioDeviceDescription::kDefaultDeviceId);
   backend_.reset(CastMediaShlib::CreateMediaPipelineBackend(params));
   CHECK(backend_);
 }
 
 void AudioVideoPipelineDeviceTest::AddPause(base::TimeDelta delay,
                                             base::TimeDelta length) {
   DCHECK_EQ(MediaPipelineDeviceParams::kModeSyncPts, sync_type_);
   pause_pattern_.push_back(PauseInfo(delay, length));
 }
 
 void AudioVideoPipelineDeviceTest::PauseBeforeEos() {
   if (audio_feeder_)
     audio_feeder_->PauseBeforeEos();
   if (video_feeder_)
     video_feeder_->PauseBeforeEos();
 }
 
 void AudioVideoPipelineDeviceTest::AddEffectsStreams() {
   for (int i = 0; i < kNumEffectsStreams; ++i) {
     MediaPipelineDeviceParams params(
         MediaPipelineDeviceParams::kModeIgnorePts,
-        MediaPipelineDeviceParams::kAudioStreamSoundEffects,
-        task_runner_.get());
+        MediaPipelineDeviceParams::kAudioStreamSoundEffects, task_runner_.get(),
+        AudioContentType::kMedia,
+        ::media::AudioDeviceDescription::kDefaultDeviceId);
     MediaPipelineBackend* effects_backend =
         CastMediaShlib::CreateMediaPipelineBackend(params);
     CHECK(effects_backend);
     effects_backends_.push_back(base::WrapUnique(effects_backend));
 
     MediaPipelineBackend::AudioDecoder* audio_decoder =
         effects_backend->CreateAudioDecoder();
     audio_decoder->SetConfig(DefaultAudioConfig());
 
     std::unique_ptr<BufferFeeder> feeder(
@@ skipping 495 matching lines @@
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   ConfigureForFile("bear-640x360.webm");
   PauseBeforeEos();
   AddEffectsStreams();
   Start();
   base::RunLoop().Run();
 }
 
 }  // namespace media
 }  // namespace chromecast