[WebsiteSettings] Enable permission bubbles by default.

chrome/browser/geolocation/geolocation_permission_context_unittest.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 "chrome/browser/geolocation/geolocation_permission_context.h"
 
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/clock.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/content_settings/permission_request_id.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/geolocation/geolocation_permission_context_factory.h"
 #include "chrome/browser/infobars/infobar_service.h"
+#include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
+#include "chrome/browser/ui/website_settings/permission_bubble_request.h"
+#include "chrome/browser/ui/website_settings/permission_bubble_view.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/infobars/core/confirm_infobar_delegate.h"
 #include "components/infobars/core/infobar.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_renderer_host.h"
+#include "content/public/test/test_utils.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_ANDROID)
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/android/mock_google_location_settings_helper.h"
 #include "chrome/common/pref_names.h"
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
 #include "extensions/browser/view_type_utils.h"
 #endif
 
 using content::MockRenderProcessHost;
 
+class MockPermissionBubbleView : public PermissionBubbleView {
+ public:
+  MockPermissionBubbleView() : shown_(false) {}
+  virtual ~MockPermissionBubbleView() {}
+
+  virtual void SetDelegate(Delegate* delegate) OVERRIDE {
+  }
+
+  virtual void Show(
+      const std::vector<PermissionBubbleRequest*>& requests,
+      const std::vector<bool>& accept_state,
+      bool customization_mode) OVERRIDE {
+LOG(INFO) << "Showing view... " << requests[0]->GetMessageText();
+    shown_ = true;
+  }
+
+  virtual bool CanAcceptRequestUpdate() OVERRIDE {
+    return true;
+  }
+
+  virtual void Hide() OVERRIDE {
+    shown_ = false;
+  }
+
+  virtual bool IsVisible() OVERRIDE {
+    return shown_;
+  }
+
+ private:
+  bool shown_;
+};
 
 // ClosedInfoBarTracker -------------------------------------------------------
 
 // We need to track which infobars were closed.
 class ClosedInfoBarTracker : public content::NotificationObserver {
  public:
   ClosedInfoBarTracker();
   virtual ~ClosedInfoBarTracker();
 
   // content::NotificationObserver:
@@ skipping 51 matching lines @@
   PermissionRequestID RequestIDForTab(int tab, int bridge_id);
   InfoBarService* infobar_service() {
     return InfoBarService::FromWebContents(web_contents());
   }
   InfoBarService* infobar_service_for_tab(int tab) {
     return InfoBarService::FromWebContents(extra_tabs_[tab]);
   }
 
   void RequestGeolocationPermission(content::WebContents* web_contents,
                                     const PermissionRequestID& id,
-                                    const GURL& requesting_frame);
+                                    const GURL& requesting_frame,
+                                    bool user_gesture);
   void RequestGeolocationPermission(content::WebContents* web_contents,
                                     const PermissionRequestID& id,
                                     const GURL& requesting_frame,
+                                    bool user_gesture,
                                     base::Closure* cancel_callback);
   void PermissionResponse(const PermissionRequestID& id,
                           bool allowed);
   void CheckPermissionMessageSent(int bridge_id, bool allowed);
   void CheckPermissionMessageSentForTab(int tab, int bridge_id, bool allowed);
   void CheckPermissionMessageSentInternal(MockRenderProcessHost* process,
                                           int bridge_id,
                                           bool allowed);
   void AddNewTab(const GURL& url);
   void CheckTabContentsState(const GURL& requesting_frame,
                              ContentSetting expected_content_setting);
+  base::string16 GetFirstRequestText(PermissionBubbleManager* mgr);
+  int GetBubblesQueueSize(PermissionBubbleManager* mgr);
+  void AcceptBubble(PermissionBubbleManager* mgr);
+  void DenyBubble(PermissionBubbleManager* mgr);
+  void BubbleManagerDocumentLoadCompleted();
 
   scoped_refptr<GeolocationPermissionContext> geolocation_permission_context_;
   ClosedInfoBarTracker closed_infobar_tracker_;
