[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()));
+  GetMediaStreamDispatcher()->StopEnumerateDevices(request_id, AsWeakPtr());

[yzshen1, 2014/07/14 17:19:55]

Is it safe to remove this PostTask()?

If I understand the code correctly:
This method may be called while MediaStreamDispatcher::OnDevicesEnumerated() is
on the stack, without PostTask() it mutates the |requests_| list directly, and
causes the |it| iterator in OnDeviceEnumerated() to be invalidated before it
does ++it.

Right?

[miu, 2014/07/14 19:41:28]

Done.

I removed it because, at one point, I managed to convince myself the "mechanism"
here avoided the re-entrancy issue:
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/p...

However, there are a lot of complex interactions at-play here, so I've decided
to take the safer route and put back the PostTask().  Note, the code here still
had to change because MediaStreamDispatcher no longer provides WeakPtrs to
non-private code.

[yzshen1, 2014/07/14 21:15:32]

I don't think the mechanism can avoid the re-entrancy issue. Even if the
enumeration results are returned asynchronously, 
MediaStreamDispatcher::OnDevicesEnumerated() will be on the stack.

 #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