Rename PermissionBubbleManager to PermissionRequestManager

chrome/browser/geolocation/geolocation_browsertest.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/clock.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
+#include "chrome/browser/permissions/permission_request_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
-#include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/content_settings/core/browser/content_settings_usages_state.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/geoposition.h"
@@ skipping 85 matching lines @@
     navigation_completed_ = true;
   } else if (type == content::NOTIFICATION_DOM_OPERATION_RESPONSE) {
     content::Details<std::string> dom_op_result(details);
     javascript_response_ = *dom_op_result.ptr();
     javascript_completed_ = true;
   }
   if (javascript_completed_ && navigation_completed_)
     base::MessageLoopForUI::current()->QuitWhenIdle();
 }
 
-// PermissionBubbleObserver ---------------------------------------------------
+// PermissionRequestObserver ---------------------------------------------------
 
-// Used to observe the creation of a single permission bubble without
+// Used to observe the creation of a single permission request without
 // responding.
-class PermissionBubbleObserver : public PermissionBubbleManager::Observer {
+class PermissionRequestObserver : public PermissionRequestManager::Observer {
  public:
-  explicit PermissionBubbleObserver(content::WebContents* web_contents)
-      : bubble_manager_(PermissionBubbleManager::FromWebContents(web_contents)),
+  explicit PermissionRequestObserver(content::WebContents* web_contents)
+      : request_manager_(
+            PermissionRequestManager::FromWebContents(web_contents)),
         request_shown_(false),
         message_loop_runner_(new content::MessageLoopRunner) {
-    bubble_manager_->AddObserver(this);
+    request_manager_->AddObserver(this);
   }
-  ~PermissionBubbleObserver() override {
+  ~PermissionRequestObserver() override {
     // Safe to remove twice if it happens.
-    bubble_manager_->RemoveObserver(this);
+    request_manager_->RemoveObserver(this);
   }
 
   void Wait() { message_loop_runner_->Run(); }
 
   bool request_shown() { return request_shown_; }
 
  private:
-  // PermissionBubbleManager::Observer
+  // PermissionRequestManager::Observer
   void OnBubbleAdded() override {
     request_shown_ = true;
-    bubble_manager_->RemoveObserver(this);
+    request_manager_->RemoveObserver(this);
     message_loop_runner_->Quit();
   }
 
-  PermissionBubbleManager* bubble_manager_;
+  PermissionRequestManager* request_manager_;
   bool request_shown_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
-  DISALLOW_COPY_AND_ASSIGN(PermissionBubbleObserver);
+  DISALLOW_COPY_AND_ASSIGN(PermissionRequestObserver);
 };
 
 }  // namespace
 
 
 // GeolocationBrowserTest -----------------------------------------------------
 
 // This is a browser test for Geolocation.
 // It exercises various integration points from javascript <-> browser:
 // 1. The user is prompted when a position is requested from an unauthorized
@@ skipping 40 matching lines @@
   // http://localhost.
   void LoadIFrames();
 
   // Specifies which frame to use for executing JavaScript.
   void SetFrameForScriptExecution(const std::string& frame_name);
 
   // Gets the HostContentSettingsMap for the current profile.
   HostContentSettingsMap* GetHostContentSettingsMap();
 
   // Calls watchPosition in JavaScript and accepts or denies the resulting
-  // permission bubble. Returns |true| if the expected behavior happened.
+  // permission request. Returns |true| if the expected behavior happened.
   bool WatchPositionAndGrantPermission() WARN_UNUSED_RESULT;
   bool WatchPositionAndDenyPermission() WARN_UNUSED_RESULT;
 
   // Calls watchPosition in JavaScript and observes whether the permission
-  // bubble is shown without interacting with it. Callers should set
-  // |bubble_should_display| to |true| if they expect a bubble to display.
-  void WatchPositionAndObservePermissionBubble(bool bubble_should_display);
+  // request is shown without interacting with it. Callers should set
+  // |request_should_display| to |true| if they expect a request to display.
+  void WatchPositionAndObservePermissionRequest(bool request_should_display);
 
   // Checks that no errors have been received in JavaScript, and checks that the
   // position most recently received matches |latitude| and |longitude|.
   void ExpectPosition(double latitude, double longitude);
 
   // Executes |function| in |render_frame_host| and checks that the return value
   // matches |expected|.
   void ExpectValueFromScriptForFrame(
       const std::string& expected,
       const std::string& function,
       content::RenderFrameHost* render_frame_host);
 
   // Executes |function| and checks that the return value matches |expected|.
   void ExpectValueFromScript(const std::string& expected,
                              const std::string& function);
 
   // Sets a new (second) position and runs all callbacks currently registered
   // with the Geolocation system. Returns |true| if the new position is updated
   // successfully in JavaScript.
   bool SetPositionAndWaitUntilUpdated(double latitude, double longitude);
 
-  // Convenience method to look up the number of queued permission bubbles.
-  int GetBubbleQueueSize(PermissionBubbleManager* manager);
+  // Convenience method to look up the number of queued permission requests.
+  int GetRequestQueueSize(PermissionRequestManager* manager);
 
  private:
   // Calls watchPosition() in JavaScript and accepts or denies the resulting
-  // permission bubble. Returns the JavaScript response.
-  std::string WatchPositionAndRespondToPermissionBubble(
-      PermissionBubbleManager::AutoResponseType bubble_response);
+  // permission request. Returns the JavaScript response.
+  std::string WatchPositionAndRespondToPermissionRequest(
+      PermissionRequestManager::AutoResponseType request_response);
 
   // The current Browser as set in Initialize. May be for an incognito profile.
   Browser* current_browser_ = nullptr;
 
   // The path element of a URL referencing the html content for this test.
   std::string html_for_tests_ = "/geolocation/simple.html";
 
   // The frame where the JavaScript calls will run.
   content::RenderFrameHost* render_frame_host_ = nullptr;
 
@@ skipping 69 matching lines @@
   }
   DCHECK(render_frame_host_);
 }
 
 HostContentSettingsMap* GeolocationBrowserTest::GetHostContentSettingsMap() {
   return HostContentSettingsMapFactory::GetForProfile(
       current_browser()->profile());
 }
 
 bool GeolocationBrowserTest::WatchPositionAndGrantPermission() {
-  std::string result = WatchPositionAndRespondToPermissionBubble(
-      PermissionBubbleManager::ACCEPT_ALL);
+  std::string result = WatchPositionAndRespondToPermissionRequest(
+      PermissionRequestManager::ACCEPT_ALL);
   return "request-callback-success" == result;
 }
 
 bool GeolocationBrowserTest::WatchPositionAndDenyPermission() {
-  std::string result = WatchPositionAndRespondToPermissionBubble(
-      PermissionBubbleManager::DENY_ALL);
+  std::string result = WatchPositionAndRespondToPermissionRequest(
+      PermissionRequestManager::DENY_ALL);
   return "request-callback-error" == result;
 }
 
