mash: Migrate ShelfTooltipManager to wm common types.

ash/shelf/shelf_tooltip_manager.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/shelf/shelf_tooltip_manager.h"
 
+#include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_window_ids.h"
-#include "ash/shelf/shelf.h"
-#include "ash/shelf/shelf_layout_manager.h"
+#include "ash/common/wm_lookup.h"
+#include "ash/common/wm_root_window_controller.h"
+#include "ash/common/wm_shell.h"
+#include "ash/common/wm_window.h"
 #include "ash/shelf/shelf_view.h"
-#include "ash/shell.h"
-#include "ash/wm/window_animations.h"
 #include "base/bind.h"
 #include "base/strings/string16.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "ui/aura/window.h"

[msw, 2016/07/22 22:41:39]

Can/should I avoid this? Use WmWindow and add support via ui::Window?

 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/views/bubble/bubble_dialog_delegate.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/widget/widget.h"
-#include "ui/wm/core/window_animations.h"
 
 namespace ash {
 namespace {
 
 const int kTooltipTopBottomMargin = 3;
 const int kTooltipLeftRightMargin = 10;
 const int kTooltipAppearanceDelay = 1000;  // msec
 const int kTooltipMinHeight = 29 - 2 * kTooltipTopBottomMargin;
 const SkColor kTooltipTextColor = SkColorSetRGB(0x22, 0x22, 0x22);
 
@@ skipping 10 matching lines @@
 }  // namespace
 
 // The implementation of tooltip of the launcher.
 class ShelfTooltipManager::ShelfTooltipBubble
     : public views::BubbleDialogDelegateView {
  public:
   ShelfTooltipBubble(views::View* anchor,
                      views::BubbleBorder::Arrow arrow,
                      const base::string16& text)
       : views::BubbleDialogDelegateView(anchor, arrow) {
-    gfx::Insets insets =
-        gfx::Insets(kArrowOffsetTopBottom, kArrowOffsetLeftRight);
+    gfx::Insets insets(kArrowOffsetTopBottom, kArrowOffsetLeftRight);
     // Adjust the anchor location for asymmetrical borders of shelf item.
     if (anchor->border())
       insets += anchor->border()->GetInsets();
 
     set_anchor_view_insets(insets);
     set_close_on_deactivate(false);
     set_can_activate(false);
     set_accept_events(false);
     set_margins(gfx::Insets(kTooltipTopBottomMargin, kTooltipLeftRightMargin));
     set_shadow(views::BubbleBorder::SMALL_SHADOW);
     SetLayoutManager(new views::FillLayout());
-    // The anchor may not have the widget in tests.
-    if (anchor->GetWidget() && anchor->GetWidget()->GetNativeWindow()) {
-      set_parent_window(ash::Shell::GetContainer(
-          anchor->GetWidget()->GetNativeWindow()->GetRootWindow(),
-          ash::kShellWindowId_SettingBubbleContainer));
-    }
     views::Label* label = new views::Label(text);
     label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
     label->SetEnabledColor(kTooltipTextColor);
     AddChildView(label);
     views::BubbleDialogDelegateView::CreateBubble(this);
   }
 
  private:
   // BubbleDialogDelegateView overrides:
   gfx::Size GetPreferredSize() const override {
     const gfx::Size size = BubbleDialogDelegateView::GetPreferredSize();
     return gfx::Size(std::min(size.width(), kTooltipMaxWidth),
                      std::max(size.height(), kTooltipMinHeight));
   }
 
+  void OnBeforeBubbleWidgetInit(views::Widget::InitParams* params,
+                                views::Widget* bubble_widget) const override {
+    // Place the bubble in the same display as the anchor.
+    WmLookup::Get()
+        ->GetWindowForWidget(anchor_widget())
+        ->GetRootWindowController()
+        ->ConfigureWidgetInitParamsForContainer(
+            bubble_widget, kShellWindowId_SettingBubbleContainer, params);
+  }
+
   int GetDialogButtons() const override { return ui::DIALOG_BUTTON_NONE; }
 
   DISALLOW_COPY_AND_ASSIGN(ShelfTooltipBubble);
 };
 
 ShelfTooltipManager::ShelfTooltipManager(ShelfView* shelf_view)
     : timer_delay_(kTooltipAppearanceDelay),
       shelf_view_(shelf_view),
-      root_window_(nullptr),
-      shelf_layout_manager_(nullptr),
       bubble_(nullptr),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+  shelf_view_->wm_shelf()->AddObserver(this);
+  WmShell::Get()->AddPointerDownWatcher(this);
+}
 
 ShelfTooltipManager::~ShelfTooltipManager() {
-  WillDeleteShelfLayoutManager();
-
-  Shell::GetInstance()->RemovePointerDownWatcher(this);
-
-  if (root_window_) {
-    root_window_->RemoveObserver(this);
-    root_window_->RemovePreTargetHandler(this);
-    root_window_ = nullptr;
-  }
+  WmShell::Get()->RemovePointerDownWatcher(this);
+  shelf_view_->wm_shelf()->RemoveObserver(this);
+  if (shelf_view_->GetWidget() && shelf_view_->GetWidget()->GetNativeWindow())
+    shelf_view_->GetWidget()->GetNativeWindow()->PrependPreTargetHandler(this);
 }
 
 void ShelfTooltipManager::Init() {
-  shelf_layout_manager_ = shelf_view_->shelf()->shelf_layout_manager();
-  shelf_layout_manager_->AddObserver(this);
-
-  root_window_ = shelf_view_->GetWidget()->GetNativeWindow()->GetRootWindow();
-  root_window_->AddPreTargetHandler(this);
-  root_window_->AddObserver(this);
-
-  Shell::GetInstance()->AddPointerDownWatcher(this);
+  shelf_view_->GetWidget()->GetNativeWindow()->PrependPreTargetHandler(this);
 }
 
 void ShelfTooltipManager::Close() {
   timer_.Stop();
   if (bubble_)
     bubble_->GetWidget()->Close();
   bubble_ = nullptr;
 }
 
 bool ShelfTooltipManager::IsVisible() const {
   return bubble_ && bubble_->GetWidget()->IsVisible();
 }
 
 views::View* ShelfTooltipManager::GetCurrentAnchorView() const {
   return bubble_ ? bubble_->GetAnchorView() : nullptr;
 }
 
 void ShelfTooltipManager::ShowTooltip(views::View* view) {
   timer_.Stop();
   if (bubble_) {
     // Cancel the hiding animation to hide the old bubble immediately.
-    gfx::NativeView native_view = bubble_->GetWidget()->GetNativeView();
-    ::wm::SetWindowVisibilityAnimationTransition(native_view,
-                                                 ::wm::ANIMATE_NONE);
+    WmLookup::Get()
+        ->GetWindowForWidget(bubble_->GetWidget())
+        ->SetVisibilityAnimationTransition(::wm::ANIMATE_NONE);
     Close();
   }
 
   if (!ShouldShowTooltipForView(view))
     return;
 
-  Shelf* shelf = shelf_view_->shelf();
-  views::BubbleBorder::Arrow arrow = shelf->SelectValueForShelfAlignment(
-      views::BubbleBorder::BOTTOM_CENTER, views::BubbleBorder::LEFT_CENTER,
-      views::BubbleBorder::RIGHT_CENTER);
+  views::BubbleBorder::Arrow arrow = views::BubbleBorder::Arrow::NONE;
+  switch (shelf_view_->wm_shelf()->GetAlignment()) {
+    case SHELF_ALIGNMENT_BOTTOM:
+    case SHELF_ALIGNMENT_BOTTOM_LOCKED:
+      arrow = views::BubbleBorder::BOTTOM_CENTER;
+      break;
+    case SHELF_ALIGNMENT_LEFT:
+      arrow = views::BubbleBorder::LEFT_CENTER;
+      break;
+    case SHELF_ALIGNMENT_RIGHT:
+      arrow = views::BubbleBorder::RIGHT_CENTER;
+      break;
+  }
 
   base::string16 text = shelf_view_->GetTitleForView(view);
   bubble_ = new ShelfTooltipBubble(view, arrow, text);
-  gfx::NativeView native_view = bubble_->GetWidget()->GetNativeView();
-  ::wm::SetWindowVisibilityAnimationType(
-      native_view, ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_VERTICAL);
-  ::wm::SetWindowVisibilityAnimationTransition(native_view, ::wm::ANIMATE_HIDE);
+  WmWindow* window = WmLookup::Get()->GetWindowForWidget(bubble_->GetWidget());
+  window->SetVisibilityAnimationType(
+      ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_VERTICAL);
+  window->SetVisibilityAnimationTransition(::wm::ANIMATE_HIDE);
   bubble_->GetWidget()->Show();
 }
 
 void ShelfTooltipManager::ShowTooltipWithDelay(views::View* view) {
   if (ShouldShowTooltipForView(view)) {
     timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(timer_delay_),
                  base::Bind(&ShelfTooltipManager::ShowTooltip,
                             weak_factory_.GetWeakPtr(), view));
   }
 }
 
 void ShelfTooltipManager::OnMousePressed(const ui::MouseEvent& event,
                                          const gfx::Point& location_in_screen,
                                          views::Widget* target) {
   // Close on any mouse press events inside or outside the tooltip.
   Close();
 }
 
 void ShelfTooltipManager::OnTouchPressed(const ui::TouchEvent& event,
                                          const gfx::Point& location_in_screen,
                                          views::Widget* target) {
   // Close on any touch press events inside or outside the tooltip.
   Close();
 }
 
