Add basic coalescing behavior to the permission bubble manager.

chrome/browser/ui/website_settings/permission_bubble_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_WEBSITE_SETTINGS_PERMISSION_BUBBLE_MANAGER_H_
 #define CHROME_BROWSER_UI_WEBSITE_SETTINGS_PERMISSION_BUBBLE_MANAGER_H_
 
 #include <vector>
 
+#include "base/timer/timer.h"
 #include "chrome/browser/ui/website_settings/permission_bubble_view.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 
 class PermissionBubbleRequest;
 
 // Provides access to permissions bubbles. Allows clients to add a request
 // callback interface to the existing permission bubble configuration.
 // Depending on the situation and policy, that may add new UI to an existing
 // permission bubble, create and show a new permission bubble, or provide no
 // visible UI action at all. (In that case, the request will be immediately
 // informed that the permission request failed.)
 //
 // A PermissionBubbleManager is associated with a particular WebContents.
 // Requests attached to a particular WebContents' PBM must outlive it.
 //
 // The PermissionBubbleManager should be addressed on the UI thread.
 class PermissionBubbleManager
     : public content::WebContentsObserver,
       public content::WebContentsUserData<PermissionBubbleManager>,
       public PermissionBubbleView::Delegate {
  public:
   // Return the flag-driven enabled state of permissions bubbles.
   static bool Enabled();
 
   virtual ~PermissionBubbleManager();
 
   // Add a new request to the permission bubble. Ownership of the request
   // remains with the caller. The caller must arrange for the request to
-  // outlive the PermissionBubbleManager.
+  // outlive the PermissionBubbleManager. If a bubble is visible when this
+  // call is made, the request will be queued up and shown after the current
+  // bubble closes.
   virtual void AddRequest(PermissionBubbleRequest* request);
 
   // Set the active view for the permission bubble. If this is NULL, it
   // means the permission bubble is no longer showing.
   virtual void SetView(PermissionBubbleView* view);
 
+ protected:
+  // Sets the coalesce time interval to |interval_ms|. For testing only.
+  void SetCoalesceIntervalForTesting(int interval_ms);
+
  private:
   friend class PermissionBubbleManagerTest;
   friend class content::WebContentsUserData<PermissionBubbleManager>;
 
   explicit PermissionBubbleManager(content::WebContents* web_contents);
 
   // contents::WebContentsObserver:
   virtual void WebContentsDestroyed(

[Greg Billock, 2014/02/07 20:14:24]

Lets add

DocumentOnLoadCompletedInMainFrame
DocumentLoadedInFrame

to this list. Then we can trigger on those signals and reset the timer as well.
That'll let us move faster on page load and will give us a trigger for unit
tests as well. Then we can figure out exactly what the relationship will be
between the timer and the load signals as we go.

[leng, 2014/02/08 00:11:18]

I tested those two functions, along with DidFinishLoad, and found that the
AddRequest call happened after all of them.  So for now, I suggest we leave only
DidFinishLoad, and if we find requests being made before it is called, we can
add the others.

[Greg Billock, 2014/02/11 16:26:50]

Sounds good. Did you try with iframes? That might trigger A but not B or
something... But perhaps just mark that a TODO and we'll pick it up later.

[leng, 2014/02/11 16:46:51]

I did not try with iframes.  Now you know how much I know about page loading. 
:)
I added a TODO, and will look into that.

       content::WebContents* web_contents) OVERRIDE;
 
   // PermissionBubbleView::Delegate:
   virtual void ToggleAccept(int request_index, bool new_value) OVERRIDE;
   virtual void SetCustomizationMode() OVERRIDE;
   virtual void Accept() OVERRIDE;
   virtual void Deny() OVERRIDE;
   virtual void Closing() OVERRIDE;
 
+  // Called when the coalescing timer is done. Will show the bubble.
+  void OnTimerExpired();
+
   // Finalize the pending permissions request.
   void FinalizeBubble();
 
   // Whether or not we are showing the bubble in this tab.
   bool bubble_showing_;
 
   // Set to the UI surface to be used to display the permissions requests.
   PermissionBubbleView* view_;
 
   std::vector<PermissionBubbleRequest*> requests_;
+  std::vector<PermissionBubbleRequest*> queued_requests_;
   std::vector<bool> accept_state_;
   bool customization_mode_;
+
+  scoped_ptr<base::Timer> timer_;
 };
 
 #endif  // CHROME_BROWSER_UI_WEBSITE_SETTINGS_PERMISSION_BUBBLE_MANAGER_H_