Show queued geolocation InfoBars when InfoBar is hidden.

chrome/browser/geolocation/chrome_geolocation_permission_context.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/chrome_geolocation_permission_context.h"
 
 #include <functional>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/google/google_util.h"
+#include "chrome/browser/infobars/infobar.h"
 #include "chrome/browser/infobars/infobar_tab_helper.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/confirm_infobar_delegate.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
+#include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "net/base/net_util.h"
@@ skipping 33 matching lines @@
                             int bridge_id,
                             const GURL& requesting_frame,
                             const GURL& emebedder,
                             base::Callback<void(bool)> callback);
 
   // Cancels a specific infobar request.
   void CancelInfoBarRequest(int render_process_id,
                             int render_view_id,
                             int bridge_id);
 
-  // Called by the InfoBarDelegate to notify it's closed. It'll display a new
-  // InfoBar if there's any request pending for this tab.
-  void OnInfoBarClosed(int render_process_id,
-                       int render_view_id,
-                       int bridge_id);
-
   // Called by the InfoBarDelegate to notify permission has been set.
   // It'll notify and dismiss any other pending InfoBar request for the same
   // |requesting_frame| and embedder.
   void OnPermissionSet(int render_process_id,
                        int render_view_id,
                        int bridge_id,
                        const GURL& requesting_frame,
                        const GURL& embedder,
                        bool allowed);
 
   // content::NotificationObserver
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   struct PendingInfoBarRequest;
   class RequestEquals;
 
   typedef std::vector<PendingInfoBarRequest> PendingInfoBarRequests;
 
   // Shows the first pending infobar for this tab.
-  void ShowQueuedInfoBar(int render_process_id, int render_view_id);
+  void ShowQueuedInfoBar(int render_process_id, int render_view_id,
+                         InfoBarTabHelper* helper);
 
-  // Cancels an InfoBar request and returns the next iterator position.
-  PendingInfoBarRequests::iterator CancelInfoBarRequestInternal(
-      PendingInfoBarRequests::iterator i);
+  // Removes any pending requests for a given tab.
+  void ClearPendingInfoBarRequestsForTab(int render_process_id,
+                                         int render_view_id);
+
+  InfoBarTabHelper* GetInfoBarHelper(int render_process_id, int render_view_id);
+  bool AlreadyShowingInfoBar(int render_process_id, int render_view_id);
 
   content::NotificationRegistrar registrar_;
 
   ChromeGeolocationPermissionContext* const geolocation_permission_context_;
   Profile* const profile_;
   PendingInfoBarRequests pending_infobar_requests_;
 };
 
 
 // GeolocationConfirmInfoBarDelegate ------------------------------------------
 
 namespace {
 
 class GeolocationConfirmInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   GeolocationConfirmInfoBarDelegate(
       InfoBarTabHelper* infobar_helper,
       GeolocationInfoBarQueueController* controller,
       int render_process_id,
       int render_view_id,
       int bridge_id,
       const GURL& requesting_frame_url,
       const std::string& display_languages);
 
+  int render_process_id() const { return render_process_id_; }
+  int render_view_id() const { return render_view_id_; }
+
  private:
-  virtual ~GeolocationConfirmInfoBarDelegate();
 
   // ConfirmInfoBarDelegate:
   virtual bool ShouldExpire(
       const content::LoadCommittedDetails& details) const OVERRIDE;
   virtual gfx::Image* GetIcon() const OVERRIDE;
   virtual Type GetInfoBarType() const OVERRIDE;
   virtual string16 GetMessageText() const OVERRIDE;
   virtual string16 GetButtonLabel(InfoBarButton button) const OVERRIDE;
   virtual bool Accept() OVERRIDE;
   virtual bool Cancel() OVERRIDE;
@@ skipping 28 matching lines @@
       render_view_id_(render_view_id),
       bridge_id_(bridge_id),
       requesting_frame_url_(requesting_frame_url),
       display_languages_(display_languages) {
   const NavigationEntry* committed_entry =
       infobar_helper->web_contents()->GetController().GetLastCommittedEntry();
   committed_contents_unique_id_ = committed_entry ?
       committed_entry->GetUniqueID() : 0;
 }
 
-GeolocationConfirmInfoBarDelegate::~GeolocationConfirmInfoBarDelegate() {
-  controller_->OnInfoBarClosed(render_process_id_, render_view_id_,
-                               bridge_id_);
-}
-
 bool GeolocationConfirmInfoBarDelegate::ShouldExpire(
     const content::LoadCommittedDetails& details) const {
   if (details.did_replace_entry || !details.is_navigation_to_different_page())
     return false;
   return committed_contents_unique_id_ != details.entry->GetUniqueID() ||
       content::PageTransitionStripQualifier(
           details.entry->GetTransitionType()) ==
               content::PAGE_TRANSITION_RELOAD;
 }
 
@@ skipping 73 matching lines @@
   bool Equals(int p_render_process_id,
               int p_render_view_id,
               int p_bridge_id) const;
 
   int render_process_id;
   int render_view_id;
   int bridge_id;
   GURL requesting_frame;
   GURL embedder;
   base::Callback<void(bool)> callback;
-  InfoBarDelegate* infobar_delegate;
+  GeolocationConfirmInfoBarDelegate* infobar_delegate;
 };
 
 GeolocationInfoBarQueueController::PendingInfoBarRequest::PendingInfoBarRequest(
     int render_process_id,
     int render_view_id,
     int bridge_id,
     const GURL& requesting_frame,
     const GURL& embedder,
     base::Callback<void(bool)> callback)
     : render_process_id(render_process_id),