+  MockPermissionBubbleView bubble_view_;
   ScopedVector<content::WebContents> extra_tabs_;
 
   // A map between renderer child id and a pair represending the bridge id and
   // whether the requested permission was allowed.
   base::hash_map<int, std::pair<int, bool> > responses_;
 };
 
 PermissionRequestID GeolocationPermissionContextTests::RequestID(
     int bridge_id) {
   return PermissionRequestID(
       web_contents()->GetRenderProcessHost()->GetID(),
       web_contents()->GetRenderViewHost()->GetRoutingID(),
       bridge_id,
       GURL());
 }
 
 PermissionRequestID GeolocationPermissionContextTests::RequestIDForTab(
     int tab,
     int bridge_id) {
   return PermissionRequestID(
       extra_tabs_[tab]->GetRenderProcessHost()->GetID(),
       extra_tabs_[tab]->GetRenderViewHost()->GetRoutingID(),
       bridge_id,
       GURL());
 }
 
 void GeolocationPermissionContextTests::RequestGeolocationPermission(
     content::WebContents* web_contents,
     const PermissionRequestID& id,
-    const GURL& requesting_frame) {
-  RequestGeolocationPermission(web_contents, id, requesting_frame, NULL);
+    const GURL& requesting_frame,
+    bool user_gesture) {
+  RequestGeolocationPermission(web_contents, id, requesting_frame,
+                               user_gesture, NULL);
 }
 
 void GeolocationPermissionContextTests::RequestGeolocationPermission(
     content::WebContents* web_contents,
     const PermissionRequestID& id,
     const GURL& requesting_frame,
+    bool user_gesture,
     base::Closure* cancel_callback) {
   geolocation_permission_context_->RequestGeolocationPermission(
-      web_contents, id.bridge_id(), requesting_frame, false,
+      web_contents, id.bridge_id(), requesting_frame, user_gesture,
       base::Bind(&GeolocationPermissionContextTests::PermissionResponse,
                  base::Unretained(this), id),
       cancel_callback);
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
 }
 
 void GeolocationPermissionContextTests::PermissionResponse(
     const PermissionRequestID& id,
     bool allowed) {
@@ skipping 42 matching lines @@
   extra_tabs_.push_back(new_tab);
 }
 
 void GeolocationPermissionContextTests::CheckTabContentsState(
     const GURL& requesting_frame,
     ContentSetting expected_content_setting) {
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::FromWebContents(web_contents());
   const ContentSettingsUsagesState::StateMap& state_map =
       content_settings->geolocation_usages_state().state_map();
-  EXPECT_EQ(1U, state_map.count(requesting_frame.GetOrigin()));
-  EXPECT_EQ(0U, state_map.count(requesting_frame));
+  EXPECT_EQ(1U, state_map.count(requesting_frame.GetOrigin()))
+      << " for " << requesting_frame.spec();
+  EXPECT_EQ(0U, state_map.count(requesting_frame))
+      << " for " << requesting_frame.spec();
   ContentSettingsUsagesState::StateMap::const_iterator settings =
       state_map.find(requesting_frame.GetOrigin());
   ASSERT_FALSE(settings == state_map.end())
       << "geolocation state not found " << requesting_frame;
-  EXPECT_EQ(expected_content_setting, settings->second);
+  EXPECT_EQ(expected_content_setting, settings->second)
+      << " for " << requesting_frame.spec();
 }
 
 void GeolocationPermissionContextTests::SetUp() {
   ChromeRenderViewHostTestHarness::SetUp();
 
   // Set up required helpers, and make this be as "tabby" as the code requires.
 #if defined(ENABLE_EXTENSIONS)
   extensions::SetViewType(web_contents(), extensions::VIEW_TYPE_TAB_CONTENTS);
 #endif
   InfoBarService::CreateForWebContents(web_contents());
   TabSpecificContentSettings::CreateForWebContents(web_contents());
 #if defined(OS_ANDROID)
   MockGoogleLocationSettingsHelper::SetLocationStatus(true, true);
 #endif
   geolocation_permission_context_ =
       GeolocationPermissionContextFactory::GetForProfile(profile());
+
+  PermissionBubbleManager::CreateForWebContents(web_contents());
+  PermissionBubbleManager::FromWebContents(web_contents())->SetView(
+      &bubble_view_);
 }
 
 void GeolocationPermissionContextTests::TearDown() {
   extra_tabs_.clear();
   ChromeRenderViewHostTestHarness::TearDown();
 }
 
+base::string16 GeolocationPermissionContextTests::GetFirstRequestText(
+    PermissionBubbleManager* mgr) {
+  return mgr->requests_.front()->GetMessageText();
+}
+
+int GeolocationPermissionContextTests::GetBubblesQueueSize(
+    PermissionBubbleManager* mgr) {
+  return static_cast<int>(mgr->requests_.size());
+}
+
+void GeolocationPermissionContextTests::AcceptBubble(
+    PermissionBubbleManager* mgr) {
+  mgr->Accept();
+}
+
+void GeolocationPermissionContextTests::DenyBubble(
+    PermissionBubbleManager* mgr) {
+  mgr->Deny();
+}
+
+void GeolocationPermissionContextTests::BubbleManagerDocumentLoadCompleted() {
+  PermissionBubbleManager::FromWebContents(web_contents())->
+      DocumentOnLoadCompletedInMainFrame();
+}
+
 // Tests ----------------------------------------------------------------------
 
-TEST_F(GeolocationPermissionContextTests, SinglePermission) {
+TEST_F(GeolocationPermissionContextTests, SinglePermissionInfobar) {
+  if (PermissionBubbleManager::Enabled())
+    return;
+
   GURL requesting_frame("http://www.example.com/geolocation");
   NavigateAndCommit(requesting_frame);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
-  RequestGeolocationPermission(web_contents(), RequestID(0), requesting_frame);
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame, true);
   ASSERT_EQ(1U, infobar_service()->infobar_count());
   infobars::InfoBar* infobar = infobar_service()->infobar_at(0);
   ConfirmInfoBarDelegate* infobar_delegate =
       infobar->delegate()->AsConfirmInfoBarDelegate();
   ASSERT_TRUE(infobar_delegate);
   infobar_delegate->Cancel();
   infobar_service()->RemoveInfoBar(infobar);
   EXPECT_EQ(1U, closed_infobar_tracker_.size());
   EXPECT_TRUE(closed_infobar_tracker_.Contains(infobar));
 }
 
+TEST_F(GeolocationPermissionContextTests, SinglePermissionBubble) {
+  if (!PermissionBubbleManager::Enabled())
+    return;
+
+  GURL requesting_frame("http://www.example.com/geolocation");
+  NavigateAndCommit(requesting_frame);
+  BubbleManagerDocumentLoadCompleted();
+  EXPECT_EQ(0U, infobar_service()->infobar_count());
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame, true);
+  PermissionBubbleManager* mgr =
+      PermissionBubbleManager::FromWebContents(web_contents());
+  ASSERT_EQ(1, GetBubblesQueueSize(mgr));
+}
+
 #if defined(OS_ANDROID)
 TEST_F(GeolocationPermissionContextTests, GeolocationEnabledDisabled) {
   GURL requesting_frame("http://www.example.com/geolocation");
   NavigateAndCommit(requesting_frame);
   MockGoogleLocationSettingsHelper::SetLocationStatus(true, true);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
-  RequestGeolocationPermission(web_contents(), RequestID(0), requesting_frame);
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame, true);
   EXPECT_EQ(1U, infobar_service()->infobar_count());
   ConfirmInfoBarDelegate* infobar_delegate_0 =
       infobar_service()->infobar_at(0)->delegate()->AsConfirmInfoBarDelegate();
   ASSERT_TRUE(infobar_delegate_0);
   base::string16 text_0 = infobar_delegate_0->GetButtonLabel(
       ConfirmInfoBarDelegate::BUTTON_OK);
 
   Reload();
   MockGoogleLocationSettingsHelper::SetLocationStatus(true, false);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
