Introducing DecoderBuffer and general Buffer cleanup.

media/audio/win/audio_low_latency_output_win_unittest.cc

 // Copyright (c) 2012 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 <windows.h>
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/time.h"
 #include "base/path_service.h"
 #include "base/win/scoped_com_initializer.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/win/audio_low_latency_output_win.h"
+#include "media/base/decoder_buffer.h"
 #include "media/base/seekable_buffer.h"
 #include "media/base/test_data_util.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::Between;
 using ::testing::CreateFunctor;
@@ skipping 32 matching lines @@
 // it takes about 20 seconds to play out a file.
 class ReadFromFileAudioSource : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit ReadFromFileAudioSource(const std::string& name)
     : pos_(0),
       previous_call_time_(base::Time::Now()),
       text_file_(NULL),
       elements_to_write_(0) {
     // Reads a test file from media/test/data directory and stores it in
     // a scoped_array.
-    ReadTestDataFile(name, &file_, &file_size_);
+    file_ = ReadTestDataFile(name);
 
     // Creates an array that will store delta times between callbacks.
     // The content of this array will be written to a text file at
     // destruction and can then be used for off-line analysis of the exact
     // timing of callbacks. The text file will be stored in media/test/data.
     delta_times_.reset(new int[kMaxDeltaSamples]);
   }
 
   virtual ~ReadFromFileAudioSource() {
     // Get complete file path to output file in directory containing
@@ skipping 24 matching lines @@
     // These values will be written to a file in the destructor.
     int diff = (base::Time::Now() - previous_call_time_).InMilliseconds();
     previous_call_time_ = base::Time::Now();
     if (elements_to_write_ < kMaxDeltaSamples) {
       delta_times_[elements_to_write_] = diff;
       ++elements_to_write_;
     }
 
     // Use samples read from a data file and fill up the audio buffer
     // provided to us in the callback.
-    if (pos_ + static_cast<int>(max_size) > file_size_)
-      max_size = file_size_ - pos_;
+    if (pos_ + static_cast<int>(max_size) > file_size())
+      max_size = file_size() - pos_;
     if (max_size) {
       memcpy(dest, &file_[pos_], max_size);
       pos_ += max_size;
     }
     return max_size;
   }
 
   virtual void OnError(AudioOutputStream* stream, int code) {}
 
-  int file_size() { return file_size_; }
+  int file_size() { return file_->GetDataSize(); }
 
  private:
-  scoped_array<uint8> file_;
+  scoped_refptr<DecoderBuffer> file_;
   scoped_array<int> delta_times_;
-  int file_size_;
   int pos_;
   base::Time previous_call_time_;
   FILE* text_file_;
   size_t elements_to_write_;
 };
 
 // Convenience method which ensures that we are not running on the build
 // bots and that at least one valid output device can be found. We also
 // verify that we are not running on XP since the low-latency (WASAPI-
 // based) version requires Windows Vista or higher.
@@ skipping 394 matching lines @@
   aos->Start(&file_source);
   base::PlatformThread::Sleep(
       base::TimeDelta::FromMilliseconds(kFileDurationMs));
   aos->Stop();
 
   LOG(INFO) << ">> File playout has stopped.";
   aos->Close();
 }
 
 }  // namespace media