Use the same codepath for NOTIFICATIONS and PUSH_MESSAGING permissions

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/threading/thread_task_runner_handle.h"
@@ skipping 16 matching lines @@
 #include "url/gurl.h"
 
 namespace {
 
 void DoNothing(ContentSetting content_setting) {}
 void DoNothing2(blink::mojom::PermissionStatus status) {}
 
 class TestNotificationPermissionContext : public NotificationPermissionContext {
  public:
   explicit TestNotificationPermissionContext(Profile* profile)
-      : NotificationPermissionContext(profile),
+      : NotificationPermissionContext(profile,
+                                      content::PermissionType::NOTIFICATIONS),
         permission_set_count_(0),
         last_permission_set_persisted_(false),
         last_permission_set_setting_(CONTENT_SETTING_DEFAULT) {}
 
   int permission_set_count() const { return permission_set_count_; }
   bool last_permission_set_persisted() const {
     return last_permission_set_persisted_;
   }
   ContentSetting last_permission_set_setting() const {
     return last_permission_set_setting_;
@@ skipping 20 matching lines @@
     NotificationPermissionContext::NotifyPermissionSet(
         id, requesting_origin, embedder_origin, callback, persist,
         content_setting);
   }
 
   int permission_set_count_;
   bool last_permission_set_persisted_;
   ContentSetting last_permission_set_setting_;
 };
 
+}  // namespace
+
 class NotificationPermissionContextTest
     : public ChromeRenderViewHostTestHarness {
  public:
   scoped_refptr<base::TestMockTimeTaskRunner> SwitchToMockTime() {
     old_task_runner_ = base::ThreadTaskRunnerHandle::Get();
     scoped_refptr<base::TestMockTimeTaskRunner> task_runner(
         new base::TestMockTimeTaskRunner(base::Time::Now(),
                                          base::TimeTicks::Now()));
     base::MessageLoop::current()->SetTaskRunner(task_runner);
     return task_runner;
   }
 
   void TearDown() override {
     if (old_task_runner_) {
       base::MessageLoop::current()->SetTaskRunner(old_task_runner_);
       old_task_runner_ = nullptr;
     }
     ChromeRenderViewHostTestHarness::TearDown();
   }
 
+ protected:
+  void UpdateContentSetting(NotificationPermissionContext* context,
+                            const GURL& requesting_origin,
+                            const GURL& embedding_origin,
+                            ContentSetting setting) {
+    context->UpdateContentSetting(requesting_origin, embedding_origin, setting);
+  }
+
  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");
 
-  NotificationPermissionContext context(profile());
-  context.UpdateContentSetting(requesting_origin,
-                               embedding_origin,
-                               CONTENT_SETTING_ALLOW);
+  NotificationPermissionContext context(profile(),
+                                        content::PermissionType::NOTIFICATIONS);
+  UpdateContentSetting(&context, 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));
 }
 
+// Push messaging permission requests should only succeed for top level origins
+// (embedding origin == requesting origin).
+TEST_F(NotificationPermissionContextTest, PushTopLevelOriginOnly) {
+  GURL requesting_origin("https://example.com");
+  GURL embedding_origin("https://chrome.com");
+
+  NotificationPermissionContext context(
+      profile(), content::PermissionType::PUSH_MESSAGING);
+  UpdateContentSetting(&context, requesting_origin, embedding_origin,
+                       CONTENT_SETTING_ALLOW);
+
+  EXPECT_EQ(CONTENT_SETTING_BLOCK,
+            context.GetPermissionStatus(requesting_origin, embedding_origin));
+
+  context.ResetPermission(requesting_origin, embedding_origin);
+
+  UpdateContentSetting(&context, embedding_origin, embedding_origin,
+                       CONTENT_SETTING_ALLOW);
+
+  EXPECT_EQ(CONTENT_SETTING_ALLOW,
+            context.GetPermissionStatus(embedding_origin, embedding_origin));
+
+  context.ResetPermission(embedding_origin, embedding_origin);
+
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+            context.GetPermissionStatus(embedding_origin, embedding_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");
 
-  NotificationPermissionContext context(profile());
+  NotificationPermissionContext context(profile(),
+                                        content::PermissionType::NOTIFICATIONS);
   EXPECT_EQ(CONTENT_SETTING_ASK,
             context.GetPermissionStatus(origin, origin));
 
-  context.UpdateContentSetting(origin, origin, CONTENT_SETTING_ALLOW);
+  UpdateContentSetting(&context, origin, origin, CONTENT_SETTING_ALLOW);
 
   EXPECT_EQ(CONTENT_SETTING_ALLOW,
             context.GetPermissionStatus(origin, origin));
 }
 
+// Push notifications requires a secure origin to acquire permission.
+TEST_F(NotificationPermissionContextTest, PushSecureOriginRequirement) {
+  GURL origin("http://example.com");
+  GURL secure_origin("https://example.com");
+
+  NotificationPermissionContext context(
+      profile(), content::PermissionType::PUSH_MESSAGING);
+  EXPECT_EQ(CONTENT_SETTING_BLOCK, context.GetPermissionStatus(origin, origin));
+
+  UpdateContentSetting(&context, origin, origin, CONTENT_SETTING_ALLOW);
+
+  EXPECT_EQ(CONTENT_SETTING_BLOCK, context.GetPermissionStatus(origin, origin));
+
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+            context.GetPermissionStatus(secure_origin, secure_origin));
+
+  UpdateContentSetting(&context, secure_origin, secure_origin,
+                       CONTENT_SETTING_ALLOW);
+
+  EXPECT_EQ(CONTENT_SETTING_ALLOW,
+            context.GetPermissionStatus(secure_origin, secure_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");
   NavigateAndCommit(url);
 
   const PermissionRequestID id(web_contents()->GetRenderProcessHost()->GetID(),
                                web_contents()->GetMainFrame()->GetRoutingID(),
                                -1);
@@ skipping 138 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));
 }