Fix webrtcAudioPrivate API to handle requests from <webview>s.

chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.cc

 // Copyright 2013 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 "chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_output_controller.h"
 
 namespace extensions {
 
 using content::BrowserThread;
-using content::RenderViewHost;
+using content::RenderProcessHost;
 using media::AudioDeviceNames;
 using media::AudioManager;
 
 namespace wap = api::webrtc_audio_private;
 
+using api::webrtc_audio_private::RequestInfo;
+
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<WebrtcAudioPrivateEventService> > g_factory =
     LAZY_INSTANCE_INITIALIZER;
 
 WebrtcAudioPrivateEventService::WebrtcAudioPrivateEventService(
     content::BrowserContext* context)
     : browser_context_(context) {
   // In unit tests, the SystemMonitor may not be created.
   base::SystemMonitor* system_monitor = base::SystemMonitor::Get();
   if (system_monitor)
@@ skipping 81 matching lines @@
       base::Bind(&WebrtcAudioPrivateFunction::OnOutputDeviceNames,
                  this,
                  Passed(&device_names)));
 }
 
 void WebrtcAudioPrivateFunction::OnOutputDeviceNames(
     scoped_ptr<AudioDeviceNames> device_names) {
   NOTREACHED();
 }
 
-bool WebrtcAudioPrivateFunction::GetControllerList(int tab_id) {
-  content::WebContents* contents = NULL;
-  if (!ExtensionTabUtil::GetTabById(
-          tab_id, GetProfile(), true, NULL, NULL, &contents, NULL)) {
-    error_ = extensions::ErrorUtils::FormatErrorMessage(
-        extensions::tabs_constants::kTabNotFoundError,
-        base::IntToString(tab_id));
+bool WebrtcAudioPrivateFunction::GetControllerList(const RequestInfo& request) {
+  content::RenderProcessHost* rhp = NULL;

[tommi (sloooow) - chröme, 2015/01/30 20:17:39]

nit: rph

(also, should we use nullptr?)

+
+  // If |guest_process_id| is defined, directly use this id to find the
+  // corresponding RenderProcessHost.
+  if (request.guest_process_id.get()) {
+    rhp = content::RenderProcessHost::FromID(*request.guest_process_id.get());
+  } else if (request.tab_id.get()) {
+    int tab_id = *request.tab_id.get();
+    content::WebContents* contents = NULL;
+    if (!ExtensionTabUtil::GetTabById(tab_id, GetProfile(), true, NULL, NULL,
+                                      &contents, NULL)) {
+      error_ = extensions::ErrorUtils::FormatErrorMessage(
+          extensions::tabs_constants::kTabNotFoundError,
+          base::IntToString(tab_id));
+      return false;
+    }
+    rhp = contents->GetRenderProcessHost();
+  } else {
     return false;
   }
 
-  RenderViewHost* rvh = contents->GetRenderViewHost();
-  if (!rvh)
+  if (!rhp)
     return false;
 
-  rvh->GetAudioOutputControllers(base::Bind(
-      &WebrtcAudioPrivateFunction::OnControllerList, this));
+  rhp->GetAudioOutputControllers(
+      base::Bind(&WebrtcAudioPrivateFunction::OnControllerList, this));
   return true;
 }
 
 void WebrtcAudioPrivateFunction::OnControllerList(
-    const content::RenderViewHost::AudioOutputControllerList& list) {
+    const content::RenderProcessHost::AudioOutputControllerList& list) {
   NOTREACHED();
 }
 
 void WebrtcAudioPrivateFunction::CalculateHMAC(const std::string& raw_id) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&WebrtcAudioPrivateFunction::CalculateHMAC, this, raw_id));
     return;
