Simplified AudioOutputStream interface.

media/audio/audio_input_controller.cc

 // Copyright (c) 2010 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/audio/audio_input_controller.h"
 #include "media/base/limits.h"
 
 namespace {
 
 const int kMaxInputChannels = 2;
-const int kMaxSamplesPerPacket = media::Limits::kMaxSampleRate;
 
 }  // namespace
 
 namespace media {
 
 // static
 AudioInputController::Factory* AudioInputController::factory_ = NULL;
 
 AudioInputController::AudioInputController(EventHandler* handler)
     : handler_(handler),
       stream_(NULL),
       state_(kEmpty),
       thread_("AudioInputControllerThread") {
 }
 
 AudioInputController::~AudioInputController() {
   DCHECK(kClosed == state_ || kCreated == state_ || kEmpty == state_);
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::Create(
     EventHandler* event_handler,
-    AudioParameters params,
-    int samples_per_packet) {
+    AudioParameters params) {
   if (!params.IsValid() ||

[scherkus (not reviewing), 2010/11/09 02:28:31]

single line

[Sergey Ulanov, 2010/11/09 22:29:58]

Done.

-      (params.channels > kMaxInputChannels) ||
-      (samples_per_packet > kMaxSamplesPerPacket) || (samples_per_packet < 0))
+      (params.channels > kMaxInputChannels))
     return NULL;
 
   if (factory_) {
-    return factory_->Create(event_handler, params, samples_per_packet);
+    return factory_->Create(event_handler, params);
   }
 
   scoped_refptr<AudioInputController> controller(new AudioInputController(
       event_handler));
 
   // Start the thread and post a task to create the audio input stream.
   controller->thread_.Start();
   controller->thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(controller.get(), &AudioInputController::DoCreate,
-                        params, samples_per_packet));
+                        params));
   return controller;
 }
 
 void AudioInputController::Record() {
   DCHECK(thread_.IsRunning());
   thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioInputController::DoRecord));
 }
 
 void AudioInputController::Close() {
   if (!thread_.IsRunning()) {
     // If the thread is not running make sure we are stopped.
     DCHECK_EQ(kClosed, state_);
     return;
   }
 
   // Wait for all tasks to complete on the audio thread.
   thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioInputController::DoClose));
   thread_.Stop();
 }
 
-void AudioInputController::DoCreate(AudioParameters params,
-                                    uint32 samples_per_packet) {
-  stream_ = AudioManager::GetAudioManager()->MakeAudioInputStream(
-      params, samples_per_packet);
+void AudioInputController::DoCreate(AudioParameters params) {
+  stream_ = AudioManager::GetAudioManager()->MakeAudioInputStream(params);
 
   if (!stream_) {
     // TODO(satish): Define error types.
     handler_->OnError(this, 0);
     return;
   }
 
   if (stream_ && !stream_->Open()) {
     stream_->Close();
     stream_ = NULL;
@@ skipping 60 matching lines @@
 }
 
 void AudioInputController::OnError(AudioInputStream* stream, int code) {
   // Handle error on the audio controller thread.
   thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioInputController::DoReportError, code));
 }
 
 }  // namespace media