Fix race in MediaDevicesPermissionChecker.

content/browser/renderer_host/media/media_devices_dispatcher_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/media_devices_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <queue>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/test/mock_resource_context.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"
@@ skipping 82 matching lines @@
       const base::Closure& closure,
       const std::vector<std::vector<MediaDeviceInfo>>& devices) {
     enumerated_devices_ = devices;
     closure.Run();
   }
 
   void EnumerateDevicesAndWaitForResult(bool enumerate_audio_input,
                                         bool enumerate_video_input,
                                         bool enumerate_audio_output,
                                         bool permission_override_value = true) {
-    MediaDevicesPermissionChecker permission_checker;
-    permission_checker.OverridePermissionsForTesting(permission_override_value);
-    host_->SetPermissionChecker(permission_checker);
+    host_->SetPermissionChecker(base::MakeUnique<MediaDevicesPermissionChecker>(
+        permission_override_value));
     base::RunLoop run_loop;
     host_->EnumerateDevices(
         enumerate_audio_input, enumerate_video_input, enumerate_audio_output,
         origin_, base::Bind(&MediaDevicesDispatcherHostTest::DevicesEnumerated,
                             base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
 
     ASSERT_FALSE(enumerated_devices_.empty());
     if (enumerate_audio_input)
       EXPECT_FALSE(enumerated_devices_[MEDIA_DEVICE_TYPE_AUDIO_INPUT].empty());
@@ skipping 79 matching lines @@
   bool DoesNotContainLabels(
       const std::vector<std::vector<MediaDeviceInfo>>& enumeration) {
     for (const auto& device_infos : enumeration) {
       if (!DoesNotContainLabels(device_infos))
         return false;
     }
     return true;
   }
 
   void SubscribeAndWaitForResult(bool has_permission) {
-    MediaDevicesPermissionChecker permission_checker;
-    permission_checker.OverridePermissionsForTesting(has_permission);
-    host_->SetPermissionChecker(permission_checker);
+    host_->SetPermissionChecker(
+        base::MakeUnique<MediaDevicesPermissionChecker>(has_permission));
     uint32_t subscription_id = 0u;
     url::Origin origin(GURL("http://localhost"));
     for (size_t i = 0; i < NUM_MEDIA_DEVICE_TYPES; ++i) {
       MediaDeviceType type = static_cast<MediaDeviceType>(i);
       host_->SubscribeDeviceChangeNotifications(type, subscription_id, origin);
       MockMediaDevicesListener device_change_listener;
       host_->SetDeviceChangeListenerForTesting(
           device_change_listener.CreateInterfacePtrAndBind());
       MediaDeviceInfoArray changed_devices;
       EXPECT_CALL(device_change_listener,
@@ skipping 68 matching lines @@
 
 TEST_F(MediaDevicesDispatcherHostTest, SubscribeDeviceChange) {
   SubscribeAndWaitForResult(true);
 }
 
 TEST_F(MediaDevicesDispatcherHostTest, SubscribeDeviceChangeNoAccess) {
   SubscribeAndWaitForResult(false);
 }
 
 };  // namespace content