Added initial muted state to stream creation callback, to avoid races.

content/browser/renderer_host/media/audio_input_renderer_host_unittest.cc

 // Copyright 2016 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 "content/browser/renderer_host/media/audio_input_renderer_host.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 59 matching lines @@
 AudioInputHostMsg_CreateStream_Config DefaultConfig() {
   AudioInputHostMsg_CreateStream_Config config;
   config.params = media::AudioParameters::UnavailableDeviceParams();
   config.automatic_gain_control = false;
   config.shared_memory_count = kSharedMemoryCount;
   return config;
 }
 
 class MockRenderer {
  public:
-  MOCK_METHOD5(NotifyStreamCreated,
+  MOCK_METHOD6(NotifyStreamCreated,
                void(int /*stream_id*/,
                     base::SharedMemoryHandle /*handle*/,
                     base::SyncSocket::TransitDescriptor /*socket_desriptor*/,
                     uint32_t /*length*/,
-                    uint32_t /*total_segments*/));
+                    uint32_t /*total_segments*/,
+                    bool initially_muted));
   MOCK_METHOD1(NotifyStreamError, void(int /*stream_id*/));
   MOCK_METHOD0(WasShutDown, void());
 };
 
 // This class overrides Send to intercept the messages that the
 // AudioInputRendererHost sends to the renderer. They are sent to
 // the provided MockRenderer instead.
 class AudioInputRendererHostWithInterception : public AudioInputRendererHost {
  public:
   AudioInputRendererHostWithInterception(
@@ skipping 35 matching lines @@
     return true;
   }
 
   void ShutdownForBadMessage() override { renderer_->WasShutDown(); }
 
   void NotifyRendererStreamCreated(
       int stream_id,
       base::SharedMemoryHandle handle,
       base::SyncSocket::TransitDescriptor socket_descriptor,
       uint32_t length,
-      uint32_t total_segments) {
+      uint32_t total_segments,
+      bool initially_muted) {
     // It's difficult to check that the sync socket and shared memory is
     // valid in the gmock macros, so we check them here.
     EXPECT_NE(base::SyncSocket::UnwrapHandle(socket_descriptor),
               base::SyncSocket::kInvalidHandle);
     base::SharedMemory memory(handle, /*read_only*/ true);
     EXPECT_TRUE(memory.Map(length));
     renderer_->NotifyStreamCreated(stream_id, handle, socket_descriptor, length,
-                                   total_segments);
+                                   total_segments, initially_muted);
     EXPECT_TRUE(memory.Unmap());
     memory.Close();
   }
 
   void NotifyRendererStreamError(int stream_id) {
     renderer_->NotifyStreamError(stream_id);
   }
 
   MockRenderer* renderer_;
 };
