Disable Web Notifications in Incognito

chrome/browser/permissions/permission_context_base_unittest.cc

 // Copyright 2014 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/permissions/permission_context_base.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/test/mock_entropy_provider.h"
+#include "base/test/test_mock_time_task_runner.h"
+#include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/permissions/permission_queue_controller.h"
 #include "chrome/browser/permissions/permission_request_id.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
@@ skipping 59 matching lines @@
 
   void ResetFieldTrialList() {
     // Destroy the existing FieldTrialList before creating a new one to avoid
     // a DCHECK.
     field_trial_list_.reset();
     field_trial_list_.reset(new base::FieldTrialList(
         new base::MockEntropyProvider));
     variations::testing::ClearAllVariationParams();
   }
 
+  ContentSetting GetContentSettingFromMap(GURL url_a, GURL url_b) {
+    return HostContentSettingsMapFactory::GetForProfile(profile())
+        ->GetContentSetting(url_a.GetOrigin(), url_b.GetOrigin(),
+                            content_settings_type(), std::string());
+  }
+
  protected:
   void UpdateTabContext(const PermissionRequestID& id,
                         const GURL& requesting_origin,
                         bool allowed) override {
     tab_context_updated_ = true;
   }
 
   bool IsRestrictedToSecureOrigins() const override {
     return false;
   }
@@ skipping 41 matching lines @@
     permission_context.RequestPermission(
         web_contents(),
         id, url, true,
         base::Bind(&TestPermissionContext::TrackPermissionDecision,
                    base::Unretained(&permission_context)));
 
     RespondToPermission(&permission_context, id, url, true);
     EXPECT_TRUE(permission_context.permission_set());
     EXPECT_TRUE(permission_context.permission_granted());
     EXPECT_TRUE(permission_context.tab_context_updated());
-
-    ContentSetting setting =
-        HostContentSettingsMapFactory::GetForProfile(profile())
-            ->GetContentSetting(url.GetOrigin(),
-                                url.GetOrigin(),
-                                CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
-                                std::string());
-    EXPECT_EQ(CONTENT_SETTING_ALLOW, setting);
+    EXPECT_EQ(CONTENT_SETTING_ALLOW,
+              permission_context.GetContentSettingFromMap(url, url));
   }
 
   void TestAskAndDismiss_TestContent() {
     TestPermissionContext permission_context(
         profile(), content::PermissionType::MIDI_SYSEX,
         CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
     GURL url("http://www.google.es");
     content::WebContentsTester::For(web_contents())->NavigateAndCommit(url);
 
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(),
         -1);
     permission_context.RequestPermission(
         web_contents(),
         id, url, true,
         base::Bind(&TestPermissionContext::TrackPermissionDecision,
                    base::Unretained(&permission_context)));
 
     RespondToPermission(&permission_context, id, url, false);
     EXPECT_TRUE(permission_context.permission_set());
     EXPECT_FALSE(permission_context.permission_granted());
     EXPECT_TRUE(permission_context.tab_context_updated());
-
-    ContentSetting setting =
-        HostContentSettingsMapFactory::GetForProfile(profile())
-            ->GetContentSetting(url.GetOrigin(),
-                                url.GetOrigin(),
-                                CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
-                                std::string());
-    EXPECT_EQ(CONTENT_SETTING_ASK, setting);
+    EXPECT_EQ(CONTENT_SETTING_ASK,
+              permission_context.GetContentSettingFromMap(url, url));
   }
 
   void TestRequestPermissionInvalidUrl(
       content::PermissionType permission_type,
       ContentSettingsType content_settings_type) {
     TestPermissionContext permission_context(profile(), permission_type,
                                              content_settings_type);
     GURL url;
     ASSERT_FALSE(url.is_valid());
     content::WebContentsTester::For(web_contents())->NavigateAndCommit(url);
 
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(),
         -1);
     permission_context.RequestPermission(
         web_contents(),
         id, url, true,
         base::Bind(&TestPermissionContext::TrackPermissionDecision,
                    base::Unretained(&permission_context)));
 
     EXPECT_TRUE(permission_context.permission_set());
     EXPECT_FALSE(permission_context.permission_granted());
     EXPECT_TRUE(permission_context.tab_context_updated());
