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;
 using testing::Return;
 using testing::WithArgs;
 using testing::StrictMock;
 using testing::Values;
 
 namespace media {
 
 namespace {
 
 const char kDefaultDeviceId[] = "";
 const char kNonDefaultDeviceId[] = "valid-nondefault-device-id";
 const char kUnauthorizedDeviceId[] = "unauthorized-device-id";
+const int kAuthTimeoutForTestingMs = 500;
 
 class MockRenderCallback : public AudioRendererSink::RenderCallback {
  public:
   MockRenderCallback() {}
   virtual ~MockRenderCallback() {}
 
   MOCK_METHOD3(Render,
                int(AudioBus* dest,
                    uint32_t frames_delayed,
                    uint32_t frames_skipped));
@@ skipping 37 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::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(),
+      base::TimeDelta::FromMilliseconds(kAuthTimeoutForTestingMs));
+}
+
 void AudioOutputDeviceTest::SetDevice(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());
+  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) {
+  DCHECK(!io_loop_.task_runner()->BelongsToCurrentThread());
+  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) {
+  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());
+
+  // Request authorization; no reply from the browser.
+  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_TIMED_OUT),
+      event.GetClosure());
+
+  io_loop_.RunUntilIdle();
+
+  // Runs the loop and waits for |thread| to call event's closure.
+  event.RunAndWait();
+
+  audio_device_->Stop();
+  io_loop_.RunUntilIdle();
+}
+
 INSTANTIATE_TEST_CASE_P(Render, AudioOutputDeviceTest, Values(false));
 
 }  // namespace media.