Implementing AudioOutputDevice authorization timeout

media/audio/audio_output_device_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 <vector>
 
 #include "base/at_exit.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process_handle.h"
 #include "base/sync_socket.h"
 #include "base/task_runner.h"
 #include "base/test/test_timeouts.h"
+#include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/audio/audio_output_device.h"
 #include "media/audio/sample_rates.h"
+#include "media/base/test_helpers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::CancelableSyncSocket;
 using base::SharedMemory;
 using base::SyncSocket;
 using testing::_;
 using testing::DoAll;
 using testing::Invoke;
@@ skipping 59 matching lines @@
  public:
   AudioOutputDeviceTest();
   ~AudioOutputDeviceTest();
 
   void ReceiveAuthorization(OutputDeviceStatus device_status);
   void StartAudioDevice();
   void CreateStream();
   void ExpectRenderCallback();
   void WaitUntilRenderCallback();
   void StopAudioDevice();
+  void CreateDevice(const std::string& device_id);
   void SetDevice(const std::string& device_id);
+  void CheckDeviceStatus(OutputDeviceStatus device_status);
 
  protected:
   // Used to clean up TLS pointers that the test(s) will initialize.
   // Must remain the first member of this class.
   base::ShadowingAtExitManager at_exit_manager_;
   base::MessageLoopForIO io_loop_;
   AudioParameters default_audio_parameters_;
   StrictMock<MockRenderCallback> callback_;
   MockAudioOutputIPC* audio_output_ipc_;  // owned by audio_device_
   scoped_refptr<AudioOutputDevice> audio_device_;
@@ skipping 19 matching lines @@
     : device_status_(OUTPUT_DEVICE_STATUS_ERROR_INTERNAL) {
   default_audio_parameters_.Reset(AudioParameters::AUDIO_PCM_LINEAR,
                                   CHANNEL_LAYOUT_STEREO, 48000, 16, 1024);
   SetDevice(kDefaultDeviceId);
 }
 
 AudioOutputDeviceTest::~AudioOutputDeviceTest() {
   audio_device_ = NULL;
 }
 
-void AudioOutputDeviceTest::SetDevice(const std::string& device_id) {
+void AudioOutputDeviceTest::CreateDevice(const std::string& device_id) {
   audio_output_ipc_ = new MockAudioOutputIPC();
   audio_device_ = new AudioOutputDevice(base::WrapUnique(audio_output_ipc_),
                                         io_loop_.task_runner(), 0, device_id,
                                         url::Origin());
+}
+
+void AudioOutputDeviceTest::SetDevice(const std::string& device_id) {
+  CreateDevice(device_id);
   EXPECT_CALL(*audio_output_ipc_,
               RequestDeviceAuthorization(audio_device_.get(), 0, device_id, _));
   audio_device_->RequestDeviceAuthorization();
   io_loop_.RunUntilIdle();
 
   // Simulate response from browser
   OutputDeviceStatus device_status =
       (device_id == kUnauthorizedDeviceId)
           ? OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED
           : OUTPUT_DEVICE_STATUS_OK;
   ReceiveAuthorization(device_status);
 
   audio_device_->Initialize(default_audio_parameters_,
                             &callback_);
 }
 
+void AudioOutputDeviceTest::CheckDeviceStatus(OutputDeviceStatus status) {
+  EXPECT_EQ(status, audio_device_->GetOutputDeviceInfo().device_status());
+}
+
 void AudioOutputDeviceTest::ReceiveAuthorization(OutputDeviceStatus status) {
   device_status_ = status;
   if (device_status_ != OUTPUT_DEVICE_STATUS_OK)
     EXPECT_CALL(*audio_output_ipc_, CloseStream());
 
   audio_device_->OnDeviceAuthorized(device_status_, default_audio_parameters_,
                                     kDefaultDeviceId);
   io_loop_.RunUntilIdle();
 }
 
@@ skipping 138 matching lines @@
 
   StopAudioDevice();
 }
 
 TEST_P(AudioOutputDeviceTest, UnauthorizedDevice) {
   SetDevice(kUnauthorizedDeviceId);
   StartAudioDevice();
   StopAudioDevice();
 }
 
+TEST_P(AudioOutputDeviceTest, AuthorizationTimedOut) {

[o1ka, 2016/06/10 14:21:09]

Since it takes 4 seconds (= auth timeout value), probably enable it on Windows
only?

+  base::Thread thread("DeviceInfo");
+  thread.Start();
+
+  CreateDevice(kNonDefaultDeviceId);
+  EXPECT_CALL(*audio_output_ipc_,
+              RequestDeviceAuthorization(audio_device_.get(), 0,
+                                         kNonDefaultDeviceId, _));
+  EXPECT_CALL(*audio_output_ipc_, CloseStream());
+  audio_device_->RequestDeviceAuthorization();
+
+  media::WaitableMessageLoopEvent event;
+  // Request device info on another thread.
+  thread.task_runner()->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&AudioOutputDeviceTest::CheckDeviceStatus,
+                 base::Unretained(this), OUTPUT_DEVICE_STATUS_ERROR_INTERNAL),
+      event.GetClosure());
+
+  io_loop_.RunUntilIdle();
+
+  // Runs the loop and waits for |thread| to call event's closure.

[DaleCurtis, 2016/06/10 18:29:19]

Don't use real time if you want to add a test like this. You'll need to inject a
fake timer or have a SetTimeoutForTesting() to something much smaller.

[o1ka, 2016/06/13 13:22:13]

Introduced a timeout parameter in AOD constructor. It also allows to align the
timeout value to make sure it is under kHungRendererDelayMs.

+  event.RunAndWait();
+
+  audio_device_->Stop();
+  io_loop_.RunUntilIdle();
+}
+
 INSTANTIATE_TEST_CASE_P(Render, AudioOutputDeviceTest, Values(false));
 
 }  // namespace media.