-
-    ContentSetting setting =
-        HostContentSettingsMapFactory::GetForProfile(profile())
-            ->GetContentSetting(url.GetOrigin(), url.GetOrigin(),
-                                content_settings_type, std::string());
-    EXPECT_EQ(CONTENT_SETTING_ASK, setting);
+    EXPECT_EQ(CONTENT_SETTING_ASK,
+              permission_context.GetContentSettingFromMap(url, url));
   }
 
   void TestGrantAndRevoke_TestContent(content::PermissionType permission_type,
                                       ContentSettingsType content_settings_type,
                                       ContentSetting expected_default) {
     TestPermissionContext permission_context(profile(), permission_type,
                                              content_settings_type);
     GURL url("https://www.google.com");
     content::WebContentsTester::For(web_contents())->NavigateAndCommit(url);
 
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(),
         -1);
     permission_context.RequestPermission(
         web_contents(),
         id, url, true,
         base::Bind(&TestPermissionContext::TrackPermissionDecision,
                    base::Unretained(&permission_context)));
 
     RespondToPermission(&permission_context, id, url, true);
     EXPECT_TRUE(permission_context.permission_set());
     EXPECT_TRUE(permission_context.permission_granted());
     EXPECT_TRUE(permission_context.tab_context_updated());
-
-    ContentSetting setting =
-        HostContentSettingsMapFactory::GetForProfile(profile())
-            ->GetContentSetting(url.GetOrigin(), url.GetOrigin(),
-                                content_settings_type, std::string());
-    EXPECT_EQ(CONTENT_SETTING_ALLOW, setting);
+    EXPECT_EQ(CONTENT_SETTING_ALLOW,
+              permission_context.GetContentSettingFromMap(url, url));
 
     // Try to reset permission.
     permission_context.ResetPermission(url.GetOrigin(), url.GetOrigin());
     ContentSetting setting_after_reset =
