Convert location bar bubble delegates to bubble dialog delegates

ash/wm/immersive_fullscreen_controller.cc

 // Copyright 2013 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 "ash/wm/immersive_fullscreen_controller.h"
 
 #include <set>
 
 #include "ash/ash_constants.h"
 #include "ash/shell.h"
 #include "ash/wm/resize_handle_window_targeter.h"
 #include "ash/wm/window_state.h"
 #include "base/metrics/histogram.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/gfx/animation/slide_animation.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/bubble/bubble_delegate.h"
+#include "ui/views/bubble/bubble_dialog_delegate.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/transient_window_manager.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_client.h"
 
 using views::View;
 
 namespace ash {
 
@@ skipping 19 matching lines @@
 // of just more vertical then horizontal.
 const int kSwipeVerticalThresholdMultiplier = 3;
 
 // The height in pixels of the region above the top edge of the display which
 // hosts the immersive fullscreen window in which mouse events are ignored
 // (cannot reveal or unreveal the top-of-window views).
 // See ShouldIgnoreMouseEventAtLocation() for more details.
 const int kHeightOfDeadRegionAboveTopContainer = 10;
 
 // Returns the BubbleDelegateView corresponding to |maybe_bubble| if
-// |maybe_bubble| is a bubble.
+// |maybe_bubble| is a bubble. TODO(estade): remove this when all bubbles are
+// BubbleDialogDelegateViews, or create a common interface for the two bubble
+// types.
 views::BubbleDelegateView* AsBubbleDelegate(aura::Window* maybe_bubble) {
   if (!maybe_bubble)
-    return NULL;
+    return nullptr;
   views::Widget* widget = views::Widget::GetWidgetForNativeView(maybe_bubble);
   if (!widget)
-    return NULL;
+    return nullptr;
   return widget->widget_delegate()->AsBubbleDelegate();
 }
 
+// Returns the BubbleDialogDelegateView corresponding to |maybe_bubble| if
+// |maybe_bubble| is a bubble.
+views::BubbleDialogDelegateView* AsBubbleDialogDelegate(
+    aura::Window* maybe_bubble) {
+  if (!maybe_bubble)
+    return nullptr;
+  views::Widget* widget = views::Widget::GetWidgetForNativeView(maybe_bubble);
+  if (!widget)
+    return nullptr;
+  return widget->widget_delegate()->AsBubbleDialogDelegate();
+}
+
+views::View* GetAnchorView(aura::Window* maybe_bubble) {
+  views::BubbleDelegateView* bubble = AsBubbleDelegate(maybe_bubble);
+  if (bubble)
+    return bubble->GetAnchorView();
+
+  views::BubbleDialogDelegateView* bubble_dialog =
+      AsBubbleDialogDelegate(maybe_bubble);
+  return bubble_dialog ? bubble_dialog->GetAnchorView() : nullptr;
+}
+
 // Returns true if |maybe_transient| is a transient child of |toplevel|.
 bool IsWindowTransientChildOf(aura::Window* maybe_transient,
                               aura::Window* toplevel) {
   if (!maybe_transient || !toplevel)
     return false;
 
   for (aura::Window* window = maybe_transient; window;
        window = ::wm::GetTransientParent(window)) {
     if (window == toplevel)
       return true;
@@ skipping 35 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Class which keeps the top-of-window views revealed as long as one of the
 // bubbles it is observing is visible. The logic to keep the top-of-window
 // views revealed based on the visibility of bubbles anchored to
 // children of |ImmersiveFullscreenController::top_container_| is separate from
 // the logic related to |ImmersiveFullscreenController::focus_revealed_lock_|
 // so that bubbles which are not activatable and bubbles which do not close
 // upon deactivation also keep the top-of-window views revealed for the
 // duration of their visibility.
-class ImmersiveFullscreenController::BubbleManager
+class ImmersiveFullscreenController::BubbleObserver
     : public aura::WindowObserver {
  public:
-  explicit BubbleManager(ImmersiveFullscreenController* controller);
-  ~BubbleManager() override;
+  explicit BubbleObserver(ImmersiveFullscreenController* controller);
+  ~BubbleObserver() override;
 
   // Start / stop observing changes to |bubble|'s visibility.
   void StartObserving(aura::Window* bubble);
   void StopObserving(aura::Window* bubble);
 
  private:
   // Updates |revealed_lock_| based on whether any of |bubbles_| is visible.
   void UpdateRevealedLock();
 
   // aura::WindowObserver overrides:
   void OnWindowVisibilityChanged(aura::Window* window, bool visible) override;
   void OnWindowDestroying(aura::Window* window) override;
 
   ImmersiveFullscreenController* controller_;
 
   std::set<aura::Window*> bubbles_;
 
   // Lock which keeps the top-of-window views revealed based on whether any of
   // |bubbles_| is visible.
   scoped_ptr<ImmersiveRevealedLock> revealed_lock_;
 
-  DISALLOW_COPY_AND_ASSIGN(BubbleManager);
+  DISALLOW_COPY_AND_ASSIGN(BubbleObserver);
 };
 
-ImmersiveFullscreenController::BubbleManager::BubbleManager(
+ImmersiveFullscreenController::BubbleObserver::BubbleObserver(
     ImmersiveFullscreenController* controller)
-    : controller_(controller) {
-}
+    : controller_(controller) {}
 
-ImmersiveFullscreenController::BubbleManager::~BubbleManager() {
+ImmersiveFullscreenController::BubbleObserver::~BubbleObserver() {
   for (std::set<aura::Window*>::const_iterator it = bubbles_.begin();
        it != bubbles_.end(); ++it) {
     (*it)->RemoveObserver(this);
   }
 }
 
-void ImmersiveFullscreenController::BubbleManager::StartObserving(
+void ImmersiveFullscreenController::BubbleObserver::StartObserving(
     aura::Window* bubble) {
   if (bubbles_.insert(bubble).second) {
     bubble->AddObserver(this);
     UpdateRevealedLock();
   }
 }
 
-void ImmersiveFullscreenController::BubbleManager::StopObserving(
+void ImmersiveFullscreenController::BubbleObserver::StopObserving(
     aura::Window* bubble) {
   if (bubbles_.erase(bubble)) {
     bubble->RemoveObserver(this);
     UpdateRevealedLock();
   }
 }
 
-void ImmersiveFullscreenController::BubbleManager::UpdateRevealedLock() {
+void ImmersiveFullscreenController::BubbleObserver::UpdateRevealedLock() {
   bool has_visible_bubble = false;
   for (std::set<aura::Window*>::const_iterator it = bubbles_.begin();
        it != bubbles_.end(); ++it) {
     if ((*it)->IsVisible()) {
       has_visible_bubble = true;
       break;
     }
   }
 
   bool was_revealed = controller_->IsRevealed();
@@ skipping 10 matching lines @@
   }
 
   if (!was_revealed && revealed_lock_.get()) {
     // Currently, there is no nice way for bubbles to reposition themselves
     // whenever the anchor view moves. Tell the bubbles to reposition themselves
     // explicitly instead. The hidden bubbles are also repositioned because
     // BubbleDelegateView does not reposition its widget as a result of a
     // visibility change.
     for (std::set<aura::Window*>::const_iterator it = bubbles_.begin();
          it != bubbles_.end(); ++it) {
-      AsBubbleDelegate(*it)->OnAnchorBoundsChanged();
+      views::BubbleDelegateView* bubble = AsBubbleDelegate(*it);
+      if (bubble)
+        bubble->OnAnchorBoundsChanged();
+      else
+        AsBubbleDialogDelegate(*it)->OnAnchorBoundsChanged();
     }
   }
 }
 
-void ImmersiveFullscreenController::BubbleManager::OnWindowVisibilityChanged(
+void ImmersiveFullscreenController::BubbleObserver::OnWindowVisibilityChanged(
     aura::Window*,
     bool visible) {
   UpdateRevealedLock();
 }
 
-void ImmersiveFullscreenController::BubbleManager::OnWindowDestroying(
+void ImmersiveFullscreenController::BubbleObserver::OnWindowDestroying(
     aura::Window* window) {
   StopObserving(window);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 ImmersiveFullscreenController::ImmersiveFullscreenController()
     : delegate_(NULL),
       top_container_(NULL),
       widget_(NULL),
@@ skipping 241 matching lines @@
     const gfx::Animation* animation) {
   delegate_->SetVisibleFraction(animation->GetCurrentValue());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // aura::WindowObserver overrides:
 
 void ImmersiveFullscreenController::OnTransientChildAdded(
     aura::Window* window,
     aura::Window* transient) {
-  views::BubbleDelegateView* bubble_delegate = AsBubbleDelegate(transient);
-  if (bubble_delegate &&
-      bubble_delegate->GetAnchorView() &&
-      top_container_->Contains(bubble_delegate->GetAnchorView())) {
+  views::View* anchor = GetAnchorView(transient);
+  if (anchor && top_container_->Contains(anchor)) {
     // Observe the aura::Window because the BubbleDelegateView may not be
     // parented to the widget's root view yet so |bubble_delegate->GetWidget()|
     // may still return NULL.
-    bubble_manager_->StartObserving(transient);
+    bubble_observer_->StartObserving(transient);
   }
 }
 
 void ImmersiveFullscreenController::OnTransientChildRemoved(
     aura::Window* window,
     aura::Window* transient) {
-  bubble_manager_->StopObserving(transient);
+  bubble_observer_->StopObserving(transient);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ash::ImmersiveRevealedLock::Delegate overrides:
 
 void ImmersiveFullscreenController::LockRevealedState(
     AnimateReveal animate_reveal) {
   ++revealed_lock_count_;
   Animate animate = (animate_reveal == ANIMATE_REVEAL_YES) ?
       ANIMATE_FAST : ANIMATE_NO;
@@ skipping 19 matching lines @@
 
   views::FocusManager* focus_manager = widget_->GetFocusManager();
 
   if (enable) {
     widget_->AddObserver(this);
     focus_manager->AddFocusChangeListener(this);
     Shell::GetInstance()->AddPreTargetHandler(this);
     ::wm::TransientWindowManager::Get(native_window_)->
         AddObserver(this);
 
-    RecreateBubbleManager();
+    RecreateBubbleObserver();
   } else {
     widget_->RemoveObserver(this);
     focus_manager->RemoveFocusChangeListener(this);
     Shell::GetInstance()->RemovePreTargetHandler(this);
     ::wm::TransientWindowManager::Get(native_window_)->
         RemoveObserver(this);
 
     // We have stopped observing whether transient children are added or removed
-    // to |native_window_|. The set of bubbles that BubbleManager is observing
-    // will become stale really quickly. Destroy BubbleManager and recreate it
+    // to |native_window_|. The set of bubbles that BubbleObserver is observing
+    // will become stale really quickly. Destroy BubbleObserver and recreate it
     // when we start observing |native_window_| again.
-    bubble_manager_.reset();
+    bubble_observer_.reset();
 
     animation_->Stop();
   }
 }
 
 void ImmersiveFullscreenController::UpdateTopEdgeHoverTimer(
     ui::MouseEvent* event) {
   DCHECK(enabled_);
   DCHECK(reveal_state_ == SLIDING_CLOSED || reveal_state_ == CLOSED);
 
@@ skipping 129 matching lines @@
     return;
 
   bool hold_lock = false;
   if (widget_->IsActive()) {
     views::View* focused_view = widget_->GetFocusManager()->GetFocusedView();
     if (top_container_->Contains(focused_view))
       hold_lock = true;
   } else {
     aura::Window* active_window = aura::client::GetActivationClient(
         native_window_->GetRootWindow())->GetActiveWindow();
-    views::BubbleDelegateView* bubble_delegate =
-        AsBubbleDelegate(active_window);
-    if (bubble_delegate && bubble_delegate->anchor_widget()) {
-      // BubbleManager will already have locked the top-of-window views if the
+    if (GetAnchorView(active_window)) {
+      // BubbleObserver will already have locked the top-of-window views if the
       // bubble is anchored to a child of |top_container_|. Don't acquire
       // |focus_revealed_lock_| here for the sake of simplicity.
       // Note: Instead of checking for the existence of the |anchor_view|,
       // the existence of the |anchor_widget| is performed to avoid the case
       // where the view is already gone (and the widget is still running).
     } else {
       // The currently active window is not |native_window_| and it is not a
       // bubble with an anchor view. The top-of-window views should be revealed
       // if:
       // 1) The active window is a transient child of |native_window_|.
@@ skipping 204 matching lines @@
   // closest screen ensures that the event is from a valid bezel (as opposed to
   // another screen in an extended desktop).
   gfx::Rect screen_bounds =
       gfx::Screen::GetScreen()->GetDisplayNearestPoint(location).bounds();
   return (!screen_bounds.Contains(location) &&
           location.y() < hit_bounds_in_screen.y() &&
           location.x() >= hit_bounds_in_screen.x() &&
           location.x() < hit_bounds_in_screen.right());
 }
 
-void ImmersiveFullscreenController::RecreateBubbleManager() {
-  bubble_manager_.reset(new BubbleManager(this));
+void ImmersiveFullscreenController::RecreateBubbleObserver() {
+  bubble_observer_.reset(new BubbleObserver(this));
   const std::vector<aura::Window*> transient_children =
       ::wm::GetTransientChildren(native_window_);
   for (size_t i = 0; i < transient_children.size(); ++i) {
     aura::Window* transient_child = transient_children[i];
-    views::BubbleDelegateView* bubble_delegate =
-        AsBubbleDelegate(transient_child);
-    if (bubble_delegate &&
-        bubble_delegate->GetAnchorView() &&
-        top_container_->Contains(bubble_delegate->GetAnchorView())) {
-      bubble_manager_->StartObserving(transient_child);
-    }
+    views::View* anchor_view = GetAnchorView(transient_child);
+    if (anchor_view && top_container_->Contains(anchor_view))
+      bubble_observer_->StartObserving(transient_child);
   }
 }
 
 }  // namespace ash