[WebsiteSettings] Update permission bubble manager policy

chrome/browser/ui/website_settings/permission_bubble_manager.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
 
 #include "base/command_line.h"
 #include "chrome/browser/ui/website_settings/permission_bubble_request.h"
 #include "chrome/common/chrome_switches.h"
+#include "content/public/browser/browser_thread.h"
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(PermissionBubbleManager);
 
-namespace {
-
-// This is how many ms to wait to see if there's another permission request
-// we should coalesce.
-const int kPermissionsCoalesceIntervalMs = 400;
-
-}
-
 // static
 bool PermissionBubbleManager::Enabled() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnablePermissionsBubbles);
 }
 
 PermissionBubbleManager::PermissionBubbleManager(
     content::WebContents* web_contents)
   : content::WebContentsObserver(web_contents),
     bubble_showing_(false),
     view_(NULL),
-    customization_mode_(false) {
-  timer_.reset(new base::Timer(FROM_HERE,
-      base::TimeDelta::FromMilliseconds(kPermissionsCoalesceIntervalMs),
-      base::Bind(&PermissionBubbleManager::ShowBubble, base::Unretained(this)),
-      false));
-}
+    request_url_has_loaded_(false),
+    customization_mode_(false),
+    weak_factory_(this) {}
 
 PermissionBubbleManager::~PermissionBubbleManager() {
   if (view_ != NULL)
     view_->SetDelegate(NULL);
 
   std::vector<PermissionBubbleRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin();
        requests_iter != requests_.end();
        requests_iter++) {
     (*requests_iter)->RequestFinished();
@@ skipping 42 matching lines @@
 
   if (bubble_showing_) {
     queued_requests_.push_back(request);
     return;
   }
 
   requests_.push_back(request);
   // TODO(gbillock): do we need to make default state a request property?
   accept_states_.push_back(true);
 
-  // Start the timer when there is both a view and a request.
-  if (view_ && !timer_->IsRunning())
-    timer_->Reset();
+  if (request->HasUserGesture())
+    ShowBubble();
 }
 
 void PermissionBubbleManager::CancelRequest(PermissionBubbleRequest* request) {
   // TODO(gbillock): implement
   NOTREACHED();
 }
 
 void PermissionBubbleManager::SetView(PermissionBubbleView* view) {
   if (view == view_)
     return;
 
   if (view_ != NULL) {
     view_->SetDelegate(NULL);
     view_->Hide();
     bubble_showing_ = false;
   }
 
   view_ = view;
   if (view_)
     view_->SetDelegate(this);
   else
     return;
 
-  // Even if there are requests queued up, add a short delay before the bubble
-  // appears.
-  if (!requests_.empty() && !timer_->IsRunning())
-    timer_->Reset();
-  else
-    view_->Hide();
+  ShowBubble();
 }
 
-void PermissionBubbleManager::DidFinishLoad(
-    int64 frame_id,
-    const GURL& validated_url,
-    bool is_main_frame,
-    content::RenderViewHost* render_view_host) {
-  // Allows extra time for additional requests to coalesce.
-  if (timer_->IsRunning())
-    timer_->Reset();
+void PermissionBubbleManager::DocumentOnLoadCompletedInMainFrame(
+    int32 page_id) {
+  request_url_has_loaded_ = true;
+  // This is scheduled because while all calls to the browser have been
+  // issued at DOMContentLoaded, they may be bouncing around in scheduled
+  // callbacks finding the UI thread still. This makes sure we allow those
+  // scheduled calls to AddRequest to complete before we show the page-load
+  // permissions bubble.
+  // TODO(gbillock): make this bind safe with a weak ptr.
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&PermissionBubbleManager::ShowBubble,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void PermissionBubbleManager::NavigationEntryCommitted(
     const content::LoadCommittedDetails& details) {
   if (!request_url_.is_empty() &&
       request_url_ != web_contents()->GetLastCommittedURL()) {
     // Kill off existing bubble and cancel any pending requests.
     CancelPendingQueue();
     FinalizeBubble();
   }
@@ skipping 53 matching lines @@
   std::vector<PermissionBubbleRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin();
        requests_iter != requests_.end();
        requests_iter++) {
     (*requests_iter)->Cancelled();
   }
   FinalizeBubble();
 }
 
 void PermissionBubbleManager::ShowBubble() {
-  if (view_ && !bubble_showing_ && requests_.size()) {
+  if (view_ && !bubble_showing_ && request_url_has_loaded_ &&
+      requests_.size()) {
     // Note: this should appear above Show() for testing, since in that
     // case we may do in-line calling of finalization.
     bubble_showing_ = true;
     view_->Show(requests_, accept_states_, customization_mode_);
   }
 }
 
 void PermissionBubbleManager::FinalizeBubble() {
   if (view_)
     view_->Hide();
   bubble_showing_ = false;
 
   std::vector<PermissionBubbleRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin();
        requests_iter != requests_.end();
        requests_iter++) {
     (*requests_iter)->RequestFinished();
   }
   requests_.clear();
   accept_states_.clear();
   if (queued_requests_.size()) {
     requests_ = queued_requests_;
     accept_states_.resize(requests_.size(), true);
     queued_requests_.clear();
-    // TODO(leng):  Explore other options of showing the next bubble.  The
-    // advantage of this is that it uses the same code path as the first bubble.
-    timer_->Reset();
+    ShowBubble();
   } else {
     request_url_ = GURL();
   }
 }
 
 void PermissionBubbleManager::CancelPendingQueue() {
   std::vector<PermissionBubbleRequest*>::iterator requests_iter;
   for (requests_iter = queued_requests_.begin();
        requests_iter != queued_requests_.end();
        requests_iter++) {
     (*requests_iter)->RequestFinished();
   }
 }
-
-void PermissionBubbleManager::SetCoalesceIntervalForTesting(int interval_ms) {
-  timer_.reset(new base::Timer(FROM_HERE,
-      base::TimeDelta::FromMilliseconds(interval_ms),
-      base::Bind(&PermissionBubbleManager::ShowBubble, base::Unretained(this)),
-      false));
-}