Factor out authorization from AudioRendererHost.

content/browser/renderer_host/media/audio_output_authorization_handler_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.
+
+// Unit test for AudioOutputAuthorizationHandlerTest.
+
+#include "content/browser/renderer_host/media/audio_output_authorization_handler.h"
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/run_loop.h"
+#include "content/public/test/mock_render_process_host.h"
+#include "content/public/test/test_browser_context.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "media/audio/audio_device_description.h"
+#include "media/audio/fake_audio_manager.h"
+#include "media/base/media_switches.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+#include "url/origin.h"
+
+using ::testing::_;
+
+const int kRenderProcessId = 1;
+const int kRenderFrameId = 2;
+const char kSecurityOriginString[] = "http://localhost";
+const GURL kSecurityOriginGURL(kSecurityOriginString);
+const url::Origin kSecurityOrigin(kSecurityOriginGURL);
+const char kBadSecurityOriginString[] = "about:about";
+const GURL kBadSecurityOriginGURL(kBadSecurityOriginString);
+const url::Origin kBadSecurityOrigin(kBadSecurityOriginGURL);
+const char kDefaultDeviceId[] = "default";
+const char kEmptyDeviceId[] = "";
+const char kInvalidDeviceId[] = "invalid-device-id";
+const char kSalt[] = "salt";
+
+namespace content {
+
+class AudioOutputAuthorizationHandlerTest : public testing::Test {
+ public:
+  AudioOutputAuthorizationHandlerTest() {
+    audio_manager_ = media::FakeAudioManager::CreateForTesting(
+        base::ThreadTaskRunnerHandle::Get());
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kUseFakeDeviceForMediaStream);
+    media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
+    raw_nondefault_id = GetRawNondefaultFakeId();
+    hashed_nondefault_id = MediaStreamManager::GetHMACForMediaDeviceID(
+        kSalt, kSecurityOrigin, raw_nondefault_id);
+  }
+
+  ~AudioOutputAuthorizationHandlerTest() override {}
+
+ protected:
+  void SetUp() override {}
+
+  void TearDown() override {}
+
+  std::unique_ptr<MediaStreamManager> media_stream_manager_;
+  TestBrowserThreadBundle thread_bundle_;
+  media::ScopedAudioManagerPtr audio_manager_;
+  std::string raw_nondefault_id;
+  std::string hashed_nondefault_id;
+
+ private:
+  std::string GetRawNondefaultFakeId() {
+    MediaDeviceInfoArray devices;
+    MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
+    devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
+
+    media_stream_manager_->media_devices_manager()->EnumerateDevices(
+        devices_to_enumerate,
+        base::Bind(
+            [](MediaDeviceInfoArray* out,
+               const MediaDeviceEnumeration& result) {
+              *out = result[MediaDeviceType::MEDIA_DEVICE_TYPE_AUDIO_OUTPUT];
+            },
+            &devices));
+    base::RunLoop().RunUntilIdle();
+    return devices[1].device_id;  // devices[0] is default.
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(AudioOutputAuthorizationHandlerTest);
+};
+
+struct MockListener {
+  MOCK_METHOD3(MockAuthorizationCallback,
+               void(media::OutputDeviceStatus status,
+                    media::AudioParameters params,
+                    const std::string& id));
+  AudioOutputAuthorizationHandler::AuthorizationCompletedCallback
+  GetCallback() {
+    return base::Bind(&MockListener::MockAuthorizationCallback,
+                      base::Unretained(this));
+  }
+};
+
+TEST_F(AudioOutputAuthorizationHandlerTest, AuthorizeDefaultDevice_Ok) {
+  AudioOutputAuthorizationHandler handler(media_stream_manager_.get(),
+                                          kRenderProcessId, kSalt);
+
+  MockListener listener;
+  EXPECT_CALL(listener,
+              MockAuthorizationCallback(media::OUTPUT_DEVICE_STATUS_OK, _,
+                                        kDefaultDeviceId))
+      .Times(1);
+
+  handler.RequestDeviceAuthorization(kRenderFrameId, /*session_id*/ 0,
+                                     kDefaultDeviceId, kSecurityOrigin,
+                                     listener.GetCallback());
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputAuthorizationHandlerTest,
+       AuthorizeDefaultDeviceByEmptyId_Ok) {
+  AudioOutputAuthorizationHandler handler(media_stream_manager_.get(),
+                                          kRenderProcessId, kSalt);
+
+  MockListener listener;
+  EXPECT_CALL(listener,
+              MockAuthorizationCallback(media::OUTPUT_DEVICE_STATUS_OK, _,
+                                        kDefaultDeviceId))
+      .Times(1);
+
+  handler.RequestDeviceAuthorization(kRenderFrameId, /*session_id*/ 0,
+                                     kEmptyDeviceId, kSecurityOrigin,
+                                     listener.GetCallback());
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputAuthorizationHandlerTest,
+       AuthorizeNonDefaultDeviceIdWithoutPermission_NotAuthorized) {
+  AudioOutputAuthorizationHandler handler(media_stream_manager_.get(),
+                                          kRenderProcessId, kSalt);
+  std::string id = MediaStreamManager::GetHMACForMediaDeviceID(
+      kSalt, kSecurityOrigin, raw_nondefault_id);
+
+  MockListener listener;
+  EXPECT_CALL(listener,
+              MockAuthorizationCallback(
+                  media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED, _, _))
+      .Times(1);
+
+  handler.RequestDeviceAuthorization(kRenderFrameId, /*session_id*/ 0, id,
+                                     kSecurityOrigin, listener.GetCallback());
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputAuthorizationHandlerTest,
+       AuthorizeNonDefaultDeviceIdWithPermission_Ok) {
+  AudioOutputAuthorizationHandler handler(media_stream_manager_.get(),
+                                          kRenderProcessId, kSalt);
+  // Override permissions check.
+  handler.GetMediaDevicesPermissionCheckerForTesting()
+      .OverridePermissionsForTesting(true);
+
+  MockListener listener;
+  EXPECT_CALL(listener,
+              MockAuthorizationCallback(media::OUTPUT_DEVICE_STATUS_OK, _,
+                                        raw_nondefault_id))
+      .Times(1);
+
+  handler.RequestDeviceAuthorization(kRenderFrameId, /*session_id*/ 0,
+                                     hashed_nondefault_id, kSecurityOrigin,
+                                     listener.GetCallback());
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputAuthorizationHandlerTest, AuthorizeInvalidDeviceId_Fails) {
+  AudioOutputAuthorizationHandler handler(media_stream_manager_.get(),
+                                          kRenderProcessId, kSalt);
+
+  MockListener listener;
+  EXPECT_CALL(listener, MockAuthorizationCallback(
+                            media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND, _, _))
+      .Times(1);
+
+  handler.RequestDeviceAuthorization(kRenderFrameId, /*session_id*/ 0,
+                                     kInvalidDeviceId, kSecurityOrigin,
+                                     listener.GetCallback());
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputAuthorizationHandlerTest,
+       AuthorizeNondefaultDeviceIdWithBadOrigin_BadMessage) {
+  TestBrowserContext context;
+  MockRenderProcessHost RPH(&context);
+  AudioOutputAuthorizationHandler handler(media_stream_manager_.get(),
+                                          RPH.GetID(), kSalt);
+
+  MockListener listener;
+  EXPECT_CALL(listener, MockAuthorizationCallback(_, _, _)).Times(0);
+
+  handler.RequestDeviceAuthorization(kRenderFrameId, /*session_id*/ 0,
+                                     hashed_nondefault_id, kBadSecurityOrigin,
+                                     listener.GetCallback());
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(RPH.bad_msg_count(), 1);
+}
+
+}  // namespace content