Cleanup: Pass std::string as const reference if possible

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 <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 64 matching lines @@
 
   void SetUp() override {
     CastMediaShlib::Initialize(
         base::CommandLine::ForCurrentProcess()->argv());
   }
 
   void TearDown() override {
     CastMediaShlib::Finalize();
   }
 
-  void ConfigureForFile(std::string filename);
-  void ConfigureForAudioOnly(std::string filename);
-  void ConfigureForVideoOnly(std::string filename, bool raw_h264);
+  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
   void SetPausePattern(const std::vector<PauseInfo> pattern);
 
   // Adds a pause to the end of pause pattern
   void AddPause(base::TimeDelta delay, base::TimeDelta length);
 
   void Start();
 
  private:
   void Initialize();
 
-  void LoadAudioStream(std::string filename);
-  void LoadVideoStream(std::string filename, bool raw_h264);
+  void LoadAudioStream(const std::string& filename);
+  void LoadVideoStream(const std::string& filename, bool raw_h264);
 
   void MonitorLoop();
 
   void OnPauseCompleted();
 
   void OnEos(MediaComponentDeviceFeederForTest* device_feeder);
 
   scoped_ptr<TaskRunnerImpl> task_runner_;
   scoped_ptr<MediaPipelineBackend> backend_;
   MediaClockDevice* media_clock_device_;
@@ skipping 22 matching lines @@
 void AudioVideoPipelineDeviceTest::AddPause(base::TimeDelta delay,
                                             base::TimeDelta length) {
   pause_pattern_.push_back(PauseInfo(delay, length));
 }
 
 void AudioVideoPipelineDeviceTest::SetPausePattern(
     const std::vector<PauseInfo> pattern) {
   pause_pattern_ = pattern;
 }
 
-void AudioVideoPipelineDeviceTest::ConfigureForAudioOnly(std::string filename) {
+void AudioVideoPipelineDeviceTest::ConfigureForAudioOnly(
+    const std::string& filename) {
   Initialize();
   LoadAudioStream(filename);
 }
 
-void AudioVideoPipelineDeviceTest::ConfigureForVideoOnly(std::string filename,
-                                                         bool raw_h264) {
+void AudioVideoPipelineDeviceTest::ConfigureForVideoOnly(
+    const std::string& filename,
+    bool raw_h264) {
   Initialize();
   LoadVideoStream(filename, raw_h264);
 }
 
-void AudioVideoPipelineDeviceTest::ConfigureForFile(std::string filename) {
+void AudioVideoPipelineDeviceTest::ConfigureForFile(
+    const std::string& filename) {
   Initialize();
   LoadVideoStream(filename, false /* raw_h264 */);
   LoadAudioStream(filename);
 }
 
-void AudioVideoPipelineDeviceTest::LoadAudioStream(std::string filename) {
+void AudioVideoPipelineDeviceTest::LoadAudioStream(
+    const std::string& filename) {
   base::FilePath file_path = GetTestDataFilePath(filename);
   DemuxResult demux_result = FFmpegDemuxForTest(file_path, true /* audio */);
   BufferList frames = demux_result.frames;
 
   AudioPipelineDevice* audio_pipeline_device = backend_->GetAudio();
 
   bool success = audio_pipeline_device->SetConfig(
       DecoderConfigAdapter::ToCastAudioConfig(kPrimary,
                                               demux_result.audio_config));
   ASSERT_TRUE(success);
 
   VLOG(2) << "Got " << frames.size() << " audio input frames";
 
   frames.push_back(
       scoped_refptr<DecoderBufferBase>(
           new DecoderBufferAdapter(::media::DecoderBuffer::CreateEOSBuffer())));
 
   MediaComponentDeviceFeederForTest* device_feeder =
       new MediaComponentDeviceFeederForTest(audio_pipeline_device, frames);
   device_feeder->Initialize(base::Bind(&AudioVideoPipelineDeviceTest::OnEos,
                                        base::Unretained(this),
                                        device_feeder));
   component_device_feeders_.push_back(device_feeder);
 }
 
-void AudioVideoPipelineDeviceTest::LoadVideoStream(std::string filename,
+void AudioVideoPipelineDeviceTest::LoadVideoStream(const std::string& filename,
                                                    bool raw_h264) {
   BufferList frames;
   VideoConfig video_config;
 
   if (raw_h264) {
     base::FilePath file_path = GetTestDataFilePath(filename);
     base::MemoryMappedFile video_stream;
     ASSERT_TRUE(video_stream.Initialize(file_path))
         << "Couldn't open stream file: " << file_path.MaybeAsASCII();
     frames = H264SegmenterForTest(video_stream.data(), video_stream.length());
@@ skipping 183 matching lines @@
 TEST_F(AudioVideoPipelineDeviceTest, WebmPlayback) {
   scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   ConfigureForFile("bear-640x360.webm");
   Start();
   message_loop->Run();
 }
 
 }  // namespace media
 }  // namespace chromecast