-std::string GeolocationBrowserTest::WatchPositionAndRespondToPermissionBubble(
-    PermissionBubbleManager::AutoResponseType bubble_response) {
-  PermissionBubbleManager::FromWebContents(
+std::string GeolocationBrowserTest::WatchPositionAndRespondToPermissionRequest(
+    PermissionRequestManager::AutoResponseType request_response) {
+  PermissionRequestManager::FromWebContents(
       current_browser_->tab_strip_model()->GetActiveWebContents())
-      ->set_auto_response_for_test(bubble_response);
+      ->set_auto_response_for_test(request_response);
   return RunScript(render_frame_host_, "geoStartWithAsyncResponse()");
 }
 
-void GeolocationBrowserTest::WatchPositionAndObservePermissionBubble(
-    bool bubble_should_display) {
-  PermissionBubbleObserver observer(
+void GeolocationBrowserTest::WatchPositionAndObservePermissionRequest(
+    bool request_should_display) {
+  PermissionRequestObserver observer(
       current_browser_->tab_strip_model()->GetActiveWebContents());
-  if (bubble_should_display) {
+  if (request_should_display) {
     // Control will return as soon as the API call is made, and then the
-    // observer will wait for the bubble to display.
+    // observer will wait for the request to display.
     RunScript(render_frame_host_, "geoStartWithSyncResponse()");
     observer.Wait();
   } else {
     // Control will return once one of the callbacks fires.
     RunScript(render_frame_host_, "geoStartWithAsyncResponse()");
   }
-  EXPECT_EQ(bubble_should_display, observer.request_shown());
+  EXPECT_EQ(request_should_display, observer.request_shown());
 }
 
 void GeolocationBrowserTest::ExpectPosition(double latitude, double longitude) {
   // Checks we have no error.
   ExpectValueFromScript("0", "geoGetLastError()");
   ExpectValueFromScript(base::DoubleToString(latitude),
                         "geoGetLastPositionLatitude()");
   ExpectValueFromScript(base::DoubleToString(longitude),
                         "geoGetLastPositionLongitude()");
 }
@@ skipping 23 matching lines @@
   // Control will return (a) if the update has already been received, or (b)
   // when the update is received. This will hang if the position is never
   // updated. Currently this expects the position to be updated once; if your
   // test updates it repeatedly, |position_updated| (JS) needs to change to an
   // int to count how often it's been updated.
   std::string result =
       RunScript(render_frame_host_, "checkIfGeopositionUpdated()");
   return result == "geoposition-updated";
 }
 
-int GeolocationBrowserTest::GetBubbleQueueSize(
-    PermissionBubbleManager* manager) {
+int GeolocationBrowserTest::GetRequestQueueSize(
+    PermissionRequestManager* manager) {
   return static_cast<int>(manager->requests_.size());
 }
 
 // Tests ----------------------------------------------------------------------
 
 #if defined(OS_LINUX)
 // http://crbug.com/527437
 #define MAYBE_DisplaysPrompt DISABLED_DisplaysPrompt
 #else
 #define MAYBE_DisplaysPrompt DisplaysPrompt
@@ skipping 24 matching lines @@
 #if defined(OS_LINUX)
 // http://crbug.com/527437
 #define MAYBE_NoPromptForSecondTab DISABLED_NoPromptForSecondTab
 #else
 #define MAYBE_NoPromptForSecondTab NoPromptForSecondTab
 #endif
 IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, MAYBE_NoPromptForSecondTab) {
   ASSERT_NO_FATAL_FAILURE(Initialize(INITIALIZATION_DEFAULT));
   ASSERT_TRUE(WatchPositionAndGrantPermission());
 
-  // Checks bubble is not needed in a second tab.
+  // Checks request is not needed in a second tab.
   ASSERT_NO_FATAL_FAILURE(Initialize(INITIALIZATION_NEWTAB));
-  WatchPositionAndObservePermissionBubble(false);
+  WatchPositionAndObservePermissionRequest(false);
   ExpectPosition(fake_latitude(), fake_longitude());
 }
 
 IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, NoPromptForDeniedOrigin) {
   ASSERT_NO_FATAL_FAILURE(Initialize(INITIALIZATION_DEFAULT));
   GetHostContentSettingsMap()->SetContentSettingDefaultScope(
       current_url(), current_url(), CONTENT_SETTINGS_TYPE_GEOLOCATION,
       std::string(), CONTENT_SETTING_BLOCK);
 
-  // Check that the bubble wasn't shown but we get an error for this origin.
-  WatchPositionAndObservePermissionBubble(false);
+  // Check that the request wasn't shown but we get an error for this origin.
+  WatchPositionAndObservePermissionRequest(false);
   ExpectValueFromScript(GetErrorCodePermissionDenied(), "geoGetLastError()");
 
   // Checks prompt will not be created a second tab.
   ASSERT_NO_FATAL_FAILURE(Initialize(INITIALIZATION_NEWTAB));
-  WatchPositionAndObservePermissionBubble(false);
+  WatchPositionAndObservePermissionRequest(false);
   ExpectValueFromScript(GetErrorCodePermissionDenied(), "geoGetLastError()");
 }
 
 #if defined(OS_LINUX)
 // http://crbug.com/527437
 #define MAYBE_NoPromptForAllowedOrigin DISABLED_NoPromptForAllowedOrigin
 #else
 #define MAYBE_NoPromptForAllowedOrigin NoPromptForAllowedOrigin
 #endif
 IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, MAYBE_NoPromptForAllowedOrigin) {
   ASSERT_NO_FATAL_FAILURE(Initialize(INITIALIZATION_DEFAULT));
   GetHostContentSettingsMap()->SetContentSettingDefaultScope(
       current_url(), current_url(), CONTENT_SETTINGS_TYPE_GEOLOCATION,
       std::string(), CONTENT_SETTING_ALLOW);
-  // The bubble is not shown, there is no error, and the position gets to the
+  // The request is not shown, there is no error, and the position gets to the
   // script.
-  WatchPositionAndObservePermissionBubble(false);
+  WatchPositionAndObservePermissionRequest(false);
   ExpectPosition(fake_latitude(), fake_longitude());
 }
 
 IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, NoPromptForOffTheRecord) {
   // For a regular profile the user is prompted, and when granted the position
   // gets to the script.
   ASSERT_NO_FATAL_FAILURE(Initialize(INITIALIZATION_DEFAULT));
   ASSERT_TRUE(WatchPositionAndGrantPermission());
   ExpectPosition(fake_latitude(), fake_longitude());
 
   // The permission is persisted for the regular profile, and inherited by its
   // incognito profile. Go incognito, and check that the user is not prompted
   // again and the position gets to the script.
   ASSERT_NO_FATAL_FAILURE(Initialize(INITIALIZATION_OFFTHERECORD));
-  WatchPositionAndObservePermissionBubble(false);
+  WatchPositionAndObservePermissionRequest(false);
   ExpectPosition(fake_latitude(), fake_longitude());
 }
 
 // http://crbug.com/523387
 IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest,
                        DISABLED_NoLeakFromOffTheRecord) {
   // The user is prompted in a fresh incognito profile, and when granted the
   // position gets to the script.
   ASSERT_NO_FATAL_FAILURE(Initialize(INITIALIZATION_OFFTHERECORD));
   ASSERT_TRUE(WatchPositionAndGrantPermission());
@@ skipping 18 matching lines @@
   LoadIFrames();
 
   // Grant permission in the first frame, the position gets to the script.
   SetFrameForScriptExecution("iframe_0");
   ASSERT_TRUE(WatchPositionAndGrantPermission());
   ExpectPosition(fake_latitude(), fake_longitude());
 
   // In a second iframe from a different origin with a cached position the user
   // is prompted.
   SetFrameForScriptExecution("iframe_1");
-  WatchPositionAndObservePermissionBubble(true);
+  WatchPositionAndObservePermissionRequest(true);
 
   // Back to the first frame, enable navigation and refresh geoposition.
   SetFrameForScriptExecution("iframe_0");
   double fresh_position_latitude = 3.17;
   double fresh_position_longitude = 4.23;
   ASSERT_TRUE(SetPositionAndWaitUntilUpdated(fresh_position_latitude,
                                              fresh_position_longitude));
   ExpectPosition(fresh_position_latitude, fresh_position_longitude);
 
   // When permission is granted to the second iframe the fresh position gets to
@@ skipping 41 matching lines @@
   ASSERT_NO_FATAL_FAILURE(Initialize(INITIALIZATION_DEFAULT));
   LoadIFrames();
 
   SetFrameForScriptExecution("iframe_0");
   ASSERT_TRUE(WatchPositionAndGrantPermission());
   ExpectPosition(fake_latitude(), fake_longitude());
 
   // Test second iframe from a different origin with a cached position will
   // create the prompt.
   SetFrameForScriptExecution("iframe_1");
-  WatchPositionAndObservePermissionBubble(true);
+  WatchPositionAndObservePermissionRequest(true);
 
   // Navigate the iframe, and ensure the prompt is gone.
   content::WebContents* web_contents =
       current_browser()->tab_strip_model()->GetActiveWebContents();
   IFrameLoader change_iframe_1(current_browser(), 1, current_url());
-  int num_bubbles_after_cancel = GetBubbleQueueSize(
-      PermissionBubbleManager::FromWebContents(web_contents));
-  EXPECT_EQ(0, num_bubbles_after_cancel);
+  int num_requests_after_cancel = GetRequestQueueSize(
+      PermissionRequestManager::FromWebContents(web_contents));
+  EXPECT_EQ(0, num_requests_after_cancel);
 }
 
 IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, InvalidUrlRequest) {
   // Tests that an invalid URL (e.g. from a popup window) is rejected
   // correctly. Also acts as a regression test for http://crbug.com/40478
   set_html_for_tests("/geolocation/invalid_request_url.html");
   ASSERT_NO_FATAL_FAILURE(Initialize(INITIALIZATION_DEFAULT));
 
   content::WebContents* original_tab =
       current_browser()->tab_strip_model()->GetActiveWebContents();
@@ skipping 61 matching lines @@
   ExpectPosition(final_position_latitude, final_position_longitude);
 }
 
 // TODO(felt): Disabled because the second permission request hangs.
 IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, DISABLED_PendingChildFrames) {
   set_html_for_tests("/geolocation/two_iframes.html");
   ASSERT_NO_FATAL_FAILURE(Initialize(INITIALIZATION_DEFAULT));
   LoadIFrames();
 
   SetFrameForScriptExecution("iframe_0");
-  WatchPositionAndObservePermissionBubble(true);
+  WatchPositionAndObservePermissionRequest(true);
 
   SetFrameForScriptExecution("iframe_1");
-  WatchPositionAndObservePermissionBubble(true);
+  WatchPositionAndObservePermissionRequest(true);
 }
 
 IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, TabDestroyed) {
   ASSERT_NO_FATAL_FAILURE(Initialize(INITIALIZATION_DEFAULT));
-  WatchPositionAndObservePermissionBubble(true);
+  WatchPositionAndObservePermissionRequest(true);
 
   // TODO(mvanouwerkerk): Can't close a window you did not open. Maybe this was
   // valid when the test was written, but now it just prints "Scripts may close
   // only the windows that were opened by it."
   std::string script = "window.domAutomationController.send(window.close())";
   ASSERT_TRUE(content::ExecuteScript(
       current_browser()->tab_strip_model()->GetActiveWebContents(), script));
 }
 
 #if defined(OS_LINUX)
@@ skipping 16 matching lines @@
 
   // Permission has been used at the starting time.
   EXPECT_EQ(GetHostContentSettingsMap()->GetLastUsage(
       current_url().GetOrigin(),
       current_url().GetOrigin(),
       CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(), 10);
 
   clock_->Advance(base::TimeDelta::FromSeconds(3));
 
   // Calling watchPosition should trigger the last usage update.
-  WatchPositionAndObservePermissionBubble(false);
+  WatchPositionAndObservePermissionRequest(false);
   ExpectPosition(fake_latitude(), fake_longitude());
 
   // Last usage has been updated.
   EXPECT_EQ(GetHostContentSettingsMap()->GetLastUsage(
       current_url().GetOrigin(),
       current_url().GetOrigin(),
       CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(), 13);
 }