-void ShelfTooltipManager::OnEvent(ui::Event* event) {
-  // Mouse and touch press events are handled via views::PointerDownWatcher.
-  if (event->type() == ui::ET_MOUSE_PRESSED ||
-      event->type() == ui::ET_TOUCH_PRESSED) {
+void ShelfTooltipManager::OnMouseEvent(ui::MouseEvent* event) {
+  DCHECK_EQ(shelf_view_->GetWidget()->GetNativeWindow(), event->target());
+  if (event->type() == ui::ET_MOUSE_EXITED) {
+    Close();
     return;
   }
 
-  if (event->type() == ui::ET_MOUSE_EXITED || !event->IsMouseEvent() ||
-      event->target() != shelf_view_->GetWidget()->GetNativeWindow()) {
-    if (!event->IsKeyEvent())
-      Close();
+  if (event->type() != ui::ET_MOUSE_MOVED)
     return;
-  }
 
-  gfx::Point point = static_cast<ui::LocatedEvent*>(event)->location();
-  aura::Window::ConvertPointToTarget(
-      static_cast<aura::Window*>(event->target()),
-      shelf_view_->GetWidget()->GetNativeWindow(), &point);
+  gfx::Point point = event->AsLocatedEvent()->location();
   views::View::ConvertPointFromWidget(shelf_view_, &point);
   views::View* view = shelf_view_->GetTooltipHandlerForPoint(point);
   const bool should_show = ShouldShowTooltipForView(view);
 
   timer_.Stop();
   if (IsVisible() && should_show && bubble_->GetAnchorView() != view)
     ShowTooltip(view);
-  else if (!IsVisible() && should_show && event->type() == ui::ET_MOUSE_MOVED)
+  else if (!IsVisible() && should_show)
     ShowTooltipWithDelay(view);
   else if (IsVisible() && shelf_view_->ShouldHideTooltip(point))
     Close();
 }
 
-void ShelfTooltipManager::OnWindowDestroying(aura::Window* window) {
-  if (window == root_window_) {
-    root_window_->RemoveObserver(this);
-    root_window_->RemovePreTargetHandler(this);
-    root_window_ = nullptr;
-  }
-}
-
-void ShelfTooltipManager::WillDeleteShelfLayoutManager() {
-  if (shelf_layout_manager_)
-    shelf_layout_manager_->RemoveObserver(this);
-  shelf_layout_manager_ = nullptr;
-  shelf_view_ = nullptr;
-}
-
 void ShelfTooltipManager::WillChangeVisibilityState(
     ShelfVisibilityState new_state) {
   if (new_state == SHELF_HIDDEN)
     Close();
 }
 
 void ShelfTooltipManager::OnAutoHideStateChanged(ShelfAutoHideState new_state) {
   if (new_state == SHELF_AUTO_HIDE_HIDDEN) {
     timer_.Stop();
     // AutoHide state change happens during an event filter, so immediate close
     // may cause a crash in the HandleMouseEvent() after the filter.  So we just
     // schedule the Close here.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&ShelfTooltipManager::Close, weak_factory_.GetWeakPtr()));
   }
 }
 
 bool ShelfTooltipManager::ShouldShowTooltipForView(views::View* view) {
   return shelf_view_ && shelf_view_->ShouldShowTooltipForView(view) &&
-         shelf_layout_manager_ && shelf_layout_manager_->IsVisible();
+         shelf_view_->wm_shelf()->GetVisibilityState() == SHELF_VISIBLE;
 }
 
 }  // namespace ash