Make PermissionRequestManager::requests_ correspond to the active prompt

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 <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/mock_entropy_provider.h"
 #include "base/test/scoped_feature_list.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_decision_auto_blocker.h"
 #include "chrome/browser/permissions/permission_queue_controller.h"
 #include "chrome/browser/permissions/permission_request_id.h"
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/permissions/permission_util.h"
+#include "chrome/browser/ui/permission_bubble/mock_permission_prompt_factory.h"
 #include "chrome/common/chrome_features.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"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_types.h"
 #include "components/safe_browsing_db/database_manager.h"
 #include "components/safe_browsing_db/test_database_manager.h"
 #include "components/variations/variations_associated_data.h"
@@ skipping 200 matching lines @@
     if (response == CONTENT_SETTING_ALLOW)
       decision = PermissionAction::GRANTED;
     else if (response == CONTENT_SETTING_BLOCK)
       decision = PermissionAction::DENIED;
     context->GetInfoBarController()->OnPermissionSet(
         id, url, url, false /* user_gesture */, persist, decision);
 #else
     PermissionRequestManager* manager =
         PermissionRequestManager::FromWebContents(web_contents());
     manager->TogglePersist(persist);
-    switch (response) {
-      case CONTENT_SETTING_ALLOW:
-        manager->Accept();
-        break;
-      case CONTENT_SETTING_BLOCK:
-        manager->Deny();
-        break;
-      case CONTENT_SETTING_ASK:
-        manager->Closing();
-        break;
-      default:
-        NOTREACHED();
-    }
+    using AutoResponseType = PermissionRequestManager::AutoResponseType;
+    AutoResponseType decision = AutoResponseType::DISMISS;
+    if (response == CONTENT_SETTING_ALLOW)
+      decision = AutoResponseType::ACCEPT_ALL;
+    else if (response == CONTENT_SETTING_BLOCK)
+      decision = AutoResponseType::DENY_ALL;
+    prompt_factory_->set_response_type(decision);
 #endif
   }
 
   void TestAskAndDecide_TestContent(ContentSettingsType content_settings_type,
                                     ContentSetting decision,
                                     bool persist) {
     TestPermissionContext permission_context(profile(), content_settings_type);
     GURL url("https://www.google.com");
-    NavigateAndCommit(url);
+    SetUpUrl(url);
     base::HistogramTester histograms;
 
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(), -1);
     permission_context.SetRespondPermissionCallback(
         base::Bind(&PermissionContextBaseTests::RespondToPermission,
                    base::Unretained(this), &permission_context, id, url,
                    persist, decision));
     permission_context.RequestPermission(
@@ skipping 131 matching lines @@
         nullptr /* render_frame_host */, url, url);
     EXPECT_EQ(CONTENT_SETTING_BLOCK, result.content_setting);
     EXPECT_EQ(PermissionStatusSource::MULTIPLE_DISMISSALS, result.source);
     histograms.ExpectBucketCount(
         "Permissions.AutoBlocker.EmbargoPromptSuppression",
         static_cast<int>(PermissionEmbargoStatus::REPEATED_DISMISSALS), 1);
   }
 
   void TestBlockOnSeveralDismissals_TestContent() {
     GURL url("https://www.google.com");
-    NavigateAndCommit(url);
+    SetUpUrl(url);
     base::HistogramTester histograms;
 
     // First, ensure that > 3 dismissals behaves correctly.
     for (uint32_t i = 0; i < 4; ++i) {
       TestPermissionContext permission_context(
           profile(), CONTENT_SETTINGS_TYPE_GEOLOCATION);
 
       const PermissionRequestID id(
           web_contents()->GetRenderProcessHost()->GetID(),
           web_contents()->GetMainFrame()->GetRoutingID(), i);
@@ skipping 47 matching lines @@
 
     // Sanity check independence per permission type by checking two of them.
     DismissMultipleTimesAndExpectBlock(url, CONTENT_SETTINGS_TYPE_GEOLOCATION,
                                        3);
     DismissMultipleTimesAndExpectBlock(url, CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
                                        3);
   }
 
   void TestVariationBlockOnSeveralDismissals_TestContent() {
     GURL url("https://www.google.com");
-    NavigateAndCommit(url);
+    SetUpUrl(url);
     base::HistogramTester histograms;
 
     // Set up the custom parameter and custom value.
     base::FieldTrialList field_trials(nullptr);
     base::FieldTrial* trial = base::FieldTrialList::CreateFieldTrial(
         kPromptTrialName, kPromptGroupName);
     std::map<std::string, std::string> params;
     params[PermissionDecisionAutoBlocker::kPromptDismissCountKey] = "5";
     ASSERT_TRUE(variations::AssociateVariationParams(kPromptTrialName,
                                                      kPromptGroupName, params));
@@ skipping 86 matching lines @@
     EXPECT_EQ(PermissionStatusSource::MULTIPLE_DISMISSALS, result.source);
     variations::testing::ClearAllVariationParams();
   }
 
   void TestRequestPermissionInvalidUrl(
       ContentSettingsType content_settings_type) {
     base::HistogramTester histograms;
     TestPermissionContext permission_context(profile(), content_settings_type);
     GURL url;
     ASSERT_FALSE(url.is_valid());
-    NavigateAndCommit(url);
+    SetUpUrl(url);
 
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(), -1);
     permission_context.RequestPermission(
         web_contents(), id, url, true /* user_gesture */,
         base::Bind(&TestPermissionContext::TrackPermissionDecision,
                    base::Unretained(&permission_context)));
 
     ASSERT_EQ(1u, permission_context.decisions().size());
     EXPECT_EQ(CONTENT_SETTING_BLOCK, permission_context.decisions()[0]);
     EXPECT_TRUE(permission_context.tab_context_updated());
     EXPECT_EQ(CONTENT_SETTING_ASK,
               permission_context.GetContentSettingFromMap(url, url));
     histograms.ExpectTotalCount(
         "Permissions.AutoBlocker.EmbargoPromptSuppression", 0);
   }
 
   void TestGrantAndRevoke_TestContent(ContentSettingsType content_settings_type,
                                       ContentSetting expected_default) {
     TestPermissionContext permission_context(profile(), content_settings_type);
     GURL url("https://www.google.com");
-    NavigateAndCommit(url);
+    SetUpUrl(url);
 
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(), -1);
     permission_context.SetRespondPermissionCallback(
         base::Bind(&PermissionContextBaseTests::RespondToPermission,
                    base::Unretained(this), &permission_context, id, url, true,
                    CONTENT_SETTING_ALLOW));
 
     permission_context.RequestPermission(
@@ skipping 34 matching lines @@
                                            kPermissionsKillSwitchTestGroup);
     EXPECT_TRUE(permission_context.IsPermissionKillSwitchOn());
   }
 
   // Don't call this more than once in the same test, as it persists data to
   // HostContentSettingsMap.
   void TestParallelRequests(ContentSetting response) {
     TestPermissionContext permission_context(
         profile(), CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
     GURL url("http://www.google.com");
-    NavigateAndCommit(url);
+    SetUpUrl(url);
 
     const PermissionRequestID id0(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(), 0);
     const PermissionRequestID id1(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(), 1);
 
     bool persist = (response == CONTENT_SETTING_ALLOW ||
                     response == CONTENT_SETTING_BLOCK);
@@ skipping 24 matching lines @@
     EXPECT_EQ(response, permission_context.GetContentSettingFromMap(url, url));
   }
 
   void TestPermissionsBlacklisting(
       ContentSettingsType content_settings_type,
       scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> db_manager,
       const GURL& url,
       int timeout,
       ContentSetting expected_permission_status,
       PermissionEmbargoStatus expected_embargo_reason) {
-    NavigateAndCommit(url);
+    SetUpUrl(url);
     base::HistogramTester histograms;
     base::test::ScopedFeatureList scoped_feature_list;
     scoped_feature_list.InitAndEnableFeature(features::kPermissionsBlacklist);
     TestPermissionContext permission_context(profile(), content_settings_type);
     PermissionDecisionAutoBlocker::GetForProfile(profile())
         ->SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(db_manager,
                                                              timeout);
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(), -1);
@@ skipping 22 matching lines @@
     } else {
       EXPECT_EQ(PermissionStatusSource::SAFE_BROWSING_BLACKLIST, result.source);
     }
     histograms.ExpectUniqueSample(
         "Permissions.AutoBlocker.EmbargoPromptSuppression",
         static_cast<int>(expected_embargo_reason), 1);
     histograms.ExpectUniqueSample("Permissions.AutoBlocker.EmbargoStatus",
                                   static_cast<int>(expected_embargo_reason), 1);
   }
 
