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

content/browser/renderer_host/media/media_stream_dispatcher_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/media_stream_dispatcher_host.h"
 
 #include "content/browser/browser_main_loop.h"
-#include "content/browser/child_process_security_policy_impl.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/render_process_host.h"
 #include "url/gurl.h"
 
 namespace content {
 
 MediaStreamDispatcherHost::MediaStreamDispatcherHost(
     int render_process_id,
     const ResourceContext::SaltCallback& salt_callback,
@@ skipping 103 matching lines @@
 void MediaStreamDispatcherHost::OnChannelClosing() {
   DVLOG(1) << "MediaStreamDispatcherHost::OnChannelClosing";
 
   // Since the IPC sender is gone, close all requesting/requested streams.
   media_stream_manager_->CancelAllRequests(render_process_id_);
 }
 
 MediaStreamDispatcherHost::~MediaStreamDispatcherHost() {
 }
 
-void MediaStreamDispatcherHost::OnGenerateStream(int render_frame_id,
-                                                 int page_request_id,
-                                                 const StreamControls& controls,
-                                                 const GURL& security_origin,
-                                                 bool user_gesture) {
+void MediaStreamDispatcherHost::OnGenerateStream(
+    int render_frame_id,
+    int page_request_id,
+    const StreamControls& controls,
+    const url::Origin& security_origin,
+    bool user_gesture) {
   DVLOG(1) << "MediaStreamDispatcherHost::OnGenerateStream(" << render_frame_id
            << ", " << page_request_id << ", ["
            << " audio:" << controls.audio.requested
-           << " video:" << controls.video.requested << " ], "
-           << security_origin.spec() << ", " << user_gesture << ")";
+           << " video:" << controls.video.requested << " ], " << security_origin
+           << ", " << user_gesture << ")";
 
-  if (!IsURLAllowed(security_origin))
+  if (!MediaStreamManager::IsOriginAllowed(render_process_id_, security_origin))
     return;
 
   media_stream_manager_->GenerateStream(
       this, render_process_id_, render_frame_id, salt_callback_,
       page_request_id, controls, security_origin, user_gesture);
 }
 
 void MediaStreamDispatcherHost::OnCancelGenerateStream(int render_frame_id,
                                                        int page_request_id) {
   DVLOG(1) << "MediaStreamDispatcherHost::OnCancelGenerateStream("
@@ skipping 10 matching lines @@
            << render_frame_id << ", "
            << device_id << ")";
   media_stream_manager_->StopStreamDevice(render_process_id_, render_frame_id,
                                           device_id);
 }
 
 void MediaStreamDispatcherHost::OnEnumerateDevices(
     int render_frame_id,
     int page_request_id,
     MediaStreamType type,
-    const GURL& security_origin) {
+    const url::Origin& security_origin) {
   DVLOG(1) << "MediaStreamDispatcherHost::OnEnumerateDevices("
-           << render_frame_id << ", "
-           << page_request_id << ", "
-           << type << ", "
-           << security_origin.spec() << ")";
+           << render_frame_id << ", " << page_request_id << ", " << type << ", "
+           << security_origin << ")";
 
-  if (!IsURLAllowed(security_origin))
+  if (!MediaStreamManager::IsOriginAllowed(render_process_id_, security_origin))
     return;
 
   media_stream_manager_->EnumerateDevices(
       this, render_process_id_, render_frame_id, salt_callback_,
       page_request_id, type, security_origin);
 }
 
 void MediaStreamDispatcherHost::OnCancelEnumerateDevices(
     int render_frame_id,
     int page_request_id) {
   DVLOG(1) << "MediaStreamDispatcherHost::OnCancelEnumerateDevices("
            << render_frame_id << ", "
            << page_request_id << ")";
   media_stream_manager_->CancelRequest(render_process_id_, render_frame_id,
                                        page_request_id);
 }
 
 void MediaStreamDispatcherHost::OnOpenDevice(
     int render_frame_id,
     int page_request_id,
     const std::string& device_id,
     MediaStreamType type,
-    const GURL& security_origin) {
-  DVLOG(1) << "MediaStreamDispatcherHost::OnOpenDevice("
-           << render_frame_id << ", "
-           << page_request_id << ", device_id: "
-           << device_id.c_str() << ", type: "
-           << type << ", "
-           << security_origin.spec() << ")";
+    const url::Origin& security_origin) {
+  DVLOG(1) << "MediaStreamDispatcherHost::OnOpenDevice(" << render_frame_id
+           << ", " << page_request_id << ", device_id: " << device_id.c_str()
+           << ", type: " << type << ", " << security_origin << ")";
 
-  if (!IsURLAllowed(security_origin))
+  if (!MediaStreamManager::IsOriginAllowed(render_process_id_, security_origin))
     return;
 
   media_stream_manager_->OpenDevice(
       this, render_process_id_, render_frame_id, salt_callback_,
       page_request_id, device_id, type, security_origin);
 }
 
 void MediaStreamDispatcherHost::OnCloseDevice(
     int render_frame_id,
     const std::string& label) {
   DVLOG(1) << "MediaStreamDispatcherHost::OnCloseDevice("
            << render_frame_id << ", "
            << label << ")";
 
   media_stream_manager_->CancelRequest(label);
 }
 
-bool MediaStreamDispatcherHost::IsURLAllowed(const GURL& url) {
-  if (!ChildProcessSecurityPolicyImpl::GetInstance()->CanRequestURL(
-          render_process_id_, url)) {
-    LOG(ERROR) << "MSDH: Renderer requested a URL it's not allowed to use.";
-    return false;
-  }
-
-  return true;
-}
-
 }  // namespace content