Store device salt callback instead of resource context in WebRTC Audio Private API

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 <utility>
 
 #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 {
 
@@ skipping 67 matching lines @@
     if (router->ExtensionHasEventListener(extension_id, kEventName) &&
         extension->permissions_data()->HasAPIPermission("webrtcAudioPrivate")) {
       scoped_ptr<Event> event(
           new Event(events::WEBRTC_AUDIO_PRIVATE_ON_SINKS_CHANGED, kEventName,
                     make_scoped_ptr(new base::ListValue())));
       router->DispatchEventToExtension(extension_id, std::move(event));
     }
   }
 }
 
-WebrtcAudioPrivateFunction::WebrtcAudioPrivateFunction()
-    : resource_context_(NULL) {
-}
+WebrtcAudioPrivateFunction::WebrtcAudioPrivateFunction() {}
 
 WebrtcAudioPrivateFunction::~WebrtcAudioPrivateFunction() {
 }
 
 void WebrtcAudioPrivateFunction::GetOutputDeviceNames() {
   scoped_refptr<base::SingleThreadTaskRunner> audio_manager_runner =
       AudioManager::Get()->GetTaskRunner();
   if (!audio_manager_runner->BelongsToCurrentThread()) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     audio_manager_runner->PostTask(
@@ skipping 77 matching lines @@
 
   // We don't hash the default device name, and we always return
   // "default" for the default device. There is code in SetActiveSink
   // that transforms "default" to the empty string, and code in
   // GetActiveSink that ensures we return "default" if we get the
   // empty string as the current device ID.
   if (raw_id.empty() || raw_id == media::AudioManagerBase::kDefaultDeviceId)
     return media::AudioManagerBase::kDefaultDeviceId;
 
   GURL security_origin(source_url().GetOrigin());
-  return content::GetHMACForMediaDeviceID(
-      resource_context()->GetMediaDeviceIDSalt(),
-      security_origin,
-      raw_id);
+  return content::GetHMACForMediaDeviceID(device_id_salt(), security_origin,
+                                          raw_id);
 }
 
-void WebrtcAudioPrivateFunction::InitResourceContext() {
-  resource_context_ = GetProfile()->GetResourceContext();
+void WebrtcAudioPrivateFunction::InitDeviceIDSalt() {
+  device_id_salt_ = GetProfile()->GetResourceContext()->GetMediaDeviceIDSalt();
 }
 
-content::ResourceContext* WebrtcAudioPrivateFunction::resource_context() const {
-  DCHECK(resource_context_);  // Did you forget to InitResourceContext()?
-  return resource_context_;
+const content::ResourceContext::SaltCallback&
+WebrtcAudioPrivateFunction::device_id_salt() const {
+  DCHECK(!device_id_salt_.is_null());
+  return device_id_salt_;
 }
 
 bool WebrtcAudioPrivateGetSinksFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  InitResourceContext();
+  InitDeviceIDSalt();
   GetOutputDeviceNames();
 
   return true;
 }
 
 void WebrtcAudioPrivateGetSinksFunction::OnOutputDeviceNames(
     scoped_ptr<AudioDeviceNames> raw_ids) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   std::vector<linked_ptr<wap::SinkInfo> > results;
@@ skipping 22 matching lines @@
       FROM_HERE,
       base::Bind(&WebrtcAudioPrivateGetSinksFunction::DoneOnUIThread, this));
 }
 
 void WebrtcAudioPrivateGetSinksFunction::DoneOnUIThread() {
   SendResponse(true);
 }
 
 bool WebrtcAudioPrivateGetActiveSinkFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  InitResourceContext();
+  InitDeviceIDSalt();
 
   scoped_ptr<wap::GetActiveSink::Params> params(
       wap::GetActiveSink::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   return GetControllerList(params->request);
 }
 
 void WebrtcAudioPrivateGetActiveSinkFunction::OnControllerList(
     const RenderProcessHost::AudioOutputControllerList& controllers) {
@@ skipping 40 matching lines @@
 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();
+  InitDeviceIDSalt();
 
   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;
   }
 
@@ skipping 81 matching lines @@
 
 WebrtcAudioPrivateGetAssociatedSinkFunction::
 ~WebrtcAudioPrivateGetAssociatedSinkFunction() {
 }
 
 bool WebrtcAudioPrivateGetAssociatedSinkFunction::RunAsync() {
   params_ = wap::GetAssociatedSink::Params::Create(*args_);
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
-  InitResourceContext();
+  InitDeviceIDSalt();
 
   AudioManager::Get()->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&WebrtcAudioPrivateGetAssociatedSinkFunction::
                  GetDevicesOnDeviceThread, this));
 
   return true;
 }
 
 void WebrtcAudioPrivateGetAssociatedSinkFunction::GetDevicesOnDeviceThread() {
@@ skipping 14 matching lines @@
 
   GURL security_origin(params_->security_origin);
   std::string source_id_in_origin(params_->source_id_in_origin);
 
   // Find the raw source ID for source_id_in_origin.
   std::string raw_source_id;
   for (AudioDeviceNames::const_iterator it = source_devices_.begin();
        it != source_devices_.end();
        ++it) {
     const std::string& id = it->unique_id;
-    if (content::DoesMediaDeviceIDMatchHMAC(
-            resource_context()->GetMediaDeviceIDSalt(),
-            security_origin,
-            source_id_in_origin,
-            id)) {
+    if (content::DoesMediaDeviceIDMatchHMAC(device_id_salt(), security_origin,
+                                            source_id_in_origin, id)) {
       raw_source_id = id;
       DVLOG(2) << "Found raw ID " << raw_source_id
                << " for source ID in origin " << source_id_in_origin;
       break;
     }
   }
 
   AudioManager::Get()->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&WebrtcAudioPrivateGetAssociatedSinkFunction::
@@ skipping 26 matching lines @@
     results_.reset(wap::GetAssociatedSink::Results::Create("").release());
   } else {
     results_.reset(
         wap::GetAssociatedSink::Results::Create(associated_sink_id).release());
   }
 
   SendResponse(true);
 }
 
 }  // namespace extensions