Add BubbleManager to manage bubbles and ChromeBubbleManager for events.

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 "base/metrics/user_metrics_action.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/website_settings/permission_bubble_delegate.h"
 #include "chrome/browser/ui/website_settings/permission_bubble_request.h"
 #include "chrome/common/chrome_switches.h"
+#include "components/bubble/bubble_delegate.h"
+#include "components/bubble/bubble_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/user_metrics.h"
 
 namespace {
 
 class CancelledRequest : public PermissionBubbleRequest {
  public:
   explicit CancelledRequest(PermissionBubbleRequest* cancelled)
       : icon_(cancelled->GetIconID()),
@@ skipping 48 matching lines @@
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePermissionsBubbles))
     return false;
   return true;
 }
 
 PermissionBubbleManager::PermissionBubbleManager(
     content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       require_user_gesture_(false),
-#if !defined(OS_ANDROID)  // No bubbles in android tests.
-      view_factory_(base::Bind(&PermissionBubbleView::Create)),
-#endif
-      view_(nullptr),
+      bubble_delegate_(nullptr),
+      bubble_manager_(nullptr),
       main_frame_has_fully_loaded_(false),
       auto_response_for_test_(NONE),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 PermissionBubbleManager::~PermissionBubbleManager() {
-  if (view_ != NULL)
-    view_->SetDelegate(NULL);
+  if (bubble_delegate_) {
+    DCHECK(bubble_manager_);
+    bubble_manager_->HideBubble(bubble_delegate_.get());
+    bubble_delegate_.reset();
+  }
 
   std::vector<PermissionBubbleRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin();
        requests_iter != requests_.end();
        requests_iter++) {
     (*requests_iter)->RequestFinished();
   }
   for (requests_iter = queued_requests_.begin();
        requests_iter != queued_requests_.end();
        requests_iter++) {
@@ skipping 66 matching lines @@
 
   std::vector<bool>::iterator accepts_iter = accept_states_.begin();
   for (requests_iter = requests_.begin(), accepts_iter = accept_states_.begin();
        requests_iter != requests_.end();
        requests_iter++, accepts_iter++) {
     if (*requests_iter != request)
       continue;
 
     // We can simply erase the current entry in the request table if we aren't
     // showing the dialog, or if we are showing it and it can accept the update.
-    bool can_erase = !IsBubbleVisible() || view_->CanAcceptRequestUpdate();
+    bool can_erase = !IsBubbleVisible();
+
+    // TODO(hcarmona): Don't forget this logic. Maybe improve it? Or remove it?
+    // bool can_erase = !IsBubbleVisible() || view_->CanAcceptRequestUpdate();
+
     if (can_erase) {
       (*requests_iter)->RequestFinished();
       requests_.erase(requests_iter);
       accept_states_.erase(accepts_iter);
 
       if (IsBubbleVisible()) {
-        view_->Hide();
+        bubble_manager_->HideBubble(bubble_delegate_.get());
         // Will redraw the bubble if it is being shown.
         TriggerShowBubble();
       }
       return;
     }
 
     // Cancel the existing request and replace it with a dummy.
     PermissionBubbleRequest* cancelled_request =
         new CancelledRequest(*requests_iter);
     (*requests_iter)->RequestFinished();
     *requests_iter = cancelled_request;
     return;
   }
 
   NOTREACHED();  // Callers should not cancel requests that are not pending.
 }
 
 void PermissionBubbleManager::HideBubble() {
   // Disengage from the existing view if there is one.
-  if (!view_)
+  if (!bubble_delegate_)
     return;
 
-  view_->SetDelegate(nullptr);
-  view_->Hide();
-  view_.reset();
+  // view_->SetDelegate(nullptr);
+  DCHECK(bubble_manager_);
+  bubble_manager_->HideBubble(bubble_delegate_.get());
+  bubble_delegate_.reset();
 }
 
 void PermissionBubbleManager::DisplayPendingRequests(Browser* browser) {
   if (IsBubbleVisible())
     return;
 
-  view_ = view_factory_.Run(browser);
-  view_->SetDelegate(this);
+  bubble_manager_ = browser->bubble_manager();
+  bubble_delegate_ =
+      make_scoped_ptr(new PermissionBubbleDelegate(browser, this));
+  // view_ = view_factory_.Run(browser);
+  // view_->SetDelegate(this);
 
   TriggerShowBubble();
 }
 
 void PermissionBubbleManager::UpdateAnchorPosition() {
-  if (view_)
-    view_->UpdateAnchorPosition();
+  // TODO(hcarmona): get rid of this function when the manager is hooked in.
+  if (bubble_delegate_)
+    bubble_manager_->UpdateBubblePosition(bubble_delegate_.get());
 }
 
 bool PermissionBubbleManager::IsBubbleVisible() {
-  return view_ && view_->IsVisible();
+  if (bubble_delegate_) {
+    DCHECK(bubble_manager_);
+    return bubble_manager_->IsBubbleVisible(bubble_delegate_.get());
+  }
+
+  return false;
 }
 
 gfx::NativeWindow PermissionBubbleManager::GetBubbleWindow() {
+  /*
+   * TODO(hcarmona): get rid of this function when the manager is hooked in.
   if (view_)
     return view_->GetNativeWindow();
+    */
   return nullptr;
 }
 
 void PermissionBubbleManager::RequireUserGesture(bool required) {
   require_user_gesture_ = required;
 }
 
 void PermissionBubbleManager::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
@@ skipping 95 matching lines @@
     return;
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&PermissionBubbleManager::TriggerShowBubble,
                  weak_factory_.GetWeakPtr()));
 }
 
 void PermissionBubbleManager::TriggerShowBubble() {
-  if (!view_)
+  if (!bubble_delegate_)
     return;
   if (IsBubbleVisible())
     return;
   if (!main_frame_has_fully_loaded_)
     return;
   if (requests_.empty() && queued_requests_.empty() &&
       queued_frame_requests_.empty()) {
     return;
   }
 
   if (requests_.empty()) {
     // Queues containing a user-gesture-generated request have priority.
     if (HasUserGestureRequest(queued_requests_))
       requests_.swap(queued_requests_);
     else if (HasUserGestureRequest(queued_frame_requests_))
       requests_.swap(queued_frame_requests_);
     else if (queued_requests_.size())
       requests_.swap(queued_requests_);
     else
       requests_.swap(queued_frame_requests_);
 
     // Sets the default value for each request to be 'accept'.
     // TODO(leng):  Currently all requests default to true.  If that changes:
     // a) Add additional accept_state queues to store default values.
     // b) Change the request API to provide the default value.
     accept_states_.resize(requests_.size(), true);
   }
 
-  view_->Show(requests_, accept_states_);
+  DCHECK(bubble_manager_);
+  bubble_manager_->ShowBubble(bubble_delegate_.get());
+  // view_->Show(requests_, accept_states_);
+
   NotifyBubbleAdded();
 
   // If in testing mode, automatically respond to the bubble that was shown.
   if (auto_response_for_test_ != NONE)
     DoAutoResponseForTesting();
 }
 
 void PermissionBubbleManager::FinalizeBubble() {
-  if (view_)
-    view_->Hide();
+  if (bubble_manager_) {
+    DCHECK(bubble_manager_);
+    bubble_manager_->HideBubble(bubble_delegate_.get());
+  }
 
   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() || queued_frame_requests_.size())
@@ skipping 69 matching lines @@
     case DENY_ALL:
       Deny();
       break;
     case DISMISS:
       Closing();
       break;
     case NONE:
       NOTREACHED();
   }
 }