+  void SetUpUrl(const GURL& url) {
+    NavigateAndCommit(url);
+#if !defined(OS_ANDROID)
+    prompt_factory_->DocumentOnLoadCompletedInMainFrame();
+#endif
+  }
+
  private:
   // ChromeRenderViewHostTestHarness:
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
 #if defined(OS_ANDROID)
     InfoBarService::CreateForWebContents(web_contents());
 #else
     PermissionRequestManager::CreateForWebContents(web_contents());
+    PermissionRequestManager* manager =
+        PermissionRequestManager::FromWebContents(web_contents());
+    prompt_factory_.reset(new MockPermissionPromptFactory(manager));
+    manager->DisplayPendingRequests();
 #endif
   }
 
+  void TearDown() override {
+    prompt_factory_.reset();
+    ChromeRenderViewHostTestHarness::TearDown();
+  }
+
+  std::unique_ptr<MockPermissionPromptFactory> prompt_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(PermissionContextBaseTests);
 };
 
 // Simulates clicking Accept. The permission should be granted and
 // saved for future use.
 TEST_F(PermissionContextBaseTests, TestAskAndGrantPersist) {
   TestAskAndDecide_TestContent(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
                                CONTENT_SETTING_ALLOW, true);
 }
 
@@ skipping 122 matching lines @@
 TEST_F(PermissionContextBaseTests, TestPermissionsBlacklistingAllowed) {
   scoped_refptr<MockSafeBrowsingDatabaseManager> db_manager =
       new MockSafeBrowsingDatabaseManager(true /* perform_callback */);
   const GURL url("https://www.example.com");
   std::set<std::string> blacklisted_permissions{"GEOLOCATION"};
   db_manager->BlacklistUrlPermissions(url, blacklisted_permissions);
   TestPermissionsBlacklisting(CONTENT_SETTINGS_TYPE_NOTIFICATIONS, db_manager,
                               url, 2000 /* timeout */, CONTENT_SETTING_ALLOW,
                               PermissionEmbargoStatus::NOT_EMBARGOED);
 }