-  RequestGeolocationPermission(web_contents(), RequestID(0), requesting_frame);
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame, true);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
 }
 
 TEST_F(GeolocationPermissionContextTests, MasterEnabledGoogleAppsEnabled) {
   GURL requesting_frame("http://www.example.com/geolocation");
   NavigateAndCommit(requesting_frame);
   MockGoogleLocationSettingsHelper::SetLocationStatus(true, true);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
-  RequestGeolocationPermission(web_contents(), RequestID(0), requesting_frame);
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame, true);
   EXPECT_EQ(1U, infobar_service()->infobar_count());
   ConfirmInfoBarDelegate* infobar_delegate =
       infobar_service()->infobar_at(0)->delegate()->AsConfirmInfoBarDelegate();
   ASSERT_TRUE(infobar_delegate);
   infobar_delegate->Accept();
   CheckTabContentsState(requesting_frame, CONTENT_SETTING_ALLOW);
   CheckPermissionMessageSent(0, true);
 }
 
 TEST_F(GeolocationPermissionContextTests, MasterEnabledGoogleAppsDisabled) {
   GURL requesting_frame("http://www.example.com/geolocation");
   NavigateAndCommit(requesting_frame);
   MockGoogleLocationSettingsHelper::SetLocationStatus(true, false);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
-  RequestGeolocationPermission(web_contents(), RequestID(0), requesting_frame);
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame, true);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
 }
 #endif
 
