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

content/renderer/pepper/pepper_platform_audio_input.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_platform_audio_input.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "build/build_config.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/audio_input_message_filter.h"
 #include "content/renderer/pepper/pepper_audio_input_host.h"
 #include "content/renderer/pepper/pepper_media_device_manager.h"
+#include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "media/audio/audio_manager_base.h"
 #include "ppapi/shared_impl/ppb_audio_config_shared.h"
 #include "url/gurl.h"
 
 namespace content {
 
 // static
 PepperPlatformAudioInput* PepperPlatformAudioInput::Create(
-    const base::WeakPtr<RenderViewImpl>& render_view,
+    int render_frame_id,
     const std::string& device_id,
     const GURL& document_url,
     int sample_rate,
     int frames_per_buffer,
     PepperAudioInputHost* client) {
   scoped_refptr<PepperPlatformAudioInput> audio_input(
       new PepperPlatformAudioInput());
-  if (audio_input->Initialize(render_view,
+  if (audio_input->Initialize(render_frame_id,
                               device_id,
                               document_url,
                               sample_rate,
                               frames_per_buffer,
                               client)) {
     // Balanced by Release invoked in
     // PepperPlatformAudioInput::ShutDownOnIOThread().
     audio_input->AddRef();
     return audio_input.get();
   }
@@ skipping 88 matching lines @@
   DCHECK(!ipc_);
   DCHECK(!client_);
   DCHECK(label_.empty());
   DCHECK(!pending_open_device_);
 }
 
 PepperPlatformAudioInput::PepperPlatformAudioInput()
     : client_(NULL),
       main_message_loop_proxy_(base::MessageLoopProxy::current()),
       io_message_loop_proxy_(ChildProcess::current()->io_message_loop_proxy()),
+      render_frame_id_(MSG_ROUTING_NONE),
       create_stream_sent_(false),
       pending_open_device_(false),
       pending_open_device_id_(-1) {}
 
 bool PepperPlatformAudioInput::Initialize(
-    const base::WeakPtr<RenderViewImpl>& render_view,
+    int render_frame_id,
     const std::string& device_id,
     const GURL& document_url,
     int sample_rate,
     int frames_per_buffer,
     PepperAudioInputHost* client) {
   DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
 
-  if (!render_view.get() || !client)
+  RenderFrameImpl* const render_frame =
+      RenderFrameImpl::FromRoutingID(render_frame_id);
+  if (!render_frame || !client)
+    return false;
+
+  render_frame_id_ = render_frame_id;
+  client_ = client;
+
+  if (!GetMediaDeviceManager())
     return false;
 
   ipc_ = RenderThreadImpl::current()
              ->audio_input_message_filter()
-             ->CreateAudioInputIPC(render_view->GetRoutingID());
-
-  render_view_ = render_view;
-  client_ = client;
+             ->CreateAudioInputIPC(render_frame->render_view()->GetRoutingID());
 
   params_.Reset(media::AudioParameters::AUDIO_PCM_LINEAR,
                 media::CHANNEL_LAYOUT_MONO,
                 ppapi::kAudioInputChannels,
                 0,
                 sample_rate,
                 ppapi::kBitsPerAudioInputSample,
                 frames_per_buffer);
 
   // We need to open the device and obtain the label and session ID before
@@ skipping 49 matching lines @@
 }
 
 void PepperPlatformAudioInput::OnDeviceOpened(int request_id,
                                               bool succeeded,
                                               const std::string& label) {
   DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
 
   pending_open_device_ = false;
   pending_open_device_id_ = -1;
 
-  if (succeeded && render_view_.get()) {
+  PepperMediaDeviceManager* const device_manager = GetMediaDeviceManager();
+  if (succeeded && device_manager) {
     DCHECK(!label.empty());
     label_ = label;
 
     if (client_) {
-      int session_id = GetMediaDeviceManager()->GetSessionID(
+      int session_id = device_manager->GetSessionID(
           PP_DEVICETYPE_DEV_AUDIOCAPTURE, label);
       io_message_loop_proxy_->PostTask(
           FROM_HERE,
           base::Bind(&PepperPlatformAudioInput::InitializeOnIOThread,
                      this,
                      session_id));
     } else {
       // Shutdown has occurred.
       CloseDevice();
     }
   } else {
     NotifyStreamCreationFailed();
   }
 }
 
 void PepperPlatformAudioInput::CloseDevice() {
   DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
 
-  if (render_view_.get()) {
-    if (!label_.empty()) {
-      GetMediaDeviceManager()->CloseDevice(label_);
-      label_.clear();
-    }
-    if (pending_open_device_) {
-      GetMediaDeviceManager()->CancelOpenDevice(pending_open_device_id_);
-      pending_open_device_ = false;
-      pending_open_device_id_ = -1;
-    }
+  if (!label_.empty()) {
+    PepperMediaDeviceManager* const device_manager = GetMediaDeviceManager();
+    if (device_manager)
+      device_manager->CloseDevice(label_);
+    label_.clear();
+  }
+  if (pending_open_device_) {
+    PepperMediaDeviceManager* const device_manager = GetMediaDeviceManager();
+    if (device_manager)
+      device_manager->CancelOpenDevice(pending_open_device_id_);
+    pending_open_device_ = false;
+    pending_open_device_id_ = -1;
   }
 }
 
 void PepperPlatformAudioInput::NotifyStreamCreationFailed() {
   DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
 
   if (client_)
     client_->StreamCreationFailed();
 }
 
 PepperMediaDeviceManager* PepperPlatformAudioInput::GetMediaDeviceManager() {
-  return PepperMediaDeviceManager::GetForRenderView(render_view_.get());
+  DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
+
+  RenderFrameImpl* const render_frame =
+      RenderFrameImpl::FromRoutingID(render_frame_id_);
+  return render_frame ?
+      PepperMediaDeviceManager::GetForRenderFrame(render_frame) : NULL;
 }
 
 }  // namespace content