Use url::Origin to represent security origins in MediaStream-related code.

content/browser/renderer_host/media/audio_renderer_host.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/browser/renderer_host/media/audio_renderer_host.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/browser_main_loop.h"
-#include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/media/audio_stream_monitor.h"
 #include "content/browser/media/capture/audio_mirroring_manager.h"
 #include "content/browser/media/media_internals.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/audio_sync_reader.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/media/audio_messages.h"
 #include "content/public/browser/content_browser_client.h"
@@ skipping 19 matching lines @@
     LAZY_INSTANCE_INITIALIZER;
 
 std::pair<int, std::pair<bool, std::string>> MakeAuthorizationData(
     int stream_id,
     bool authorized,
     const std::string& device_unique_id) {
   return std::make_pair(stream_id,
                         std::make_pair(authorized, device_unique_id));
 }
 
-GURL ConvertToGURL(const url::Origin& origin) {
-  return origin.unique() ? GURL() : GURL(origin.Serialize());
-}
-
 bool IsValidDeviceId(const std::string& device_id) {
   static const std::string::size_type kValidLength = 64;
 
   if (device_id.empty() ||
       device_id == media::AudioDeviceDescription::kDefaultDeviceId ||
       device_id == media::AudioDeviceDescription::kCommunicationsDeviceId) {
     return true;
   }
 
   if (device_id.length() != kValidLength)
@@ skipping 358 matching lines @@
           media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
           static_cast<media::ChannelLayout>(
               info->device.matched_output.channel_layout),
           info->device.matched_output.sample_rate, 16,
           info->device.matched_output.frames_per_buffer);
       output_params.set_effects(info->device.matched_output.effects);
       authorizations_.insert(MakeAuthorizationData(
           stream_id, true, info->device.matched_output_device_id));
       MaybeFixAudioParameters(&output_params);
       // Hash matched device id and pass it to the renderer
-      GURL gurl_security_origin = ConvertToGURL(security_origin);
       Send(new AudioMsg_NotifyDeviceAuthorized(
           stream_id, media::OUTPUT_DEVICE_STATUS_OK, output_params,
-          GetHMACForMediaDeviceID(salt_callback_, gurl_security_origin,
+          GetHMACForMediaDeviceID(salt_callback_, security_origin,
                                   info->device.matched_output_device_id)));
       return;
     }
   }
 
   authorizations_.insert(
       MakeAuthorizationData(stream_id, false, std::string()));
-  GURL gurl_security_origin = ConvertToGURL(security_origin);
   CheckOutputDeviceAccess(
-      render_frame_id, device_id, gurl_security_origin,
+      render_frame_id, device_id, security_origin,
       base::Bind(&AudioRendererHost::OnDeviceAuthorized, this, stream_id,
-                 device_id, gurl_security_origin));
+                 device_id, security_origin));
 }
 
 void AudioRendererHost::OnDeviceAuthorized(int stream_id,
                                            const std::string& device_id,
-                                           const GURL& gurl_security_origin,
+                                           const url::Origin& security_origin,
                                            bool have_access) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const auto& auth_data = authorizations_.find(stream_id);
 
   // A close request was received while access check was in progress.
   if (auth_data == authorizations_.end())
     return;
 
   if (!have_access) {
     authorizations_.erase(auth_data);
@@ skipping 11 matching lines @@
       !media_stream_manager_->audio_output_device_enumerator()
            ->IsCacheEnabled()) {
     base::PostTaskAndReplyWithResult(
         audio_manager_->GetTaskRunner(), FROM_HERE,
         base::Bind(&GetDefaultDeviceInfoOnDeviceThread, audio_manager_),
         base::Bind(&AudioRendererHost::OnDeviceIDTranslated, this, stream_id,
                    true));
   } else {
     media_stream_manager_->audio_output_device_enumerator()->Enumerate(
         base::Bind(&AudioRendererHost::TranslateDeviceID, this, device_id,
-                   gurl_security_origin,
+                   security_origin,
                    base::Bind(&AudioRendererHost::OnDeviceIDTranslated, this,
                               stream_id)));
   }
 }
 
 void AudioRendererHost::OnDeviceIDTranslated(
     int stream_id,
     bool device_found,
     const AudioOutputDeviceInfo& device_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 236 matching lines @@
     AudioEntry* entry = it->second;
     if (entry->render_frame_id() == render_frame_id && entry->playing())
       return true;
   }
   return false;
 }
 
 void AudioRendererHost::CheckOutputDeviceAccess(
     int render_frame_id,
     const std::string& device_id,
-    const GURL& gurl_security_origin,
+    const url::Origin& security_origin,
     const OutputDeviceAccessCB& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Check security origin if nondefault device is requested.
   // Ignore check for default device, which is always authorized.
   if (!media::AudioDeviceDescription::IsDefaultDevice(device_id) &&
-      !ChildProcessSecurityPolicyImpl::GetInstance()->CanRequestURL(
-          render_process_id_, gurl_security_origin)) {
+      !MediaStreamManager::IsOriginAllowed(render_process_id_,
+                                           security_origin)) {
     content::bad_message::ReceivedBadMessage(this,
                                              bad_message::ARH_UNAUTHORIZED_URL);
     return;
   }
 
   if (device_id.empty()) {
     callback.Run(true);
   } else {
     // Check that MediaStream device permissions have been granted,
     // hence the use of a MediaStreamUIProxy.
     std::unique_ptr<MediaStreamUIProxy> ui_proxy = MediaStreamUIProxy::Create();
 
     // Use MEDIA_DEVICE_AUDIO_CAPTURE instead of MEDIA_DEVICE_AUDIO_OUTPUT
     // because MediaStreamUIProxy::CheckAccess does not currently support
     // MEDIA_DEVICE_AUDIO_OUTPUT.
     // TODO(guidou): Change to MEDIA_DEVICE_AUDIO_OUTPUT when support becomes
     // available. http://crbug.com/498675
-    ui_proxy->CheckAccess(gurl_security_origin, MEDIA_DEVICE_AUDIO_CAPTURE,
+    ui_proxy->CheckAccess(security_origin, MEDIA_DEVICE_AUDIO_CAPTURE,
                           render_process_id_, render_frame_id,
                           base::Bind(&AudioRendererHost::AccessChecked, this,
                                      base::Passed(&ui_proxy), callback));
   }
 }
 
 void AudioRendererHost::AccessChecked(
     std::unique_ptr<MediaStreamUIProxy> ui_proxy,
     const OutputDeviceAccessCB& callback,
     bool have_access) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   callback.Run(have_access);
 }
 
 void AudioRendererHost::TranslateDeviceID(
     const std::string& device_id,
-    const GURL& security_origin,
+    const url::Origin& security_origin,
     const OutputDeviceInfoCB& callback,
     const AudioOutputDeviceEnumeration& enumeration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (const AudioOutputDeviceInfo& device_info : enumeration.devices) {
     if (device_id.empty()) {
       if (device_info.unique_id ==
           media::AudioDeviceDescription::kDefaultDeviceId) {
         callback.Run(true, device_info);
         return;
       }
@@ skipping 11 matching lines @@
   callback.Run(false, device_info);
 }
 
 bool AudioRendererHost::IsAuthorizationStarted(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const auto& i = authorizations_.find(stream_id);
   return i != authorizations_.end();
 }
 
 }  // namespace content