Simplify AudioRendererImpl by using AudioDevice.

content/renderer/media/audio_renderer_impl_unittest.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/time.h"
 #include "content/common/child_process.h"
 #include "content/common/child_thread.h"
-#include "content/common/media/audio_messages.h"
 #include "content/renderer/media/audio_renderer_impl.h"
 #include "content/renderer/mock_content_renderer_client.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ipc/ipc_channel.h"
 #include "media/base/data_buffer.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 15 matching lines @@
   virtual bool UseInProcessPlugins() const { return false; }
   virtual bool HasInitializedMediaLibrary() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockRenderProcess);
 };
 }
 
 // This class defines a set of methods which will be used in combination
 // with NewRunnableMethod to form tasks which will be posted on the
-// IO thread. All methods emulate AudioMessageFilter::Delegate calls.
+// IO thread. This emulates MessageLoop::DestructionObserver.
 class DelegateCaller : public base::RefCountedThreadSafe<DelegateCaller> {
  public:
   explicit DelegateCaller(AudioRendererImpl* renderer)
       : renderer_(renderer) {}
 
-  void OnCreated(base::SharedMemoryHandle handle, uint32 length) {
-    if (renderer_->latency_type() == AudioRendererImpl::kHighLatency) {
-      renderer_->OnCreated(handle, length);
-    } else {
-      renderer_->OnLowLatencyCreated(handle, 0, length);
-    }
-  }
-  void OnStateChanged(AudioStreamState state) {
-    renderer_->OnStateChanged(state);
-  }
-  void OnRequestPacket(AudioBuffersState buffers_state) {
-    renderer_->OnRequestPacket(buffers_state);
-  }
-  void OnVolume(double volume) {
-    renderer_->OnVolume(volume);
-  }
   void DestroyCurrentMessageLoop() {
     renderer_->WillDestroyCurrentMessageLoop();
   }
  private:
   friend class base::RefCountedThreadSafe<DelegateCaller>;
   virtual ~DelegateCaller() {}
 
   scoped_refptr<AudioRendererImpl> renderer_;
   DISALLOW_COPY_AND_ASSIGN(DelegateCaller);
 };
 
 // This task can be posted on the IO thread and will signal an event when
 // done. The caller can then wait for this signal to ensure that no
 // additional tasks remain in the task queue.
 class WaitTask : public Task {
  public:
   explicit WaitTask(base::WaitableEvent* event)
       : event_(event) {}
   virtual ~WaitTask() {}
   virtual void Run() {
     event_->Signal();
   }
 
  private:
   base::WaitableEvent* event_;
   DISALLOW_COPY_AND_ASSIGN(WaitTask);
 };
 
-// Class we would be testing. The only difference between it and "real" one
-// is that test class does not open sockets and launch audio thread.
+// Class we would be testing.
 class TestAudioRendererImpl : public AudioRendererImpl {
  public:
   explicit TestAudioRendererImpl()
       : AudioRendererImpl() {
   }
- private:
-  virtual void CreateSocket(base::SyncSocket::Handle socket_handle) {}
-  virtual void CreateAudioThread() {}
 };
 
 class AudioRendererImplTest
     : public ::testing::Test,
       public IPC::Channel::Listener {
  public:
-  static void SetUpTestCase() {
-    // Set low latency mode, as it soon would be on by default.
-    if (AudioRendererImpl::latency_type() ==
-        AudioRendererImpl::kUninitializedLatency) {
-      AudioRendererImpl::set_latency_type(AudioRendererImpl::kLowLatency);
-    }
-    DCHECK_EQ(AudioRendererImpl::kLowLatency,
-              AudioRendererImpl::latency_type());
-  }
+  static void SetUpTestCase() {}
 
   // IPC::Channel::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) {
       NOTIMPLEMENTED();
       return true;
   }
 
   static const int kSize;
 
   AudioRendererImplTest() {}
   virtual ~AudioRendererImplTest() {}
 
   virtual void SetUp() {
     // This part sets up a RenderThread environment to ensure that
     // RenderThread::current() (<=> TLS pointer) is valid.
     // Main parts are inspired by the RenderViewFakeResourcesTest.
     // Note that, the IPC part is not utilized in this test.
     content::GetContentClient()->set_renderer(&mock_content_renderer_client_);
 
     static const char kThreadName[] = "RenderThread";
     channel_.reset(new IPC::Channel(kThreadName,
         IPC::Channel::MODE_SERVER, this));
     ASSERT_TRUE(channel_->Connect());
 
     mock_process_.reset(new MockRenderProcess);
     render_thread_ = new RenderThreadImpl(kThreadName);
     mock_process_->set_main_thread(render_thread_);
 
-    // Create temporary shared memory.
-    CHECK(shared_mem_.CreateAnonymous(kSize));
-
     // Setup expectations for initialization.
     decoder_ = new media::MockAudioDecoder();
 
     EXPECT_CALL(*decoder_, bits_per_channel())
         .WillRepeatedly(Return(16));
     EXPECT_CALL(*decoder_, channel_layout())
         .WillRepeatedly(Return(CHANNEL_LAYOUT_MONO));
     EXPECT_CALL(*decoder_, samples_per_second())
         .WillRepeatedly(Return(44100));
 
     // Create and initialize the audio renderer.
     renderer_ = new TestAudioRendererImpl();
-    renderer_->set_host(&host_);
     renderer_->Initialize(decoder_, media::NewExpectedClosure(),
                           NewUnderflowClosure());
 
     // Wraps delegate calls into tasks.
     delegate_caller_ = new DelegateCaller(renderer_);
 
     // We need an event to verify that all tasks are done before leaving
     // our tests.
     event_.reset(new base::WaitableEvent(false, false));
-
-    // Duplicate the shared memory handle so both the test and the callee can
-    // close their copy.
-    base::SharedMemoryHandle duplicated_handle;
-    EXPECT_TRUE(shared_mem_.ShareToProcess(base::GetCurrentProcessHandle(),
-      &duplicated_handle));
-
-    // Set things up and ensure that the call comes from the IO thread
-    // as all AudioMessageFilter::Delegate methods.
-    ChildProcess::current()->io_message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&DelegateCaller::OnCreated, delegate_caller_.get(),
-                   duplicated_handle, kSize));
-    WaitForIOThreadCompletion();
   }
 
   virtual void TearDown() {
     mock_process_.reset();
   }
 
   MOCK_METHOD0(OnUnderflow, void());
 
   base::Closure NewUnderflowClosure() {
     return base::Bind(&AudioRendererImplTest::OnUnderflow,
                       base::Unretained(this));
   }
 
  protected:
   // Posts a final task to the IO message loop and waits for completion.
   void WaitForIOThreadCompletion() {
     ChildProcess::current()->io_message_loop()->PostTask(
         FROM_HERE, new WaitTask(event_.get()));
     EXPECT_TRUE(event_->TimedWait(
         base::TimeDelta::FromMilliseconds(TestTimeouts::action_timeout_ms())));
   }
 
   MessageLoopForIO message_loop_;
   content::MockContentRendererClient mock_content_renderer_client_;
   scoped_ptr<IPC::Channel> channel_;
   RenderThreadImpl* render_thread_;  // owned by mock_process_
   scoped_ptr<MockRenderProcess> mock_process_;