@@ skipping 83 matching lines @@
 }
 
 bool WebrtcAudioPrivateGetActiveSinkFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   InitResourceContext();
 
   scoped_ptr<wap::GetActiveSink::Params> params(
       wap::GetActiveSink::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  return GetControllerList(params->tab_id);
+  return GetControllerList(params->request);
 }
 
 void WebrtcAudioPrivateGetActiveSinkFunction::OnControllerList(
-    const RenderViewHost::AudioOutputControllerList& controllers) {
+    const RenderProcessHost::AudioOutputControllerList& controllers) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (controllers.empty()) {
     // If there is no current audio stream for the rvh, we return an
     // empty string as the sink ID.
     DVLOG(2) << "chrome.webrtcAudioPrivate.getActiveSink: No controllers.";
     results_.reset(
         wap::GetActiveSink::Results::Create(std::string()).release());
     SendResponse(true);
   } else {
@@ skipping 16 matching lines @@
   std::string result = hmac_id;
   if (result.empty()) {
     DVLOG(2) << "Received empty ID, replacing with default ID.";
     result = media::AudioManagerBase::kDefaultDeviceId;
   }
   results_.reset(wap::GetActiveSink::Results::Create(result).release());
   SendResponse(true);
 }
 
 WebrtcAudioPrivateSetActiveSinkFunction::
-WebrtcAudioPrivateSetActiveSinkFunction()
-    : tab_id_(0),
-      num_remaining_sink_ids_(0) {
+    WebrtcAudioPrivateSetActiveSinkFunction()
+    : num_remaining_sink_ids_(0) {
 }
 
 WebrtcAudioPrivateSetActiveSinkFunction::
 ~WebrtcAudioPrivateSetActiveSinkFunction() {
 }
 
 bool WebrtcAudioPrivateSetActiveSinkFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<wap::SetActiveSink::Params> params(
       wap::SetActiveSink::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   InitResourceContext();
 
-  tab_id_ = params->tab_id;
+  if (params->request.guest_process_id.get()) {
+    request_info_.guest_process_id.reset(
+        new int(*params->request.guest_process_id.get()));
+  } else if (params->request.tab_id.get()) {
+    request_info_.tab_id.reset(new int(*params->request.tab_id.get()));
+  } else {
+    return false;
+  }
+
   sink_id_ = params->sink_id;
 
-  return GetControllerList(tab_id_);
+  return GetControllerList(request_info_);
 }
 
 void WebrtcAudioPrivateSetActiveSinkFunction::OnControllerList(
-    const RenderViewHost::AudioOutputControllerList& controllers) {
+    const RenderProcessHost::AudioOutputControllerList& controllers) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
+  std::string requested_process_type;
+  int requested_process_id;
+  if (request_info_.guest_process_id.get()) {
+    requested_process_type = "guestProcessId";
+    requested_process_id = *request_info_.guest_process_id.get();
+  } else {
+    requested_process_type = "tabId";
+    requested_process_id = *request_info_.tab_id.get();
+  }
+
   controllers_ = controllers;
   num_remaining_sink_ids_ = controllers_.size();
   if (num_remaining_sink_ids_ == 0) {
     error_ = extensions::ErrorUtils::FormatErrorMessage(
-        "No active stream for tab with id: *.",
-        base::IntToString(tab_id_));
+        "No active stream for " + requested_process_type,
+        base::IntToString(requested_process_id));
     SendResponse(false);
   } else {
     // We need to get the output device names, and calculate the HMAC
     // for each, to find the raw ID for the ID provided to this API
     // function call.
     GetOutputDeviceNames();
   }
 }
 
 void WebrtcAudioPrivateSetActiveSinkFunction::OnOutputDeviceNames(
@@ skipping 11 matching lines @@
       if (sink_id_ == CalculateHMACImpl(it->unique_id)) {
         raw_sink_id = it->unique_id;
         break;
       }
     }
 
     if (raw_sink_id.empty())
       DVLOG(2) << "Found no matching raw sink ID for HMAC " << sink_id_;
   }
 
-  RenderViewHost::AudioOutputControllerList::const_iterator it =
+  RenderProcessHost::AudioOutputControllerList::const_iterator it =
       controllers_.begin();
   for (; it != controllers_.end(); ++it) {
     (*it)->SwitchOutputDevice(raw_sink_id, base::Bind(
         &WebrtcAudioPrivateSetActiveSinkFunction::SwitchDone, this));
   }
 }
 
 void WebrtcAudioPrivateSetActiveSinkFunction::SwitchDone() {
   if (--num_remaining_sink_ids_ == 0) {
     BrowserThread::PostTask(
@@ skipping 100 matching lines @@
     results_.reset(wap::GetAssociatedSink::Results::Create("").release());
   } else {
     results_.reset(
         wap::GetAssociatedSink::Results::Create(associated_sink_id).release());
   }
 
   SendResponse(true);
 }
 
 }  // namespace extensions