[Cross-Site Isolation] Migrate entire MediaStream verticals to be per-RenderFrame.

content/renderer/pepper/pepper_media_device_manager.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 "content/renderer/pepper/pepper_media_device_manager.h"
 
 #include "base/logging.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
-#include "content/renderer/render_view_impl.h"
+#include "content/renderer/render_frame_impl.h"
 #include "ppapi/shared_impl/ppb_device_ref_shared.h"
 
 namespace content {
 
 namespace {
 
 ppapi::DeviceRefData FromStreamDeviceInfo(const StreamDeviceInfo& info) {
   ppapi::DeviceRefData data;
   data.id = info.device.id;
   data.name = info.device.name;
   data.type = PepperMediaDeviceManager::FromMediaStreamType(info.device.type);
   return data;
 }
 
 }  // namespace
 
-PepperMediaDeviceManager* PepperMediaDeviceManager::GetForRenderView(
-    RenderView* render_view) {
+PepperMediaDeviceManager* PepperMediaDeviceManager::GetForRenderFrame(
+    RenderFrame* render_frame) {
   PepperMediaDeviceManager* handler =
-      PepperMediaDeviceManager::Get(render_view);
+      PepperMediaDeviceManager::Get(render_frame);
   if (!handler)
-    handler = new PepperMediaDeviceManager(render_view);
+    handler = new PepperMediaDeviceManager(render_frame);
   return handler;
 }
 
-PepperMediaDeviceManager::PepperMediaDeviceManager(RenderView* render_view)
-    : RenderViewObserver(render_view),
-      RenderViewObserverTracker<PepperMediaDeviceManager>(render_view),
+PepperMediaDeviceManager::PepperMediaDeviceManager(RenderFrame* render_frame)
+    : RenderFrameObserver(render_frame),
+      RenderFrameObserverTracker<PepperMediaDeviceManager>(render_frame),
       next_id_(1) {}
 
 PepperMediaDeviceManager::~PepperMediaDeviceManager() {
   DCHECK(enumerate_callbacks_.empty());
   DCHECK(open_callbacks_.empty());
 }
 
 int PepperMediaDeviceManager::EnumerateDevices(
     PP_DeviceType_Dev type,
     const GURL& document_url,
     const EnumerateDevicesCallback& callback) {
   enumerate_callbacks_[next_id_] = callback;
   int request_id = next_id_++;
 
 #if defined(ENABLE_WEBRTC)
-  GetRenderViewImpl()->media_stream_dispatcher()->EnumerateDevices(
+  GetMediaStreamDispatcher()->EnumerateDevices(
       request_id,
       AsWeakPtr(),
       PepperMediaDeviceManager::FromPepperDeviceType(type),
       document_url.GetOrigin(),
       false);
 #else
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PepperMediaDeviceManager::OnDevicesEnumerated,
                  AsWeakPtr(),
                  request_id,
                  StreamDeviceInfoArray()));
 #endif
 
   return request_id;
 }
 
 void PepperMediaDeviceManager::StopEnumerateDevices(int request_id) {
   enumerate_callbacks_.erase(request_id);
 
 #if defined(ENABLE_WEBRTC)
   // Need to post task since this function might be called inside the callback
   // of EnumerateDevices.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&MediaStreamDispatcher::StopEnumerateDevices,
-                 GetRenderViewImpl()->media_stream_dispatcher()->AsWeakPtr(),
-                 request_id,
-                 AsWeakPtr()));
+      base::Bind(&PepperMediaDeviceManager::StopEnumerateDevicesDelayed,
+                 AsWeakPtr(),
+                 request_id));
 #endif
 }
 
+void PepperMediaDeviceManager::StopEnumerateDevicesDelayed(int request_id) {
+#if defined(ENABLE_WEBRTC)
+  // This method is being invoked by the message loop at some unknown
+  // point-in-time after StopEnumerateDevices().  Therefore, check that
+  // render_frame() is not NULL, in order to guarantee
+  // GetMediaStreamDispatcher() won't return NULL.
+  if (render_frame())
+    GetMediaStreamDispatcher()->StopEnumerateDevices(request_id, AsWeakPtr());
+#endif
+}
+
 int PepperMediaDeviceManager::OpenDevice(PP_DeviceType_Dev type,
                                          const std::string& device_id,
                                          const GURL& document_url,
                                          const OpenDeviceCallback& callback) {
   open_callbacks_[next_id_] = callback;
   int request_id = next_id_++;
 
 #if defined(ENABLE_WEBRTC)
-  GetRenderViewImpl()->media_stream_dispatcher()->OpenDevice(
+  GetMediaStreamDispatcher()->OpenDevice(
       request_id,
       AsWeakPtr(),
       device_id,
       PepperMediaDeviceManager::FromPepperDeviceType(type),
       document_url.GetOrigin());
 #else
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PepperMediaDeviceManager::OnDeviceOpenFailed,
                  AsWeakPtr(),
                  request_id));
 #endif
 
   return request_id;
 }
 
 void PepperMediaDeviceManager::CancelOpenDevice(int request_id) {
   open_callbacks_.erase(request_id);
 
 #if defined(ENABLE_WEBRTC)
-  GetRenderViewImpl()->media_stream_dispatcher()->CancelOpenDevice(request_id,
-                                                                   AsWeakPtr());
+  GetMediaStreamDispatcher()->CancelOpenDevice(request_id, AsWeakPtr());
 #endif
 }
 
 void PepperMediaDeviceManager::CloseDevice(const std::string& label) {
 #if defined(ENABLE_WEBRTC)
-  GetRenderViewImpl()->media_stream_dispatcher()->CloseDevice(label);
+  GetMediaStreamDispatcher()->CloseDevice(label);
 #endif
 }
 
 int PepperMediaDeviceManager::GetSessionID(PP_DeviceType_Dev type,
                                            const std::string& label) {
 #if defined(ENABLE_WEBRTC)
   switch (type) {
     case PP_DEVICETYPE_DEV_AUDIOCAPTURE:
-      return GetRenderViewImpl()->media_stream_dispatcher()->audio_session_id(
-          label, 0);
+      return GetMediaStreamDispatcher()->audio_session_id(label, 0);
     case PP_DEVICETYPE_DEV_VIDEOCAPTURE:
-      return GetRenderViewImpl()->media_stream_dispatcher()->video_session_id(
-          label, 0);
+      return GetMediaStreamDispatcher()->video_session_id(label, 0);
     default:
       NOTREACHED();
       return 0;
   }
 #else
   return 0;
 #endif
 }
 
 void PepperMediaDeviceManager::OnStreamGenerated(
@@ skipping 83 matching lines @@
     // The callback may have been unregistered.
     return;
   }
 
   OpenDeviceCallback callback = iter->second;
   open_callbacks_.erase(iter);
 
   callback.Run(request_id, succeeded, label);
 }
 
-RenderViewImpl* PepperMediaDeviceManager::GetRenderViewImpl() {
-  return static_cast<RenderViewImpl*>(render_view());
+MediaStreamDispatcher* PepperMediaDeviceManager::GetMediaStreamDispatcher()
+    const {
+  DCHECK(render_frame());
+  MediaStreamDispatcher* const dispatcher =
+      static_cast<RenderFrameImpl*>(render_frame())->GetMediaStreamDispatcher();
+  DCHECK(dispatcher);
+  return dispatcher;
 }
 
 }  // namespace content