Vanquish views::BubbleDelegate{View,}

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 "ash/wm/window_state_aura.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 @@
 // vertical. This is used to make sure that gesture is close to vertical instead
 // 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. 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 nullptr;
-  views::Widget* widget = views::Widget::GetWidgetForNativeView(maybe_bubble);
-  if (!widget)
-    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;
@@ skipping 74 matching lines @@
   std::unique_ptr<ImmersiveRevealedLock> revealed_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(BubbleObserver);
 };
 
 ImmersiveFullscreenController::BubbleObserver::BubbleObserver(
     ImmersiveFullscreenController* controller)
     : controller_(controller) {}
 
 ImmersiveFullscreenController::BubbleObserver::~BubbleObserver() {
-  for (std::set<aura::Window*>::const_iterator it = bubbles_.begin();
-       it != bubbles_.end(); ++it) {
-    (*it)->RemoveObserver(this);
-  }
+  for (aura::Window* bubble : bubbles_)
+    bubble->RemoveObserver(this);
 }
 
 void ImmersiveFullscreenController::BubbleObserver::StartObserving(
     aura::Window* bubble) {
   if (bubbles_.insert(bubble).second) {
     bubble->AddObserver(this);
     UpdateRevealedLock();
   }
 }
 
 void ImmersiveFullscreenController::BubbleObserver::StopObserving(
     aura::Window* bubble) {
   if (bubbles_.erase(bubble)) {
     bubble->RemoveObserver(this);
     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()) {
+  for (aura::Window* bubble : bubbles_) {
+    if (bubble->IsVisible()) {
       has_visible_bubble = true;
       break;
     }
   }
 
   bool was_revealed = controller_->IsRevealed();
   if (has_visible_bubble) {
     if (!revealed_lock_.get()) {
       // Reveal the top-of-window views without animating because it looks
       // weird for the top-of-window views to animate and the bubble not to
       // animate along with the top-of-window views.
       revealed_lock_.reset(controller_->GetRevealedLock(
           ImmersiveFullscreenController::ANIMATE_REVEAL_NO));
     }
   } else {
     revealed_lock_.reset();
   }
 
   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
+    // BubbleDialogDelegateView 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) {
-      views::BubbleDelegateView* bubble = AsBubbleDelegate(*it);
-      if (bubble)
-        bubble->OnAnchorBoundsChanged();
-      else
-        AsBubbleDialogDelegate(*it)->OnAnchorBoundsChanged();
-    }
+    for (aura::Window* bubble : bubbles_)
+      AsBubbleDialogDelegate(bubble)->OnAnchorBoundsChanged();
   }
 }
 
 void ImmersiveFullscreenController::BubbleObserver::OnWindowVisibilityChanged(
     aura::Window*,
     bool visible) {
   UpdateRevealedLock();
 }
 
 void ImmersiveFullscreenController::BubbleObserver::OnWindowDestroying(
@@ skipping 704 matching lines @@
       ::wm::GetTransientChildren(native_window_);
   for (size_t i = 0; i < transient_children.size(); ++i) {
     aura::Window* transient_child = transient_children[i];
     views::View* anchor_view = GetAnchorView(transient_child);
     if (anchor_view && top_container_->Contains(anchor_view))
       bubble_observer_->StartObserving(transient_child);
   }
 }
 
 }  // namespace ash