Fix race in MediaDevicesPermissionChecker.

content/browser/renderer_host/media/media_devices_dispatcher_host.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 <utility>
 #include <vector>
@@ skipping 70 matching lines @@
 MediaDevicesDispatcherHost::MediaDevicesDispatcherHost(
     int render_process_id,
     int render_frame_id,
     const std::string& device_id_salt,
     MediaStreamManager* media_stream_manager)
     : render_process_id_(render_process_id),
       render_frame_id_(render_frame_id),
       device_id_salt_(device_id_salt),
       group_id_salt_(ResourceContext::CreateRandomMediaDeviceIDSalt()),
       media_stream_manager_(media_stream_manager),
+      permission_checker_(base::MakeUnique<MediaDevicesPermissionChecker>()),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 MediaDevicesDispatcherHost::~MediaDevicesDispatcherHost() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (size_t i = 0; i < NUM_MEDIA_DEVICE_TYPES; ++i) {
     if (!device_change_subscriptions_[i].empty()) {
       media_stream_manager_->media_devices_manager()
           ->UnsubscribeDeviceChangeNotifications(
@@ skipping 21 matching lines @@
     bad_message::ReceivedBadMessage(render_process_id_,
                                     bad_message::MDDH_UNAUTHORIZED_ORIGIN);
     return;
   }
 
   MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
   devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = request_audio_input;
   devices_to_enumerate[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = request_video_input;
   devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = request_audio_output;
 
-  permission_checker_.CheckPermissions(
+  permission_checker_->CheckPermissions(
       devices_to_enumerate, render_process_id_, render_frame_id_,
       security_origin,
       base::Bind(&MediaDevicesDispatcherHost::DoEnumerateDevices,
                  weak_factory_.GetWeakPtr(), devices_to_enumerate,
                  security_origin, client_callback));
 }
 
 void MediaDevicesDispatcherHost::SubscribeDeviceChangeNotifications(
     MediaDeviceType type,
     uint32_t subscription_id,
@@ skipping 80 matching lines @@
     if (!render_frame_host)
       return;
 
     render_frame_host->GetRemoteInterfaces()->GetInterface(
         mojo::GetProxy(&media_devices_listener));
     if (!media_devices_listener)
       return;
   }
 
   for (const auto& subscription : subscriptions) {
-    bool has_permission = permission_checker_.CheckPermissionOnUIThread(
+    bool has_permission = permission_checker_->CheckPermissionOnUIThread(
         type, render_process_id_, render_frame_id_,
         subscription.security_origin);
     media_devices_listener->OnDevicesChanged(
         type, subscription.subscription_id,
         TranslateMediaDeviceInfoArray(
             has_permission, device_id_salt_, group_id_salt_,
             subscription.security_origin, device_infos));
   }
 }
 
 void MediaDevicesDispatcherHost::SetPermissionChecker(
-    const MediaDevicesPermissionChecker& permission_checker) {
+    std::unique_ptr<MediaDevicesPermissionChecker> permission_checker) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  permission_checker_ = permission_checker;
+  DCHECK(permission_checker);
+  permission_checker_ = std::move(permission_checker);
 }
 
 void MediaDevicesDispatcherHost::SetDeviceChangeListenerForTesting(
     ::mojom::MediaDevicesListenerPtr listener) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   device_change_listener_ = std::move(listener);
 }
 
 void MediaDevicesDispatcherHost::DoEnumerateDevices(
     const MediaDevicesManager::BoolDeviceTypes& requested_types,
@@ skipping 23 matching lines @@
     for (const auto& device_info : enumeration[i]) {
       result[i].push_back(TranslateDeviceInfo(has_permissions[i],
                                               device_id_salt_, group_id_salt_,
                                               security_origin, device_info));
     }
   }
   client_callback.Run(result);
 }
 
 }  // namespace content