@@ skipping 10 matching lines @@
       StreamType type)
       : AudioInputController(std::move(task_runner),
                              event_handler,
                              writer,
                              user_input_monitor,
                              params,
                              type) {
     GetTaskRunnerForTesting()->PostTask(
         FROM_HERE,
         base::BindOnce(&AudioInputController::EventHandler::OnCreated,
-                       base::Unretained(event_handler),
-                       base::Unretained(this)));
+                       base::Unretained(event_handler), base::Unretained(this),
+                       false));
     ON_CALL(*this, EnableDebugRecording(_))
         .WillByDefault(SaveArg<0>(&file_name));
   }
 
   EventHandler* handler() { return GetHandlerForTesting(); }
 
   // File name that we pretend to do a debug recording to, if any.
   base::FilePath debug_file_name() { return file_name; }
 
   void Close(base::OnceClosure cl) override {
@@ skipping 135 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(AudioInputRendererHostTest);
 };
 
 // Checks that a controller is created and a reply is sent when creating a
 // stream.
 TEST_F(AudioInputRendererHostTest, CreateWithDefaultDevice) {
   int session_id =
       Open("Default device", media::AudioDeviceDescription::kDefaultDeviceId);
 
   EXPECT_CALL(renderer_,
-              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount));
+              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount, _));
   EXPECT_CALL(controller_factory_, ControllerCreated());
 
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId, kRenderFrameId, session_id, DefaultConfig()));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_CALL(*controller_factory_.controller(0), DidClose());
 }
 
 // If authorization hasn't been granted, only reply with and error and do
 // nothing else.
 TEST_F(AudioInputRendererHostTest, CreateWithoutAuthorization_Error) {
   EXPECT_CALL(renderer_, NotifyStreamError(kStreamId));
 
   int session_id = 0;
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId, kRenderFrameId, session_id, DefaultConfig()));
   base::RunLoop().RunUntilIdle();
 }
 
 // Like CreateWithDefaultDevice but with a nondefault device.
 TEST_F(AudioInputRendererHostTest, CreateWithNonDefaultDevice) {
   int session_id = Open("Nondefault device", GetRawNondefaultId());
 
   EXPECT_CALL(renderer_,
-              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount));
+              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount, _));
   EXPECT_CALL(controller_factory_, ControllerCreated());
 
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId, kRenderFrameId, session_id, DefaultConfig()));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_CALL(*controller_factory_.controller(0), DidClose());
 }
 
 // Checks that stream is started when calling record.
 TEST_F(AudioInputRendererHostTest, CreateRecordClose) {
   int session_id =
       Open("Default device", media::AudioDeviceDescription::kDefaultDeviceId);
 
   EXPECT_CALL(renderer_,
-              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount));
+              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount, _));
   EXPECT_CALL(controller_factory_, ControllerCreated());
 
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId, kRenderFrameId, session_id, DefaultConfig()));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(*controller_factory_.controller(0), Record());
   EXPECT_CALL(*controller_factory_.controller(0), DidClose());
 
   airh_->OnMessageReceived(AudioInputHostMsg_RecordStream(kStreamId));
   base::RunLoop().RunUntilIdle();
   airh_->OnMessageReceived(AudioInputHostMsg_CloseStream(kStreamId));
   base::RunLoop().RunUntilIdle();
 }
 
 // In addition to the above, also check that a SetVolume message is propagated
 // to the controller.
 TEST_F(AudioInputRendererHostTest, CreateSetVolumeRecordClose) {
   int session_id =
       Open("Default device", media::AudioDeviceDescription::kDefaultDeviceId);
 
   EXPECT_CALL(renderer_,
-              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount));
+              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount, _));
   EXPECT_CALL(controller_factory_, ControllerCreated());
 
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId, kRenderFrameId, session_id, DefaultConfig()));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(*controller_factory_.controller(0), SetVolume(0.5));
   EXPECT_CALL(*controller_factory_.controller(0), Record());
   EXPECT_CALL(*controller_factory_.controller(0), DidClose());
 
   airh_->OnMessageReceived(AudioInputHostMsg_SetVolume(kStreamId, 0.5));
   airh_->OnMessageReceived(AudioInputHostMsg_RecordStream(kStreamId));
   airh_->OnMessageReceived(AudioInputHostMsg_CloseStream(kStreamId));
 
   base::RunLoop().RunUntilIdle();
 }
 
 // Check that a too large volume is treated like a bad message and doesn't
 // reach the controller.
 TEST_F(AudioInputRendererHostTest, SetVolumeTooLarge_BadMessage) {
   int session_id =
       Open("Default device", media::AudioDeviceDescription::kDefaultDeviceId);
 
   EXPECT_CALL(renderer_,
-              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount));
+              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount, _));
   EXPECT_CALL(controller_factory_, ControllerCreated());
 
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId, kRenderFrameId, session_id, DefaultConfig()));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(*controller_factory_.controller(0), DidClose());
   EXPECT_CALL(renderer_, WasShutDown());
 
   airh_->OnMessageReceived(AudioInputHostMsg_SetVolume(kStreamId, 5));
 
   base::RunLoop().RunUntilIdle();
 }
 
 // Like above.
 TEST_F(AudioInputRendererHostTest, SetVolumeNegative_BadMessage) {
   int session_id =
       Open("Default device", media::AudioDeviceDescription::kDefaultDeviceId);
 
   EXPECT_CALL(renderer_,
-              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount));
+              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount, _));
   EXPECT_CALL(controller_factory_, ControllerCreated());
 
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId, kRenderFrameId, session_id, DefaultConfig()));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(*controller_factory_.controller(0), DidClose());
   EXPECT_CALL(renderer_, WasShutDown());
 
   airh_->OnMessageReceived(AudioInputHostMsg_SetVolume(kStreamId, -0.5));
 
   base::RunLoop().RunUntilIdle();
 }
 
 // Checks that a stream_id cannot be reused.
 TEST_F(AudioInputRendererHostTest, CreateTwice_Error) {
   int session_id =
       Open("Default device", media::AudioDeviceDescription::kDefaultDeviceId);
 
   EXPECT_CALL(renderer_,
-              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount));
+              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount, _));
   EXPECT_CALL(renderer_, NotifyStreamError(kStreamId));
   EXPECT_CALL(controller_factory_, ControllerCreated());
 
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId, kRenderFrameId, session_id, DefaultConfig()));
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId, kRenderFrameId, session_id, DefaultConfig()));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(*controller_factory_.controller(0), DidClose());
 }
 
 // Checks that when two streams are created, messages are routed to the correct
 // stream. Also checks that when enabling debug recording, the streams get
 // different file names.
 TEST_F(AudioInputRendererHostTest, TwoStreams) {
   int session_id =
       Open("Default device", media::AudioDeviceDescription::kDefaultDeviceId);
 
   EXPECT_CALL(renderer_,
-              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount));
-  EXPECT_CALL(renderer_,
-              NotifyStreamCreated(kStreamId + 1, _, _, _, kSharedMemoryCount));
+              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount, _));
+  EXPECT_CALL(renderer_, NotifyStreamCreated(kStreamId + 1, _, _, _,
+                                             kSharedMemoryCount, _));
   EXPECT_CALL(controller_factory_, ControllerCreated()).Times(2);
 
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId, kRenderFrameId, session_id, DefaultConfig()));
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId + 1, kRenderFrameId, session_id, DefaultConfig()));
   base::RunLoop().RunUntilIdle();
 
 #if BUILDFLAG(ENABLE_WEBRTC)
   EXPECT_CALL(*controller_factory_.controller(0), EnableDebugRecording(_));
