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;
   }
 
   DCHECK_EQ(CONTENT_SETTING_ASK, content_setting);
 
   // Since the dialog is modal, we only support one prompt per |web_contents|.
   // Reject the new one if there is already one pending. See
   // http://crbug.com/447005
   if (pending_requests_.count(web_contents)) {
     callback.Run(CONTENT_SETTING_ASK);
     return;
   }
 
   // On ChromeOS, we don't use PermissionContextBase::RequestPermission() which
   // uses the standard permission infobar/bubble UI. See http://crbug.com/454847
   // Instead, we show the existing platform verification UI.
   // TODO(xhwang): Remove when http://crbug.com/454847 is fixed.
+  const GURL requesting_url(requesting_origin.Serialize());
   views::Widget* widget = PlatformVerificationDialog::ShowDialog(
-      web_contents, requesting_origin,
+      web_contents, requesting_url,
       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 {
-  DVLOG(1) << __FUNCTION__ << ": (" << requesting_origin.spec() << ", "
-           << embedding_origin.spec() << ")";
+    const url::Origin& requesting_origin,
+    const url::Origin& embedding_origin) const {
+  DVLOG(1) << __FUNCTION__ << ": (" << requesting_origin.Serialize() << ", "
+           << embedding_origin.Serialize() << ")";
 
-  if (!requesting_origin.is_valid() || !embedding_origin.is_valid() ||
+  if (requesting_origin.unique() || embedding_origin.unique() ||
       !IsProtectedMediaIdentifierEnabled()) {
     return CONTENT_SETTING_BLOCK;
   }
 
   ContentSetting content_setting = PermissionContextBase::GetPermissionStatus(
       requesting_origin, embedding_origin);
   DCHECK(content_setting == CONTENT_SETTING_ALLOW ||
          content_setting == CONTENT_SETTING_BLOCK ||
          content_setting == CONTENT_SETTING_ASK);
 
@@ skipping 20 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);
+    const GURL requesting_url(requesting_frame.Serialize());
+    content_settings->OnProtectedMediaIdentifierPermissionSet(requesting_url,
+                                                              allowed);
   }
 }
 
 bool
 ProtectedMediaIdentifierPermissionContext::IsRestrictedToSecureOrigins() const {
   return false;
 }
 
 // TODO(xhwang): We should consolidate the "protected content" related pref
 // across platforms.
@@ skipping 28 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