@@ skipping 50 matching lines @@
     : render_process_id_(render_process_id),
       render_view_id_(render_view_id),
       bridge_id_(bridge_id) {
 }
 
 bool GeolocationInfoBarQueueController::RequestEquals::operator()(
     const PendingInfoBarRequest& request) const {
   return request.Equals(render_process_id_, render_view_id_, bridge_id_);
 }
 
-
 // GeolocationInfoBarQueueController ------------------------------------------
 
 GeolocationInfoBarQueueController::GeolocationInfoBarQueueController(
     ChromeGeolocationPermissionContext* geolocation_permission_context,
     Profile* profile)
     : geolocation_permission_context_(geolocation_permission_context),
       profile_(profile) {
 }
 
 GeolocationInfoBarQueueController::~GeolocationInfoBarQueueController() {
 }
 
 void GeolocationInfoBarQueueController::CreateInfoBarRequest(
     int render_process_id,
     int render_view_id,
     int bridge_id,
     const GURL& requesting_frame,
     const GURL& embedder,
     base::Callback<void(bool)> callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // We shouldn't get duplicate requests.
   DCHECK(std::find_if(pending_infobar_requests_.begin(),
       pending_infobar_requests_.end(),
       RequestEquals(render_process_id, render_view_id, bridge_id)) ==
       pending_infobar_requests_.end());
 
+  InfoBarTabHelper* helper = GetInfoBarHelper(render_process_id,
+                                              render_view_id);
+  if (!helper) {
+    // We won't be able to create any infobars, shortcut and remove any pending
+    // requests.
+    ClearPendingInfoBarRequestsForTab(render_process_id, render_view_id);
+    return;
+  }
   pending_infobar_requests_.push_back(PendingInfoBarRequest(render_process_id,
       render_view_id, bridge_id, requesting_frame, embedder, callback));
-  ShowQueuedInfoBar(render_process_id, render_view_id);
+  if (!AlreadyShowingInfoBar(render_process_id, render_view_id))
+    ShowQueuedInfoBar(render_process_id, render_view_id, helper);
 }
 
 void GeolocationInfoBarQueueController::CancelInfoBarRequest(
     int render_process_id,
     int render_view_id,
     int bridge_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   PendingInfoBarRequests::iterator i = std::find_if(
       pending_infobar_requests_.begin(), pending_infobar_requests_.end(),
       RequestEquals(render_process_id, render_view_id, bridge_id));
   // TODO(pkasting): Can this conditional become a DCHECK()?
-  if (i != pending_infobar_requests_.end())
-    CancelInfoBarRequestInternal(i);
-}
-
-void GeolocationInfoBarQueueController::OnInfoBarClosed(int render_process_id,
-                                                        int render_view_id,
-                                                        int bridge_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  PendingInfoBarRequests::iterator i = std::find_if(
-      pending_infobar_requests_.begin(), pending_infobar_requests_.end(),
-      RequestEquals(render_process_id, render_view_id, bridge_id));
-  if (i != pending_infobar_requests_.end())
+  if (i == pending_infobar_requests_.end())
+    return;
+  InfoBarDelegate* delegate = i->infobar_delegate;
+  if (!delegate) {
     pending_infobar_requests_.erase(i);
-
-  ShowQueuedInfoBar(render_process_id, render_view_id);
+    return;
+  }
+  InfoBarTabHelper* helper = GetInfoBarHelper(render_process_id,
+                                              render_view_id);
+  helper->RemoveInfoBar(delegate);
 }
 
 void GeolocationInfoBarQueueController::OnPermissionSet(
     int render_process_id,
     int render_view_id,
     int bridge_id,
     const GURL& requesting_frame,
     const GURL& embedder,
     bool allowed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ContentSetting content_setting =
       allowed ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK;
   profile_->GetHostContentSettingsMap()->SetContentSetting(
       ContentSettingsPattern::FromURLNoWildcard(requesting_frame.GetOrigin()),
       ContentSettingsPattern::FromURLNoWildcard(embedder.GetOrigin()),
       CONTENT_SETTINGS_TYPE_GEOLOCATION,
       std::string(),
       content_setting);
 
+  // Cancel this request first, then notify listeners.  TODO(pkasting): Why
+  // is this order important?
+  PendingInfoBarRequests requests_to_notify;
+  PendingInfoBarRequests infobars_to_remove;
   for (PendingInfoBarRequests::iterator i = pending_infobar_requests_.begin();
        i != pending_infobar_requests_.end(); ) {
     if (i->IsForPair(requesting_frame, embedder)) {
-      // Cancel this request first, then notify listeners.  TODO(pkasting): Why
-      // is this order important?
-      // NOTE: If the pending request had an infobar, TabContents will close it
-      // either synchronously or asynchronously, which will then pump the queue
-      // via OnInfoBarClosed().
-      PendingInfoBarRequest copied_request = *i;
-      // Don't let CancelInfoBarRequestInternal() call RemoveInfoBar() with the
-      // delegate that's currently calling us.  That delegate is in either
-      // Accept() or Cancel(), so its owning InfoBar will call RemoveInfoBar()
-      // later on in this callstack anyway; and if we do it here, and it causes
-      // the delegate to be deleted, our GURL& args will point to garbage and we
-      // may also cause other problems during stack unwinding.
-      if (i->Equals(render_process_id, render_view_id, bridge_id))
-        i->infobar_delegate = NULL;
-      i = CancelInfoBarRequestInternal(i);
-
-      geolocation_permission_context_->NotifyPermissionSet(
-          copied_request.render_process_id, copied_request.render_view_id,
-          copied_request.bridge_id, copied_request.requesting_frame,
-          copied_request.callback, allowed);
+      requests_to_notify.push_back(*i);
+      if (i->Equals(render_process_id, render_view_id, bridge_id)) {
+        // The delegate that called us is i, and it's currently in either
+        // Accept() or Cancel(). This means that the owning InfoBar will call
+        // RemoveInfoBar() later on, and that will trigger a notification we're
+        // observing.
+        ++i;
+      } else if (i->infobar_delegate) {
+        // This InfoBar is for the same frame/embedder pair, but in a different
+        // tab. We should remove it now that we've got an answer for it.
+        infobars_to_remove.push_back(*i);
+        ++i;
+      } else {
+        // We haven't created an InfoBar yet, just remove the pending request.
+        i = pending_infobar_requests_.erase(i);
+      }
     } else {
       ++i;
     }
   }
+
+  // Remove all InfoBars for the same |requesting_frame| and |embedder|.
+  for (PendingInfoBarRequests::iterator i = infobars_to_remove.begin();
+       i != infobars_to_remove.end(); ++i ) {
+    InfoBarTabHelper* helper = GetInfoBarHelper(i->render_process_id,
+                                                i->render_view_id);
+    helper->RemoveInfoBar(i->infobar_delegate);
+  }
+
+  // Send out the permission notifications.
+  for (PendingInfoBarRequests::iterator i = requests_to_notify.begin();
+       i != requests_to_notify.end(); ++i ) {
+    geolocation_permission_context_->NotifyPermissionSet(
+        i->render_process_id, i->render_view_id,
+        i->bridge_id, i->requesting_frame,
+        i->callback, allowed);
+  }
 }
 
 void GeolocationInfoBarQueueController::Observe(
-    int type, const content::NotificationSource& source,
+    int type,
+    const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                    source);
-  WebContents* web_contents = content::Source<WebContents>(source).ptr();
+  DCHECK_EQ(chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED, type);
+  // We will receive this notification for all infobar closures, so we need to
+  // check whether this is the geolocation infobar we're tracking.
+  InfoBarDelegate* delegate =
+      content::Details<InfoBarRemovedDetails>(details)->first;
   for (PendingInfoBarRequests::iterator i = pending_infobar_requests_.begin();
-       i != pending_infobar_requests_.end();) {
-    if (i->infobar_delegate == NULL &&
-        web_contents == tab_util::GetWebContentsByID(i->render_process_id,
-                                                     i->render_view_id)) {
-      i = pending_infobar_requests_.erase(i);
-    } else {
-      ++i;
+       i != pending_infobar_requests_.end(); ++i) {
+    GeolocationConfirmInfoBarDelegate* confirm_delegate = i->infobar_delegate;
+    if (confirm_delegate == delegate) {
+      InfoBarTabHelper* helper =
+          content::Source<InfoBarTabHelper>(source).ptr();
+      registrar_.Remove(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
+                        source);
+      int render_process_id = i->render_process_id;
+      int render_view_id = i->render_view_id;
+      pending_infobar_requests_.erase(i);
+      ShowQueuedInfoBar(render_process_id, render_view_id, helper);
+      return;
     }
   }
 }
 
