Have Permission{Manager,Service} use Origin.

chrome/browser/notifications/notification_permission_context_unittest.cc

 // Copyright 2015 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/notifications/notification_permission_context.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/time/time.h"
@@ skipping 38 matching lines @@
   ContentSetting GetContentSettingFromMap(const GURL& url_a,
                                           const GURL& url_b) {
     return HostContentSettingsMapFactory::GetForProfile(profile())
         ->GetContentSetting(url_a.GetOrigin(), url_b.GetOrigin(),
                             content_settings_type(), std::string());
   }
 
  private:
   // NotificationPermissionContext:
   void NotifyPermissionSet(const PermissionRequestID& id,
-                           const GURL& requesting_origin,
-                           const GURL& embedder_origin,
+                           const url::Origin& requesting_origin,
+                           const url::Origin& embedder_origin,
                            const BrowserPermissionCallback& callback,
                            bool persist,
                            ContentSetting content_setting) override {
     permission_set_count_++;
     last_permission_set_persisted_ = persist;
     last_permission_set_setting_ = content_setting;
     NotificationPermissionContext::NotifyPermissionSet(
         id, requesting_origin, embedder_origin, callback, persist,
         content_setting);
   }
@@ skipping 25 matching lines @@
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> old_task_runner_;
 };
 
 }  // namespace
 
 // Web Notification permission requests will completely ignore the embedder
 // origin. See https://crbug.com/416894.
 TEST_F(NotificationPermissionContextTest, IgnoresEmbedderOrigin) {
-  GURL requesting_origin("https://example.com");
-  GURL embedding_origin("https://chrome.com");
-  GURL different_origin("https://foobar.com");
+  const GURL requesting_url("https://example.com");
+  const url::Origin requesting_origin(requesting_url);
+  const GURL embedding_url("https://chrome.com");
+  const url::Origin embedding_origin(embedding_url);
+  const GURL different_url("https://foobar.com");
+  const url::Origin different_origin(different_url);
 
   NotificationPermissionContext context(profile());
   context.UpdateContentSetting(requesting_origin,
                                embedding_origin,
                                CONTENT_SETTING_ALLOW);
 
   EXPECT_EQ(CONTENT_SETTING_ALLOW,
       context.GetPermissionStatus(requesting_origin, embedding_origin));
 
   EXPECT_EQ(CONTENT_SETTING_ALLOW,
       context.GetPermissionStatus(requesting_origin, different_origin));
 
   context.ResetPermission(requesting_origin, embedding_origin);
 
   EXPECT_EQ(CONTENT_SETTING_ASK,
       context.GetPermissionStatus(requesting_origin, embedding_origin));
 
   EXPECT_EQ(CONTENT_SETTING_ASK,
       context.GetPermissionStatus(requesting_origin, different_origin));
 }
 
 // Web Notifications do not require a secure origin when requesting permission.
 // See https://crbug.com/404095.
 TEST_F(NotificationPermissionContextTest, NoSecureOriginRequirement) {
-  GURL origin("http://example.com");
+  const GURL url("http://example.com");
+  const url::Origin origin("http://example.com");
 
   NotificationPermissionContext context(profile());
-  EXPECT_EQ(CONTENT_SETTING_ASK,
-            context.GetPermissionStatus(origin, origin));
+  EXPECT_EQ(CONTENT_SETTING_ASK, context.GetPermissionStatus(origin, origin));
 
   context.UpdateContentSetting(origin, origin, CONTENT_SETTING_ALLOW);
 
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            context.GetPermissionStatus(origin, origin));
+  EXPECT_EQ(CONTENT_SETTING_ALLOW, context.GetPermissionStatus(origin, origin));
 }
 
 // Tests auto-denial after a time delay in incognito.
 TEST_F(NotificationPermissionContextTest, TestDenyInIncognitoAfterDelay) {
   TestNotificationPermissionContext permission_context(
       profile()->GetOffTheRecordProfile());
-  GURL url("https://www.example.com");
+  const GURL url("https://www.example.com");
   NavigateAndCommit(url);
 
   const PermissionRequestID id(web_contents()->GetRenderProcessHost()->GetID(),
                                web_contents()->GetMainFrame()->GetRoutingID(),
                                -1);
 
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner(SwitchToMockTime());
 
   ASSERT_EQ(0, permission_context.permission_set_count());
   ASSERT_FALSE(permission_context.last_permission_set_persisted());
   ASSERT_EQ(CONTENT_SETTING_DEFAULT,
             permission_context.last_permission_set_setting());
 
-  permission_context.RequestPermission(
-      web_contents(), id, url, base::Bind(&DoNothing));
+  const url::Origin origin(url);
+  permission_context.RequestPermission(web_contents(), id, origin,
+                                       base::Bind(&DoNothing));
 
   // Should be blocked after 1-2 seconds, but the timer is reset whenever the
   // tab is not visible, so these 500ms never add up to >= 1 second.
   for (int n = 0; n < 10; n++) {
     web_contents()->WasShown();
     task_runner->FastForwardBy(base::TimeDelta::FromMilliseconds(500));
     web_contents()->WasHidden();
   }
 
   EXPECT_EQ(0, permission_context.permission_set_count());
@@ skipping 30 matching lines @@
   EXPECT_EQ(CONTENT_SETTING_BLOCK,
             permission_context.last_permission_set_setting());
   EXPECT_EQ(CONTENT_SETTING_BLOCK,
             permission_context.GetContentSettingFromMap(url, url));
 }
 
 // Tests that navigating cancels incognito permission requests without crashing.
 TEST_F(NotificationPermissionContextTest, TestCancelledIncognitoRequest) {
   TestNotificationPermissionContext permission_context(
       profile()->GetOffTheRecordProfile());
-  GURL url("https://www.example.com");
+  const GURL url("https://www.example.com");
   NavigateAndCommit(url);
 
   const PermissionRequestID id(web_contents()->GetRenderProcessHost()->GetID(),
                                web_contents()->GetMainFrame()->GetRoutingID(),
                                -1);
 
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner(SwitchToMockTime());
 
   content::PermissionManager* permission_manager =
       PermissionManagerFactory::GetForProfile(
           profile()->GetOffTheRecordProfile());
 
   // Request and cancel the permission via PermissionManager. That way if
   // https://crbug.com/586944 regresses, then as well as the EXPECT_EQs below
   // failing, PermissionManager::OnPermissionsRequestResponseStatus will crash.
+  const url::Origin origin(url);
   int request_id = permission_manager->RequestPermission(
       content::PermissionType::NOTIFICATIONS, web_contents()->GetMainFrame(),
-      url.GetOrigin(), base::Bind(&DoNothing2));
+      origin, base::Bind(&DoNothing2));
 
   permission_manager->CancelPermissionRequest(request_id);
 
   task_runner->FastForwardBy(base::TimeDelta::FromDays(1));
 
   EXPECT_EQ(0, permission_context.permission_set_count());
   EXPECT_EQ(CONTENT_SETTING_ASK,
             permission_context.GetContentSettingFromMap(url, url));
 }
 
 // Tests how multiple parallel permission requests get auto-denied in incognito.
 TEST_F(NotificationPermissionContextTest, TestParallelDenyInIncognito) {
   TestNotificationPermissionContext permission_context(
       profile()->GetOffTheRecordProfile());
-  GURL url("https://www.example.com");
+  const GURL url("https://www.example.com");
   NavigateAndCommit(url);
   web_contents()->WasShown();
 
   const PermissionRequestID id0(web_contents()->GetRenderProcessHost()->GetID(),
                                 web_contents()->GetMainFrame()->GetRoutingID(),
                                 0);
   const PermissionRequestID id1(web_contents()->GetRenderProcessHost()->GetID(),
                                 web_contents()->GetMainFrame()->GetRoutingID(),
                                 1);
 
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner(SwitchToMockTime());
 
   ASSERT_EQ(0, permission_context.permission_set_count());
   ASSERT_FALSE(permission_context.last_permission_set_persisted());
   ASSERT_EQ(CONTENT_SETTING_DEFAULT,
             permission_context.last_permission_set_setting());
 
-  permission_context.RequestPermission(web_contents(), id0, url,
+  const url::Origin origin(url);
+  permission_context.RequestPermission(web_contents(), id0, origin,
                                        base::Bind(&DoNothing));
-  permission_context.RequestPermission(web_contents(), id1, url,
+  permission_context.RequestPermission(web_contents(), id1, origin,
                                        base::Bind(&DoNothing));
 
   EXPECT_EQ(0, permission_context.permission_set_count());
   EXPECT_EQ(CONTENT_SETTING_ASK,
             permission_context.GetContentSettingFromMap(url, url));
 
   // Fast forward up to 2.5 seconds. Stop as soon as the first permission
   // request is auto-denied.
   for (int n = 0; n < 5; n++) {
     task_runner->FastForwardBy(base::TimeDelta::FromMilliseconds(500));
@@ skipping 12 matching lines @@
   // After another 2.5 seconds, the second permission request should also have
   // received a response.
   task_runner->FastForwardBy(base::TimeDelta::FromMilliseconds(2500));
   EXPECT_EQ(2, permission_context.permission_set_count());
   EXPECT_TRUE(permission_context.last_permission_set_persisted());
   EXPECT_EQ(CONTENT_SETTING_BLOCK,
             permission_context.last_permission_set_setting());
   EXPECT_EQ(CONTENT_SETTING_BLOCK,
             permission_context.GetContentSettingFromMap(url, url));
 }