-TEST_F(GeolocationPermissionContextTests, QueuedPermission) {
+TEST_F(GeolocationPermissionContextTests, QueuedPermissionInfobar) {
+  if (PermissionBubbleManager::Enabled())
+    return;
+
   GURL requesting_frame_0("http://www.example.com/geolocation");
   GURL requesting_frame_1("http://www.example-2.com/geolocation");
   EXPECT_EQ(CONTENT_SETTING_ASK,
             profile()->GetHostContentSettingsMap()->GetContentSetting(
                 requesting_frame_0, requesting_frame_0,
                 CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
   EXPECT_EQ(CONTENT_SETTING_ASK,
             profile()->GetHostContentSettingsMap()->GetContentSetting(
                 requesting_frame_1, requesting_frame_0,
                 CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
 
   NavigateAndCommit(requesting_frame_0);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
   // Request permission for two frames.
   RequestGeolocationPermission(
-      web_contents(), RequestID(0), requesting_frame_0);
+      web_contents(), RequestID(0), requesting_frame_0, true);
   RequestGeolocationPermission(
-      web_contents(), RequestID(1), requesting_frame_1);
+      web_contents(), RequestID(1), requesting_frame_1, true);
   // Ensure only one infobar is created.
   ASSERT_EQ(1U, infobar_service()->infobar_count());
   infobars::InfoBar* infobar_0 = infobar_service()->infobar_at(0);
   ConfirmInfoBarDelegate* infobar_delegate_0 =
       infobar_0->delegate()->AsConfirmInfoBarDelegate();
   ASSERT_TRUE(infobar_delegate_0);
   base::string16 text_0 = infobar_delegate_0->GetMessageText();
 
   // Accept the first frame.
   infobar_delegate_0->Accept();
@@ skipping 27 matching lines @@
             profile()->GetHostContentSettingsMap()->GetContentSetting(
                 requesting_frame_0, requesting_frame_0,
                 CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
 
   EXPECT_EQ(CONTENT_SETTING_BLOCK,
             profile()->GetHostContentSettingsMap()->GetContentSetting(
                 requesting_frame_1, requesting_frame_0,
                 CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
 }
 
-TEST_F(GeolocationPermissionContextTests, HashIsIgnored) {
+TEST_F(GeolocationPermissionContextTests, QueuedPermissionBubble) {
+  if (!PermissionBubbleManager::Enabled())
+    return;
+
+  GURL requesting_frame_0("http://www.example.com/geolocation");
+  GURL requesting_frame_1("http://www.example-2.com/geolocation");
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+            profile()->GetHostContentSettingsMap()->GetContentSetting(
+                requesting_frame_0, requesting_frame_0,
+                CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+            profile()->GetHostContentSettingsMap()->GetContentSetting(
+                requesting_frame_1, requesting_frame_0,
+                CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
+
+  NavigateAndCommit(requesting_frame_0);
+  BubbleManagerDocumentLoadCompleted();
+
+  PermissionBubbleManager* mgr =
+      PermissionBubbleManager::FromWebContents(web_contents());
+  ASSERT_EQ(0, GetBubblesQueueSize(mgr));
+
+  // Request permission for two frames.
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame_0, true);
+  RequestGeolocationPermission(
+      web_contents(), RequestID(1), requesting_frame_1, true);
+  // Only main frame permission shown.
+  ASSERT_EQ(1, GetBubblesQueueSize(mgr));
+  base::string16 text_0 = GetFirstRequestText(mgr);
+
+  // Accept the first frame.
+  AcceptBubble(mgr);
+  CheckTabContentsState(requesting_frame_0, CONTENT_SETTING_ALLOW);
+  CheckPermissionMessageSent(0, true);
+
+  // Now we should have a new bubble for the second frame.
+  EXPECT_EQ(1, GetBubblesQueueSize(mgr));
+
+  base::string16 text_1 = GetFirstRequestText(mgr);
+  EXPECT_NE(text_0, text_1);
+
+  // Cancel (block) this frame.
+  DenyBubble(mgr);
+  CheckTabContentsState(requesting_frame_1, CONTENT_SETTING_BLOCK);
+  CheckPermissionMessageSent(1, false);
+
+  // Ensure the persisted permissions are ok.
+  EXPECT_EQ(CONTENT_SETTING_ALLOW,
+            profile()->GetHostContentSettingsMap()->GetContentSetting(
+                requesting_frame_0, requesting_frame_0,
+                CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
+
+  EXPECT_EQ(CONTENT_SETTING_BLOCK,
+            profile()->GetHostContentSettingsMap()->GetContentSetting(
+                requesting_frame_1, requesting_frame_0,
+                CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
+}
+
+TEST_F(GeolocationPermissionContextTests, UrlFragmentIsIgnoredInfobar) {
+  if (PermissionBubbleManager::Enabled())
+    return;
+
   GURL url_a("http://www.example.com/geolocation#a");
   GURL url_b("http://www.example.com/geolocation#b");
 
   // Navigate to the first url and check permission is requested.
   NavigateAndCommit(url_a);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
-  RequestGeolocationPermission(web_contents(), RequestID(0), url_a);
+  RequestGeolocationPermission(web_contents(), RequestID(0), url_a, true);
   ASSERT_EQ(1U, infobar_service()->infobar_count());
   infobars::InfoBar* infobar = infobar_service()->infobar_at(0);
   ConfirmInfoBarDelegate* infobar_delegate =
       infobar->delegate()->AsConfirmInfoBarDelegate();
   ASSERT_TRUE(infobar_delegate);
 
   // Change the hash, we'll still be on the same page.
   NavigateAndCommit(url_b);
 
   // Accept.
   infobar_delegate->Accept();
   CheckTabContentsState(url_a, CONTENT_SETTING_ALLOW);
   CheckTabContentsState(url_b, CONTENT_SETTING_ALLOW);
   CheckPermissionMessageSent(0, true);
 
   // Cleanup.
   infobar_service()->RemoveInfoBar(infobar);
   EXPECT_EQ(1U, closed_infobar_tracker_.size());
   EXPECT_TRUE(closed_infobar_tracker_.Contains(infobar));
 }
 
-TEST_F(GeolocationPermissionContextTests, PermissionForFileScheme) {
+TEST_F(GeolocationPermissionContextTests, UrlFragmentIsIgnoredBubble) {
+  if (!PermissionBubbleManager::Enabled())
+    return;
+
+  GURL url_a("http://www.example.com/geolocation#a");
+  GURL url_b("http://www.example.com/geolocation#b");
+
+  // Navigate to the first url and check permission is requested.
+  NavigateAndCommit(url_a);
+  BubbleManagerDocumentLoadCompleted();
+
+  PermissionBubbleManager* mgr =
+      PermissionBubbleManager::FromWebContents(web_contents());
+  ASSERT_EQ(0, GetBubblesQueueSize(mgr));
+
+  RequestGeolocationPermission(web_contents(), RequestID(0), url_a, true);
+  ASSERT_EQ(1, GetBubblesQueueSize(mgr));
+
+  // Change the hash, we'll still be on the same page.
+  NavigateAndCommit(url_b);
+  BubbleManagerDocumentLoadCompleted();
+  ASSERT_EQ(1, GetBubblesQueueSize(mgr));
+
+  // Accept.
+  AcceptBubble(mgr);
+  CheckTabContentsState(url_a, CONTENT_SETTING_ALLOW);
+  CheckTabContentsState(url_b, CONTENT_SETTING_ALLOW);
+  CheckPermissionMessageSent(0, true);
+}
+
+TEST_F(GeolocationPermissionContextTests, PermissionForFileSchemeInfobars) {
+  if (PermissionBubbleManager::Enabled())
+    return;
+
   GURL requesting_frame("file://example/geolocation.html");
   NavigateAndCommit(requesting_frame);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
-  RequestGeolocationPermission(web_contents(), RequestID(0), requesting_frame);
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame, true);
   EXPECT_EQ(1U, infobar_service()->infobar_count());
   infobars::InfoBar* infobar = infobar_service()->infobar_at(0);
   ConfirmInfoBarDelegate* infobar_delegate =
       infobar->delegate()->AsConfirmInfoBarDelegate();
   ASSERT_TRUE(infobar_delegate);
   // Accept the frame.
   infobar_delegate->Accept();
   CheckTabContentsState(requesting_frame, CONTENT_SETTING_ALLOW);
   CheckPermissionMessageSent(0, true);
   infobar_service()->RemoveInfoBar(infobar);
 
   // Make sure the setting is not stored.
   EXPECT_EQ(CONTENT_SETTING_ASK,
       profile()->GetHostContentSettingsMap()->GetContentSetting(
           requesting_frame,
           requesting_frame,
           CONTENT_SETTINGS_TYPE_GEOLOCATION,
           std::string()));
 }
 
-TEST_F(GeolocationPermissionContextTests, CancelGeolocationPermissionRequest) {
+TEST_F(GeolocationPermissionContextTests, PermissionForFileSchemeBubbles) {
+  if (!PermissionBubbleManager::Enabled())
+    return;
+
+  GURL requesting_frame("file://example/geolocation.html");
+  NavigateAndCommit(requesting_frame);
+  BubbleManagerDocumentLoadCompleted();
+
+  PermissionBubbleManager* mgr =
+      PermissionBubbleManager::FromWebContents(web_contents());
+  ASSERT_EQ(0, GetBubblesQueueSize(mgr));
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame, true);
+  ASSERT_EQ(1, GetBubblesQueueSize(mgr));
+
+  // Accept the frame.
+  AcceptBubble(mgr);
+  CheckTabContentsState(requesting_frame, CONTENT_SETTING_ALLOW);
+  CheckPermissionMessageSent(0, true);
+
+  // Make sure the setting is not stored.
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+      profile()->GetHostContentSettingsMap()->GetContentSetting(
+          requesting_frame,
+          requesting_frame,
+          CONTENT_SETTINGS_TYPE_GEOLOCATION,
+          std::string()));
+}
+
+TEST_F(GeolocationPermissionContextTests,
+       CancelGeolocationPermissionRequestInfobar) {
+  if (PermissionBubbleManager::Enabled())
+    return;
+
   GURL requesting_frame_0("http://www.example.com/geolocation");
   GURL requesting_frame_1("http://www.example-2.com/geolocation");
   EXPECT_EQ(CONTENT_SETTING_ASK,
             profile()->GetHostContentSettingsMap()->GetContentSetting(
                 requesting_frame_0, requesting_frame_0,
                 CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
 
   EXPECT_EQ(CONTENT_SETTING_ASK,
             profile()->GetHostContentSettingsMap()->GetContentSetting(
                 requesting_frame_1, requesting_frame_0,
                 CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
 
   NavigateAndCommit(requesting_frame_0);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
   // Request permission for two frames.
   base::Closure cancel_callback;
   RequestGeolocationPermission(
-      web_contents(), RequestID(0), requesting_frame_0, &cancel_callback);
+      web_contents(), RequestID(0), requesting_frame_0, true, &cancel_callback);
   RequestGeolocationPermission(
-      web_contents(), RequestID(1), requesting_frame_1);
+      web_contents(), RequestID(1), requesting_frame_1, true);
   ASSERT_EQ(1U, infobar_service()->infobar_count());
 
   infobars::InfoBar* infobar_0 = infobar_service()->infobar_at(0);
   ConfirmInfoBarDelegate* infobar_delegate_0 =
       infobar_0->delegate()->AsConfirmInfoBarDelegate();
   ASSERT_TRUE(infobar_delegate_0);
   base::string16 text_0 = infobar_delegate_0->GetMessageText();
 
   // Simulate the frame going away, ensure the infobar for this frame
   // is removed and the next pending infobar is created.
@@ skipping 23 matching lines @@
             profile()->GetHostContentSettingsMap()->GetContentSetting(
                 requesting_frame_0, requesting_frame_0,
                 CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
 
   EXPECT_EQ(CONTENT_SETTING_ALLOW,
             profile()->GetHostContentSettingsMap()->GetContentSetting(
                 requesting_frame_1, requesting_frame_0,
                 CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
 }
 
+TEST_F(GeolocationPermissionContextTests,
+       CancelGeolocationPermissionRequestBubbles) {
+  if (!PermissionBubbleManager::Enabled())
+    return;
+
+  GURL requesting_frame_0("http://www.example.com/geolocation");
+  GURL requesting_frame_1("http://www.example-2.com/geolocation");
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+            profile()->GetHostContentSettingsMap()->GetContentSetting(
+                requesting_frame_0, requesting_frame_0,
+                CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
+
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+            profile()->GetHostContentSettingsMap()->GetContentSetting(
+                requesting_frame_1, requesting_frame_0,
+                CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
+
+  NavigateAndCommit(requesting_frame_0);
+  BubbleManagerDocumentLoadCompleted();
+  EXPECT_EQ(0U, infobar_service()->infobar_count());
+  // Request permission for two frames.
+  base::Closure cancel_callback;
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame_0, true, &cancel_callback);
+  RequestGeolocationPermission(
+      web_contents(), RequestID(1), requesting_frame_1, true);
+
+  PermissionBubbleManager* mgr =
+      PermissionBubbleManager::FromWebContents(web_contents());
+  ASSERT_TRUE(mgr != NULL);
+  ASSERT_EQ(1, GetBubblesQueueSize(mgr));
+  base::string16 text_0 = GetFirstRequestText(mgr);
+  ASSERT_NE(base::string16(), text_0);
+
+  // Cancel the request. This will still leave the bubble showing, since
+  // the request is showing in the view. It will just be dummied.
+  cancel_callback.Run();
+  AcceptBubble(mgr);       // Dummy accept
+  base::string16 text_1 = GetFirstRequestText(mgr);
+  EXPECT_NE(text_0, text_1);
+
+  // Allow this frame.
+  AcceptBubble(mgr);
+  CheckTabContentsState(requesting_frame_1, CONTENT_SETTING_ALLOW);
+  CheckPermissionMessageSent(1, true);
+  EXPECT_EQ(0, GetBubblesQueueSize(mgr));
+
+  // Ensure the persisted permissions are ok.
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+            profile()->GetHostContentSettingsMap()->GetContentSetting(
+                requesting_frame_0, requesting_frame_0,
+                CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
+
+  EXPECT_EQ(CONTENT_SETTING_ALLOW,
+            profile()->GetHostContentSettingsMap()->GetContentSetting(
+                requesting_frame_1, requesting_frame_0,
+                CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
+}
+
 TEST_F(GeolocationPermissionContextTests, InvalidURL) {
   GURL invalid_embedder("about:blank");
   GURL requesting_frame;
   NavigateAndCommit(invalid_embedder);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
-  RequestGeolocationPermission(web_contents(), RequestID(0), requesting_frame);
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame, true);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
   CheckPermissionMessageSent(0, false);
 }
 
-TEST_F(GeolocationPermissionContextTests, SameOriginMultipleTabs) {
+TEST_F(GeolocationPermissionContextTests, SameOriginMultipleTabsInfobar) {
+  if (PermissionBubbleManager::Enabled())
+    return;
+
   GURL url_a("http://www.example.com/geolocation");
   GURL url_b("http://www.example-2.com/geolocation");
   NavigateAndCommit(url_a);
   AddNewTab(url_b);
   AddNewTab(url_a);
 
   EXPECT_EQ(0U, infobar_service()->infobar_count());
-  RequestGeolocationPermission(web_contents(), RequestID(0), url_a);
+  RequestGeolocationPermission(web_contents(), RequestID(0), url_a, true);
   ASSERT_EQ(1U, infobar_service()->infobar_count());
 
-  RequestGeolocationPermission(extra_tabs_[0], RequestIDForTab(0, 0), url_b);
+  RequestGeolocationPermission(
+      extra_tabs_[0], RequestIDForTab(0, 0), url_b, true);
   EXPECT_EQ(1U, infobar_service_for_tab(0)->infobar_count());
 
-  RequestGeolocationPermission(extra_tabs_[1], RequestIDForTab(1, 0), url_a);
+  RequestGeolocationPermission(
+      extra_tabs_[1], RequestIDForTab(1, 0), url_a, true);
   ASSERT_EQ(1U, infobar_service_for_tab(1)->infobar_count());
 
   infobars::InfoBar* removed_infobar =
       infobar_service_for_tab(1)->infobar_at(0);
 
   // Accept the first tab.
   infobars::InfoBar* infobar_0 = infobar_service()->infobar_at(0);
   ConfirmInfoBarDelegate* infobar_delegate_0 =
       infobar_0->delegate()->AsConfirmInfoBarDelegate();
   ASSERT_TRUE(infobar_delegate_0);
@@ skipping 13 matching lines @@
   infobars::InfoBar* infobar_1 = infobar_service_for_tab(0)->infobar_at(0);
   ConfirmInfoBarDelegate* infobar_delegate_1 =
       infobar_1->delegate()->AsConfirmInfoBarDelegate();
   ASSERT_TRUE(infobar_delegate_1);
   infobar_delegate_1->Cancel();
   infobar_service_for_tab(0)->RemoveInfoBar(infobar_1);
   EXPECT_EQ(1U, closed_infobar_tracker_.size());
   EXPECT_TRUE(closed_infobar_tracker_.Contains(infobar_1));
 }
 
-TEST_F(GeolocationPermissionContextTests, QueuedOriginMultipleTabs) {
+TEST_F(GeolocationPermissionContextTests, QueuedOriginMultipleTabsInfobar) {
+  if (PermissionBubbleManager::Enabled())
+    return;
+
   GURL url_a("http://www.example.com/geolocation");
   GURL url_b("http://www.example-2.com/geolocation");
   NavigateAndCommit(url_a);
   AddNewTab(url_a);
 
   EXPECT_EQ(0U, infobar_service()->infobar_count());
-  RequestGeolocationPermission(web_contents(), RequestID(0), url_a);
+  RequestGeolocationPermission(web_contents(), RequestID(0), url_a, true);
   ASSERT_EQ(1U, infobar_service()->infobar_count());
 
-  RequestGeolocationPermission(extra_tabs_[0], RequestIDForTab(0, 0), url_a);
+  RequestGeolocationPermission(
+      extra_tabs_[0], RequestIDForTab(0, 0), url_a, true);
   EXPECT_EQ(1U, infobar_service_for_tab(0)->infobar_count());
 
-  RequestGeolocationPermission(extra_tabs_[0], RequestIDForTab(0, 1), url_b);
+  RequestGeolocationPermission(
+      extra_tabs_[0], RequestIDForTab(0, 1), url_b, true);
   ASSERT_EQ(1U, infobar_service_for_tab(0)->infobar_count());
 
   infobars::InfoBar* removed_infobar = infobar_service()->infobar_at(0);
 
   // Accept the second tab.
   infobars::InfoBar* infobar_0 = infobar_service_for_tab(0)->infobar_at(0);
   ConfirmInfoBarDelegate* infobar_delegate_0 =
       infobar_0->delegate()->AsConfirmInfoBarDelegate();
   ASSERT_TRUE(infobar_delegate_0);
   infobar_delegate_0->Accept();
@@ skipping 15 matching lines @@
   ConfirmInfoBarDelegate* infobar_delegate_1 =
       infobar_1->delegate()->AsConfirmInfoBarDelegate();
   ASSERT_TRUE(infobar_delegate_1);
   infobar_delegate_1->Accept();
   CheckPermissionMessageSentForTab(0, 1, true);
   infobar_service_for_tab(0)->RemoveInfoBar(infobar_1);
   EXPECT_EQ(1U, closed_infobar_tracker_.size());
   EXPECT_TRUE(closed_infobar_tracker_.Contains(infobar_1));
 }
 
-TEST_F(GeolocationPermissionContextTests, TabDestroyed) {
+TEST_F(GeolocationPermissionContextTests, TabDestroyedInfobar) {
+  if (PermissionBubbleManager::Enabled())
+    return;
+
   GURL requesting_frame_0("http://www.example.com/geolocation");
   GURL requesting_frame_1("http://www.example-2.com/geolocation");
   EXPECT_EQ(CONTENT_SETTING_ASK,
             profile()->GetHostContentSettingsMap()->GetContentSetting(
                 requesting_frame_0, requesting_frame_0,
                 CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
 
   EXPECT_EQ(CONTENT_SETTING_ASK,
             profile()->GetHostContentSettingsMap()->GetContentSetting(
                 requesting_frame_1, requesting_frame_0,
                 CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
 
   NavigateAndCommit(requesting_frame_0);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
   // Request permission for two frames.
   RequestGeolocationPermission(
-      web_contents(), RequestID(0), requesting_frame_0);
+      web_contents(), RequestID(0), requesting_frame_0, true);
   RequestGeolocationPermission(
-      web_contents(), RequestID(1), requesting_frame_1);
+      web_contents(), RequestID(1), requesting_frame_1, true);
   // Ensure only one infobar is created.
   ASSERT_EQ(1U, infobar_service()->infobar_count());
   infobars::InfoBar* infobar = infobar_service()->infobar_at(0);
 
   // Delete the tab contents.
   DeleteContents();
 
   // During contents destruction, the infobar will have been closed, and the
   // pending request should have been cleared without an infobar being created.
   ASSERT_EQ(1U, closed_infobar_tracker_.size());
   ASSERT_TRUE(closed_infobar_tracker_.Contains(infobar));
 }
 
+TEST_F(GeolocationPermissionContextTests, TabDestroyedBubbles) {
+  if (!PermissionBubbleManager::Enabled())
+    return;
+
+  GURL requesting_frame_0("http://www.example.com/geolocation");
+  GURL requesting_frame_1("http://www.example-2.com/geolocation");
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+            profile()->GetHostContentSettingsMap()->GetContentSetting(
+                requesting_frame_0, requesting_frame_0,
+                CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
+
+  EXPECT_EQ(CONTENT_SETTING_ASK,
+            profile()->GetHostContentSettingsMap()->GetContentSetting(
+                requesting_frame_1, requesting_frame_0,
+                CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
+
+  NavigateAndCommit(requesting_frame_0);
+  BubbleManagerDocumentLoadCompleted();
+  PermissionBubbleManager* mgr =
+      PermissionBubbleManager::FromWebContents(web_contents());
+  ASSERT_TRUE(mgr != NULL);
+  ASSERT_EQ(0, GetBubblesQueueSize(mgr));
+
+  // Request permission for two frames.
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame_0, true);
+  RequestGeolocationPermission(
+      web_contents(), RequestID(1), requesting_frame_1, true);
+  // Ensure only one bubble request is shown.
+  ASSERT_EQ(1, GetBubblesQueueSize(mgr));
+
+  // Delete the tab contents.
+  DeleteContents();
+
+  // During contents destruction, the bubble will have been closed, and the
+  // pending request should have been cleared without a bubble being shown.
+}
+
 TEST_F(GeolocationPermissionContextTests, InfoBarUsesCommittedEntry) {
+  if (PermissionBubbleManager::Enabled())
+    return;
+
   GURL requesting_frame_0("http://www.example.com/geolocation");
   GURL requesting_frame_1("http://www.example-2.com/geolocation");
   NavigateAndCommit(requesting_frame_0);
   NavigateAndCommit(requesting_frame_1);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
   // Go back: navigate to a pending entry before requesting geolocation
   // permission.
   web_contents()->GetController().GoBack();
   // Request permission for the committed frame (not the pending one).
   RequestGeolocationPermission(
-      web_contents(), RequestID(0), requesting_frame_1);
+      web_contents(), RequestID(0), requesting_frame_1, true);
   // Ensure the infobar is created.
   ASSERT_EQ(1U, infobar_service()->infobar_count());
   infobars::InfoBarDelegate* infobar_delegate =
       infobar_service()->infobar_at(0)->delegate();
   ASSERT_TRUE(infobar_delegate);
   // Ensure the infobar wouldn't expire for a navigation to the committed entry.
   content::LoadCommittedDetails details;
   details.entry = web_contents()->GetController().GetLastCommittedEntry();
   EXPECT_FALSE(infobar_delegate->ShouldExpire(
       InfoBarService::NavigationDetailsFromLoadCommittedDetails(details)));
@@ skipping 17 matching lines @@
   HostContentSettingsMap* map = profile()->GetHostContentSettingsMap();
   map->SetPrefClockForTesting(scoped_ptr<base::Clock>(test_clock));
 
   // The permission shouldn't have been used yet.
   EXPECT_EQ(map->GetLastUsage(requesting_frame.GetOrigin(),
                               requesting_frame.GetOrigin(),
                               CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
             0);
 
   EXPECT_EQ(0U, infobar_service()->infobar_count());
-  RequestGeolocationPermission(web_contents(), RequestID(0), requesting_frame);
-  ASSERT_EQ(1U, infobar_service()->infobar_count());
-  infobars::InfoBar* infobar = infobar_service()->infobar_at(0);
-  ConfirmInfoBarDelegate* infobar_delegate =
-      infobar->delegate()->AsConfirmInfoBarDelegate();
-  ASSERT_TRUE(infobar_delegate);
-  infobar_delegate->Accept();
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame, true);
+
+  if (!PermissionBubbleManager::Enabled()) {
+    ASSERT_EQ(1U, infobar_service()->infobar_count());
+    infobars::InfoBar* infobar = infobar_service()->infobar_at(0);
+    ConfirmInfoBarDelegate* infobar_delegate =
+        infobar->delegate()->AsConfirmInfoBarDelegate();
+    ASSERT_TRUE(infobar_delegate);
+    infobar_delegate->Accept();
+  } else {
+    PermissionBubbleManager* mgr =
+        PermissionBubbleManager::FromWebContents(web_contents());
+    AcceptBubble(mgr);
+  }
+
   CheckTabContentsState(requesting_frame, CONTENT_SETTING_ALLOW);
   CheckPermissionMessageSent(0, true);
 
   // Permission has been used at the starting time.
   EXPECT_EQ(map->GetLastUsage(requesting_frame.GetOrigin(),
                               requesting_frame.GetOrigin(),
                               CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
             10);
 
   test_clock->Advance(base::TimeDelta::FromSeconds(3));
-  RequestGeolocationPermission(web_contents(), RequestID(0), requesting_frame);
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame, true);
 
   // Permission has been used three seconds later.
   EXPECT_EQ(map->GetLastUsage(requesting_frame.GetOrigin(),
                               requesting_frame.GetOrigin(),
                               CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
             13);
 }
 
-TEST_F(GeolocationPermissionContextTests, LastUsageAuditedMultipleFrames) {
+TEST_F(GeolocationPermissionContextTests,
+       LastUsageAuditedMultipleFramesInfobar) {
+  if (PermissionBubbleManager::Enabled())
+    return;
+
   base::SimpleTestClock* test_clock = new base::SimpleTestClock;
   test_clock->SetNow(base::Time::UnixEpoch() +
                      base::TimeDelta::FromSeconds(10));
 
   HostContentSettingsMap* map = profile()->GetHostContentSettingsMap();
   map->SetPrefClockForTesting(scoped_ptr<base::Clock>(test_clock));
 
   GURL requesting_frame_0("http://www.example.com/geolocation");
   GURL requesting_frame_1("http://www.example-2.com/geolocation");
 
   // The permission shouldn't have been used yet.
   EXPECT_EQ(map->GetLastUsage(requesting_frame_0.GetOrigin(),
                               requesting_frame_0.GetOrigin(),
                               CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
             0);
   EXPECT_EQ(map->GetLastUsage(requesting_frame_1.GetOrigin(),
                               requesting_frame_0.GetOrigin(),
                               CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
             0);
 
   NavigateAndCommit(requesting_frame_0);
   EXPECT_EQ(0U, infobar_service()->infobar_count());
 
   // Request permission for two frames.
   RequestGeolocationPermission(
-      web_contents(), RequestID(0), requesting_frame_0);
+      web_contents(), RequestID(0), requesting_frame_0, true);
   RequestGeolocationPermission(
-      web_contents(), RequestID(1), requesting_frame_1);
+      web_contents(), RequestID(1), requesting_frame_1, true);
 
   // Ensure only one infobar is created.
   ASSERT_EQ(1U, infobar_service()->infobar_count());
   infobars::InfoBar* infobar_0 = infobar_service()->infobar_at(0);
   ConfirmInfoBarDelegate* infobar_delegate_0 =
       infobar_0->delegate()->AsConfirmInfoBarDelegate();
 
   // Accept the first frame.
   infobar_delegate_0->Accept();
+
   CheckTabContentsState(requesting_frame_0, CONTENT_SETTING_ALLOW);
   CheckPermissionMessageSent(0, true);
   infobar_service()->RemoveInfoBar(infobar_0);
 
   // Verify that accepting the first didn't accept because it's embedder
   // in the other.
   EXPECT_EQ(map->GetLastUsage(requesting_frame_0.GetOrigin(),
                               requesting_frame_0.GetOrigin(),
                               CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
             10);
@@ skipping 20 matching lines @@
                               requesting_frame_0.GetOrigin(),
                               CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
             10);
   EXPECT_EQ(map->GetLastUsage(requesting_frame_1.GetOrigin(),
                               requesting_frame_0.GetOrigin(),
                               CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
             11);
 
   test_clock->Advance(base::TimeDelta::FromSeconds(2));
   RequestGeolocationPermission(
-      web_contents(), RequestID(0), requesting_frame_0);
+      web_contents(), RequestID(0), requesting_frame_0, true);
 
   // Verify that requesting permission in one frame doesn't update other where
   // it is the embedder.
+  EXPECT_EQ(map->GetLastUsage(requesting_frame_0.GetOrigin(),
+                              requesting_frame_0.GetOrigin(),
+                              CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
+            13);
+  EXPECT_EQ(map->GetLastUsage(requesting_frame_1.GetOrigin(),
+                              requesting_frame_0.GetOrigin(),
+                              CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
+            11);
+}
+
+TEST_F(GeolocationPermissionContextTests,
+       LastUsageAuditedMultipleFramesBubble) {
+  if (!PermissionBubbleManager::Enabled())
+    return;
+
+  base::SimpleTestClock* test_clock = new base::SimpleTestClock;
+  test_clock->SetNow(base::Time::UnixEpoch() +
+                     base::TimeDelta::FromSeconds(10));
+
+  HostContentSettingsMap* map = profile()->GetHostContentSettingsMap();
+  map->SetPrefClockForTesting(scoped_ptr<base::Clock>(test_clock));
+
+  GURL requesting_frame_0("http://www.example.com/geolocation");
+  GURL requesting_frame_1("http://www.example-2.com/geolocation");
+
+  // The permission shouldn't have been used yet.
+  EXPECT_EQ(map->GetLastUsage(requesting_frame_0.GetOrigin(),
+                              requesting_frame_0.GetOrigin(),
+                              CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
+            0);
+  EXPECT_EQ(map->GetLastUsage(requesting_frame_1.GetOrigin(),
+                              requesting_frame_0.GetOrigin(),
+                              CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
+            0);
+
+  NavigateAndCommit(requesting_frame_0);
+  BubbleManagerDocumentLoadCompleted();
+  PermissionBubbleManager* mgr =
+      PermissionBubbleManager::FromWebContents(web_contents());
+  EXPECT_EQ(0, GetBubblesQueueSize(mgr));
+
+  // Request permission for two frames.
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame_0, true);
+  RequestGeolocationPermission(
+      web_contents(), RequestID(1), requesting_frame_1, true);
+  EXPECT_EQ(1, GetBubblesQueueSize(mgr));  // 1 in request queue, 1 in pending
+  content::RunAllPendingInMessageLoop();
+
+  // Accept the first frame.
+  AcceptBubble(mgr);
+
+LOG(INFO) << "Checking state after accepting requesting_frame_0";
+  CheckTabContentsState(requesting_frame_0, CONTENT_SETTING_ALLOW);
+  CheckPermissionMessageSent(0, true);
+
+  // Verify that accepting the first didn't accept because it's embedder
+  // in the other.
+  EXPECT_EQ(map->GetLastUsage(requesting_frame_0.GetOrigin(),
+                              requesting_frame_0.GetOrigin(),
+                              CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
+            10);
+  EXPECT_EQ(map->GetLastUsage(requesting_frame_1.GetOrigin(),
+                              requesting_frame_0.GetOrigin(),
+                              CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
+            0);
+
+  test_clock->Advance(base::TimeDelta::FromSeconds(1));
+  AcceptBubble(mgr);
+LOG(INFO) << "Checking state after accepting second bubble.";
+  CheckTabContentsState(requesting_frame_1, CONTENT_SETTING_ALLOW);
+  CheckPermissionMessageSent(1, true);
+
+  // Verify that the times are different.
+  EXPECT_EQ(map->GetLastUsage(requesting_frame_0.GetOrigin(),
+                              requesting_frame_0.GetOrigin(),
+                              CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
+            10);
+  EXPECT_EQ(map->GetLastUsage(requesting_frame_1.GetOrigin(),
+                              requesting_frame_0.GetOrigin(),
+                              CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
+            11);
+
+  test_clock->Advance(base::TimeDelta::FromSeconds(2));
+  RequestGeolocationPermission(
+      web_contents(), RequestID(0), requesting_frame_0, true);
+
+  // Verify that requesting permission in one frame doesn't update other where
+  // it is the embedder.
   EXPECT_EQ(map->GetLastUsage(requesting_frame_0.GetOrigin(),
                               requesting_frame_0.GetOrigin(),
                               CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
             13);
   EXPECT_EQ(map->GetLastUsage(requesting_frame_1.GetOrigin(),
                               requesting_frame_0.GetOrigin(),
                               CONTENT_SETTINGS_TYPE_GEOLOCATION).ToDoubleT(),
             11);
 }