Have Permission{Manager,Service} use Origin.

chrome/browser/media/protected_media_identifier_permission_context.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/media/protected_media_identifier_permission_context.h"
 
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
@@ skipping 37 matching lines @@
 }
 
 ProtectedMediaIdentifierPermissionContext::
     ~ProtectedMediaIdentifierPermissionContext() {
 }
 
 #if defined(OS_CHROMEOS)
 void ProtectedMediaIdentifierPermissionContext::RequestPermission(
     content::WebContents* web_contents,
     const PermissionRequestID& id,
-    const GURL& requesting_origin,
+    const url::Origin& requesting_origin,
     const BrowserPermissionCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // First check if this permission has been disabled. This check occurs before
   // the call to GetPermissionStatus, which will return CONTENT_SETTING_BLOCK
   // if the kill switch is on.
   //
   // TODO(xhwang): Remove this kill switch block when crbug.com/454847 is fixed
   // and we no longer call GetPermissionStatus before
   // PermissionContextBase::RequestPermission.
   if (IsPermissionKillSwitchOn()) {
     // Log to the developer console.
     web_contents->GetMainFrame()->AddMessageToConsole(
         content::CONSOLE_MESSAGE_LEVEL_LOG,
         base::StringPrintf(
             "%s permission has been blocked.",
             PermissionUtil::GetPermissionString(
                 content::PermissionType::PROTECTED_MEDIA_IDENTIFIER)
                 .c_str()));
     // The kill switch is enabled for this permission; Block all requests and
     // run the callback immediately.
     callback.Run(CONTENT_SETTING_BLOCK);
     return;
   }
 
-  GURL embedding_origin = web_contents->GetLastCommittedURL().GetOrigin();
+  const url::Origin embedding_origin(web_contents->GetLastCommittedURL());
 
-  DVLOG(1) << __FUNCTION__ << ": (" << requesting_origin.spec() << ", "
-           << embedding_origin.spec() << ")";
+  DVLOG(1) << __FUNCTION__ << ": (" << requesting_origin << ", "
+           << embedding_origin << ")";
 
   ContentSetting content_setting =
       GetPermissionStatus(requesting_origin, embedding_origin);
 
   if (content_setting == CONTENT_SETTING_ALLOW ||
       content_setting == CONTENT_SETTING_BLOCK) {
     NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
                         false /* persist */, content_setting);
     return;
   }
@@ skipping 17 matching lines @@
       base::Bind(&ProtectedMediaIdentifierPermissionContext::
                      OnPlatformVerificationConsentResponse,
                  weak_factory_.GetWeakPtr(), web_contents, id,
                  requesting_origin, embedding_origin, callback));
   pending_requests_.insert(
       std::make_pair(web_contents, std::make_pair(widget, id)));
 }
 #endif  // defined(OS_CHROMEOS)
 
 ContentSetting ProtectedMediaIdentifierPermissionContext::GetPermissionStatus(
-      const GURL& requesting_origin,
-      const GURL& embedding_origin) const {
+    const url::Origin& requesting_origin,
+    const url::Origin& embedding_origin) const {
   DVLOG(1) << __FUNCTION__ << ": (" << requesting_origin.spec() << ", "
            << embedding_origin.spec() << ")";
 
   if (!requesting_origin.is_valid() || !embedding_origin.is_valid() ||
       !IsProtectedMediaIdentifierEnabled()) {
     return CONTENT_SETTING_BLOCK;
   }
 
   ContentSetting content_setting = PermissionContextBase::GetPermissionStatus(
       requesting_origin, embedding_origin);
@@ skipping 24 matching lines @@
   // will simply be dropped.
   if (!web_contents->IsBeingDestroyed())
     widget->Close();
 #else
   PermissionContextBase::CancelPermissionRequest(web_contents, id);
 #endif
 }
 
 void ProtectedMediaIdentifierPermissionContext::UpdateTabContext(
     const PermissionRequestID& id,
-    const GURL& requesting_frame,
+    const url::Origin& requesting_frame,
     bool allowed) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // WebContents may have gone away.
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::GetForFrame(id.render_process_id(),
                                               id.render_frame_id());
   if (content_settings) {
     content_settings->OnProtectedMediaIdentifierPermissionSet(
         requesting_frame.GetOrigin(), allowed);
@@ skipping 38 matching lines @@
 #endif
 
   return true;
 }
 
 #if defined(OS_CHROMEOS)
 void ProtectedMediaIdentifierPermissionContext::
     OnPlatformVerificationConsentResponse(
         content::WebContents* web_contents,
         const PermissionRequestID& id,
-        const GURL& requesting_origin,
-        const GURL& embedding_origin,
+        const url::Origin& requesting_origin,
+        const url::Origin& embedding_origin,
         const BrowserPermissionCallback& callback,
         PlatformVerificationDialog::ConsentResponse response) {
   // The request may have been canceled. Drop the callback in that case.
   PendingRequestMap::iterator request = pending_requests_.find(web_contents);
   if (request == pending_requests_.end())
     return;
 
   DCHECK(request->second.second == id);
   pending_requests_.erase(request);
 
@@ skipping 18 matching lines @@
       content_setting = CONTENT_SETTING_BLOCK;
       persist = true;
       break;
   }
 
   NotifyPermissionSet(
       id, requesting_origin, embedding_origin, callback,
       persist, content_setting);
 }
 #endif