Switch stream creation and closing in Chrome audio rendering from IPC to Mojo

content/renderer/media/audio_message_filter_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 <stdint.h>
 
 #include <string>
 
 #include "base/macros.h"
 #include "content/common/media/audio_messages.h"
 #include "content/renderer/media/audio_message_filter.h"
+#include "content/renderer/media/audio_output_client.h"
 #include "media/audio/audio_output_ipc.h"
 #include "testing/gtest/include/gtest/gtest.h"
-
+/*
 namespace content {
 namespace {
 
 const int kRenderFrameId = 2;
 const char kEmptyMatchedDeviceId[] = "";
 
 class MockAudioDelegate : public media::AudioOutputIPCDelegate {
  public:
   MockAudioDelegate() {
     Reset();
@@ skipping 80 matching lines @@
 
 TEST(AudioMessageFilterTest, Basic) {
   base::MessageLoopForIO message_loop;
 
   scoped_refptr<AudioMessageFilter> filter(
       new AudioMessageFilter(message_loop.task_runner()));
 
   MockAudioDelegate delegate;
   const std::unique_ptr<media::AudioOutputIPC> ipc =
       filter->CreateAudioOutputIPC(kRenderFrameId);
+  filter->set_audio_output_client(kRenderFrameId, new AudioOutputClient(NULL));
   static const int kSessionId = 0;
   static const std::string kDeviceId;
   static const url::Origin kSecurityOrigin;
   ipc->RequestDeviceAuthorization(&delegate, kSessionId, kDeviceId,
                                   kSecurityOrigin);
   ipc->CreateStream(&delegate, media::AudioParameters());
   static const int kStreamId = 1;
   EXPECT_EQ(&delegate, filter->delegates_.Lookup(kStreamId));
 
   // AudioMsg_NotifyDeviceAuthorized
   EXPECT_FALSE(delegate.device_authorized_received());
   filter->OnMessageReceived(AudioMsg_NotifyDeviceAuthorized(
       kStreamId, media::OUTPUT_DEVICE_STATUS_OK, MockOutputParams(),
       kEmptyMatchedDeviceId));
   EXPECT_TRUE(delegate.device_authorized_received());
   EXPECT_TRUE(delegate.output_params().Equals(MockOutputParams()));
   delegate.Reset();
 
   // AudioMsg_NotifyStreamCreated
   base::SyncSocket::TransitDescriptor socket_descriptor;
   const uint32_t kLength = 1024;
   EXPECT_FALSE(delegate.created_received());
-  filter->OnMessageReceived(AudioMsg_NotifyStreamCreated(
-      kStreamId, base::SharedMemory::NULLHandle(), socket_descriptor, kLength));
+  filter->OnStreamCreated(kStreamId, base::SharedMemory::NULLHandle(),
+                          socket_descriptor, kLength);
   EXPECT_TRUE(delegate.created_received());
   EXPECT_FALSE(base::SharedMemory::IsHandleValid(delegate.handle()));
   EXPECT_EQ(kLength, delegate.length());
   delegate.Reset();
 
   // AudioMsg_NotifyStreamStateChanged
   EXPECT_FALSE(delegate.state_changed_received());
   filter->OnMessageReceived(
       AudioMsg_NotifyStreamStateChanged(
           kStreamId, media::AUDIO_OUTPUT_IPC_DELEGATE_STATE_PLAYING));
+  filter->OnStreamCreated(kStreamId, base::SharedMemory::NULLHandle(),
+                          socket_descriptor, kLength);
   EXPECT_TRUE(delegate.state_changed_received());
   EXPECT_EQ(media::AUDIO_OUTPUT_IPC_DELEGATE_STATE_PLAYING, delegate.state());
   delegate.Reset();
 
   ipc->CloseStream();
   EXPECT_EQ(static_cast<media::AudioOutputIPCDelegate*>(NULL),
             filter->delegates_.Lookup(kStreamId));
 }
 
 TEST(AudioMessageFilterTest, Delegates) {
   base::MessageLoopForIO message_loop;
 
   scoped_refptr<AudioMessageFilter> filter(
       new AudioMessageFilter(message_loop.task_runner()));
-
+  filter->set_audio_output_client(kRenderFrameId, new AudioOutputClient(NULL));
   MockAudioDelegate delegate1;
   MockAudioDelegate delegate2;
   const std::unique_ptr<media::AudioOutputIPC> ipc1 =
       filter->CreateAudioOutputIPC(kRenderFrameId);
   const std::unique_ptr<media::AudioOutputIPC> ipc2 =
       filter->CreateAudioOutputIPC(kRenderFrameId);
   ipc1->CreateStream(&delegate1, media::AudioParameters());
   ipc2->CreateStream(&delegate2, media::AudioParameters());
   static const int kStreamId1 = 1;
   static const int kStreamId2 = 2;
@@ skipping 22 matching lines @@
   message_loop.RunUntilIdle();
 
   ipc1->CloseStream();
   ipc2->CloseStream();
   EXPECT_EQ(static_cast<media::AudioOutputIPCDelegate*>(NULL),
             filter->delegates_.Lookup(kStreamId1));
   EXPECT_EQ(static_cast<media::AudioOutputIPCDelegate*>(NULL),
             filter->delegates_.Lookup(kStreamId2));
 }
 
-}  // namespace content
+}
+
+  // namespace content
+
+*/