-void GeolocationInfoBarQueueController::ShowQueuedInfoBar(int render_process_id,
-                                                          int render_view_id) {
-  WebContents* tab_contents =
-      tab_util::GetWebContentsByID(render_process_id, render_view_id);
-  TabContentsWrapper* wrapper = NULL;
-  if (tab_contents)
-    wrapper = TabContentsWrapper::GetCurrentWrapperForContents(tab_contents);
+void GeolocationInfoBarQueueController::ClearPendingInfoBarRequestsForTab(
+    int render_process_id,
+    int render_view_id) {
   for (PendingInfoBarRequests::iterator i = pending_infobar_requests_.begin();
        i != pending_infobar_requests_.end(); ) {
-    if (i->IsForTab(render_process_id, render_view_id)) {
-      if (!wrapper) {
-        i = pending_infobar_requests_.erase(i);
-        continue;
-      }
-
-      if (!i->infobar_delegate) {
-        if (!registrar_.IsRegistered(
-                this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                content::Source<WebContents>(tab_contents))) {
-          registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                         content::Source<WebContents>(tab_contents));
-        }
-        i->infobar_delegate = new GeolocationConfirmInfoBarDelegate(
-            wrapper->infobar_tab_helper(), this, render_process_id,
-            render_view_id, i->bridge_id, i->requesting_frame,
-            profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
-        wrapper->infobar_tab_helper()->AddInfoBar(i->infobar_delegate);
-      }
-      break;
-    }
-    ++i;
+    if (i->IsForTab(render_process_id, render_view_id))
+      i = pending_infobar_requests_.erase(i);
+    else
+      ++i;
   }
 }
 
-GeolocationInfoBarQueueController::PendingInfoBarRequests::iterator
-    GeolocationInfoBarQueueController::CancelInfoBarRequestInternal(
-    PendingInfoBarRequests::iterator i) {
-  InfoBarDelegate* delegate = i->infobar_delegate;
-  if (!delegate)
-    return pending_infobar_requests_.erase(i);
-
-  WebContents* web_contents =
-      tab_util::GetWebContentsByID(i->render_process_id, i->render_view_id);
-  if (!web_contents)
-    return pending_infobar_requests_.erase(i);
-
-  // WebContents will destroy the InfoBar, which will remove from our vector
-  // asynchronously.
+InfoBarTabHelper* GeolocationInfoBarQueueController::GetInfoBarHelper(
+    int render_process_id,
+    int render_view_id) {
+  WebContents* tab_contents =
+      tab_util::GetWebContentsByID(render_process_id, render_view_id);
+  if (!tab_contents)
+    return NULL;
   TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
-  wrapper->infobar_tab_helper()->RemoveInfoBar(i->infobar_delegate);
-  return ++i;
+      TabContentsWrapper::GetCurrentWrapperForContents(tab_contents);
+  if (!wrapper)
+    return NULL;
+  return wrapper->infobar_tab_helper();
 }
 
+bool GeolocationInfoBarQueueController::AlreadyShowingInfoBar(
+    int render_process_id,
+    int render_view_id) {
+  for (PendingInfoBarRequests::iterator i = pending_infobar_requests_.begin();
+       i != pending_infobar_requests_.end(); ++i) {
+    if (i->IsForTab(render_process_id, render_view_id) && i->infobar_delegate)
+      return true;
+  }
+  return false;
+}
+
+void GeolocationInfoBarQueueController::ShowQueuedInfoBar(
+    int render_process_id,
+    int render_view_id,
+    InfoBarTabHelper* helper) {
+  DCHECK(helper);
+  DCHECK(!AlreadyShowingInfoBar(render_process_id, render_view_id));
+  for (PendingInfoBarRequests::iterator i = pending_infobar_requests_.begin();
+       i != pending_infobar_requests_.end(); ++i) {
+    if (i->IsForTab(render_process_id, render_view_id) &&
+        !i->infobar_delegate) {
+        DCHECK(!registrar_.IsRegistered(
+            this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
+            content::Source<InfoBarTabHelper>(helper)));
+        registrar_.Add(
+            this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
+            content::Source<InfoBarTabHelper>(helper));
+        i->infobar_delegate = new GeolocationConfirmInfoBarDelegate(
+            helper, this, render_process_id,
+            render_view_id, i->bridge_id, i->requesting_frame,
+            profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
+        helper->AddInfoBar(i->infobar_delegate);
+        break;
+    }
+  }
+}
 
 // GeolocationPermissionContext -----------------------------------------------
 
 ChromeGeolocationPermissionContext::ChromeGeolocationPermissionContext(
     Profile* profile)
     : profile_(profile),
       ALLOW_THIS_IN_INITIALIZER_LIST(geolocation_infobar_queue_controller_(
          new GeolocationInfoBarQueueController(this, profile))) {
 }
 
@@ skipping 116 matching lines @@
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &ChromeGeolocationPermissionContext::CancelPendingInfoBarRequest,
             this, render_process_id, render_view_id, bridge_id));
      return;
   }
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   geolocation_infobar_queue_controller_->CancelInfoBarRequest(render_process_id,
       render_view_id, bridge_id);
 }