-  base::SharedMemory shared_mem_;
-  media::MockFilterHost host_;
   scoped_refptr<media::MockAudioDecoder> decoder_;
   scoped_refptr<AudioRendererImpl> renderer_;
   scoped_ptr<base::WaitableEvent> event_;
   scoped_refptr<DelegateCaller> delegate_caller_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioRendererImplTest);
 };
 
 const int AudioRendererImplTest::kSize = 1024;
@@ skipping 19 matching lines @@
 
   renderer_->Stop(media::NewExpectedClosure());
   WaitForIOThreadCompletion();
 }
 
 TEST_F(AudioRendererImplTest, Stop) {
   // Execute Stop() codepath.
   // Tasks will be posted internally on the IO thread.
   renderer_->Stop(media::NewExpectedClosure());
 
-  // Run AudioMessageFilter::Delegate methods, which can be executed after being
-  // stopped. AudioRendererImpl shouldn't create any messages in this state.
-  // All delegate method calls are posted on the IO thread since it is
-  // a requirement.
-  if (renderer_->latency_type() == AudioRendererImpl::kHighLatency) {
-    ChildProcess::current()->io_message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&DelegateCaller::OnRequestPacket,
-                   delegate_caller_.get(), AudioBuffersState(kSize, 0)));
-  }
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&DelegateCaller::OnStateChanged,
-                 delegate_caller_.get(), kAudioStreamError));
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&DelegateCaller::OnStateChanged,
-                 delegate_caller_.get(), kAudioStreamPlaying));
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&DelegateCaller::OnStateChanged,
-                 delegate_caller_.get(), kAudioStreamPaused));
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&DelegateCaller::OnCreated,
-                 delegate_caller_.get(), shared_mem_.handle(), kSize));
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&DelegateCaller::OnVolume,
-                 delegate_caller_.get(), 0.5));
-
   WaitForIOThreadCompletion();
 
   // It's possible that the upstream decoder replies right after being stopped.
   scoped_refptr<media::Buffer> buffer(new media::DataBuffer(kSize));
   renderer_->ConsumeAudioSamples(buffer);
 }
 
 TEST_F(AudioRendererImplTest, DestroyedMessageLoop_SetPlaybackRate) {
   // Emulate "killing the message loop" and verify that SetPlaybackRate()
   // still works.
@@ skipping 48 matching lines @@
   base::Time time_now = base::Time();  // Null time by default.
   renderer_->set_earliest_end_time(time_now);
   renderer_->UpdateEarliestEndTime(renderer_->bytes_per_second(),
                                    base::TimeDelta::FromMilliseconds(100),
                                    time_now);
   int time_delta = (renderer_->earliest_end_time() - time_now).InMilliseconds();
   EXPECT_EQ(1100, time_delta);
   renderer_->Stop(media::NewExpectedClosure());
   WaitForIOThreadCompletion();
 }