@@ skipping 14 matching lines @@
   EXPECT_CALL(*controller_factory_.controller(1), DidClose());
 }
 
 // Checks that the stream is properly cleaned up and a notification is sent to
 // the renderer when the stream encounters an error.
 TEST_F(AudioInputRendererHostTest, Error_ClosesController) {
   int session_id =
       Open("Default device", media::AudioDeviceDescription::kDefaultDeviceId);
 
   EXPECT_CALL(renderer_,
-              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount));
+              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount, _));
   EXPECT_CALL(controller_factory_, ControllerCreated());
 
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId, kRenderFrameId, session_id, DefaultConfig()));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_CALL(*controller_factory_.controller(0), DidClose());
   EXPECT_CALL(renderer_, NotifyStreamError(kStreamId));
 
   controller_factory_.controller(0)->handler()->OnError(
@@ skipping 11 matching lines @@
       "web-contents-media-stream://%d:%d", kRenderProcessId, kRenderFrameId);
   controls.audio.stream_source = kMediaStreamSourceTab;
   std::string request_label = media_stream_manager_->MakeMediaAccessRequest(
       kRenderProcessId, kRenderFrameId, 0, controls, SecurityOrigin(),
       base::Bind([](const MediaStreamDevices& devices,
                     std::unique_ptr<MediaStreamUIProxy>) {}));
   base::RunLoop().RunUntilIdle();
   int session_id = Open("Tab capture", controls.audio.device_id);
 
   EXPECT_CALL(renderer_,
-              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount));
+              NotifyStreamCreated(kStreamId, _, _, _, kSharedMemoryCount, _));
   EXPECT_CALL(controller_factory_, ControllerCreated());
 
   airh_->OnMessageReceived(AudioInputHostMsg_CreateStream(
       kStreamId, kRenderFrameId, session_id, DefaultConfig()));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(*controller_factory_.controller(0), DidClose());
 }
 
 }  // namespace content