-        HostContentSettingsMapFactory::GetForProfile(profile())
-            ->GetContentSetting(url.GetOrigin(), url.GetOrigin(),
-                                content_settings_type, std::string());
+        permission_context.GetContentSettingFromMap(url, url);
     ContentSetting default_setting =
         HostContentSettingsMapFactory::GetForProfile(profile())
             ->GetDefaultContentSetting(content_settings_type, nullptr);
     EXPECT_EQ(default_setting, setting_after_reset);
   }
 
   void TestGlobalPermissionsKillSwitch(
       content::PermissionType permission_type,
       ContentSettingsType content_settings_type) {
     TestPermissionContext permission_context(profile(), permission_type,
@@ skipping 91 matching lines @@
 #endif
   TestGrantAndRevoke_TestContent(content::PermissionType::MIDI_SYSEX,
                                  CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
                                  CONTENT_SETTING_ASK);
   TestGrantAndRevoke_TestContent(content::PermissionType::PUSH_MESSAGING,
                                  CONTENT_SETTINGS_TYPE_PUSH_MESSAGING,
                                  CONTENT_SETTING_ASK);
 }
 #endif
 
+// Tests content_settings::ContentSettingsInfo::DENY_IN_INCOGNITO_AFTER_DELAY.
+#if defined(ENABLE_NOTIFICATIONS)
+TEST_F(PermissionContextBaseTests, TestDenyInIncognitoAfterDelay) {
+  TestPermissionContext permission_context(
+      profile()->GetOffTheRecordProfile(),
+      content::PermissionType::NOTIFICATIONS,
+      CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
+  GURL url("http://www.google.com");
+  content::WebContentsTester::For(web_contents())->NavigateAndCommit(url);
+
+  const PermissionRequestID id(web_contents()->GetRenderProcessHost()->GetID(),
+                               web_contents()->GetMainFrame()->GetRoutingID(),
+                               -1);
+
+  scoped_refptr<base::SingleThreadTaskRunner> old_task_runner(
+      base::MessageLoop::current()->task_runner());
+  scoped_refptr<base::TestMockTimeTaskRunner> task_runner(
+      new base::TestMockTimeTaskRunner(base::Time::Now(),
+                                       base::TimeTicks::Now()));
+  base::MessageLoop::current()->SetTaskRunner(task_runner);
+
+  permission_context.RequestPermission(
+      web_contents(), id, url, true /* user_gesture */,
+      base::Bind(&TestPermissionContext::TrackPermissionDecision,
+                 base::Unretained(&permission_context)));
+
+  // 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_FALSE(permission_context.permission_set());
+  EXPECT_FALSE(permission_context.tab_context_updated());
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+            permission_context.GetContentSettingFromMap(url, url));
+
+  // Time elapsed whilst hidden is not counted.
+  // n.b. This line also clears out any old scheduled timer tasks. This is
+  // important, because otherwise Timer::Reset (triggered by
+  // VisibilityTimerTabHelper::WasShown) may choose to re-use an existing
+  // scheduled task, and when it fires Timer::RunScheduledTask will call
+  // TimeTicks::Now() (which unlike task_runner->NowTicks(), we can't fake),
+  // and miscalculate the remaining delay at which to fire the timer.
+  task_runner->FastForwardBy(base::TimeDelta::FromDays(1));
+
+  EXPECT_FALSE(permission_context.permission_set());
+  EXPECT_FALSE(permission_context.tab_context_updated());
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+            permission_context.GetContentSettingFromMap(url, url));
+
+  // Should be blocked after 1-2 seconds. So 500ms is not enough.
+  web_contents()->WasShown();
+  task_runner->FastForwardBy(base::TimeDelta::FromMilliseconds(500));
+
+  EXPECT_FALSE(permission_context.permission_set());
+  EXPECT_FALSE(permission_context.tab_context_updated());
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+            permission_context.GetContentSettingFromMap(url, url));
+
+  // But 5*500ms > 2 seconds, so it should now be blocked.
+  for (int n = 0; n < 4; n++)
+    task_runner->FastForwardBy(base::TimeDelta::FromMilliseconds(500));
+
+  EXPECT_TRUE(permission_context.permission_set());
+  EXPECT_TRUE(permission_context.tab_context_updated());
+  EXPECT_EQ(CONTENT_SETTING_BLOCK,
+            permission_context.GetContentSettingFromMap(url, url));
+
+  base::MessageLoop::current()->SetTaskRunner(old_task_runner);
+}
+#endif
+
 // Tests the global kill switch by enabling/disabling the Field Trials.
 TEST_F(PermissionContextBaseTests, TestGlobalKillSwitch) {
   TestGlobalPermissionsKillSwitch(content::PermissionType::GEOLOCATION,
                                   CONTENT_SETTINGS_TYPE_GEOLOCATION);
   TestGlobalPermissionsKillSwitch(content::PermissionType::NOTIFICATIONS,
                                   CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
   TestGlobalPermissionsKillSwitch(content::PermissionType::MIDI_SYSEX,
                                   CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
   TestGlobalPermissionsKillSwitch(content::PermissionType::PUSH_MESSAGING,
                                   CONTENT_SETTINGS_TYPE_PUSH_MESSAGING);
   TestGlobalPermissionsKillSwitch(content::PermissionType::DURABLE_STORAGE,
                                   CONTENT_SETTINGS_TYPE_DURABLE_STORAGE);
 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
   TestGlobalPermissionsKillSwitch(
       content::PermissionType::PROTECTED_MEDIA_IDENTIFIER,
       CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER);
 #endif
   TestGlobalPermissionsKillSwitch(content::PermissionType::AUDIO_CAPTURE,
                                   CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
   TestGlobalPermissionsKillSwitch(content::PermissionType::VIDEO_CAPTURE,
                                   CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
 }