mash: Move ShelfWindowTargeter out of shelf_widget.cc

ash/shelf/shelf_widget.cc

 // Copyright 2012 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_widget.h"
 
 #include "ash/aura/wm_shelf_aura.h"
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/focus_cycler.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_background_animator_observer.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/system/status_area_widget.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/shelf/dimmer_view.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
+#include "ash/shelf/shelf_window_targeter.h"
 #include "ash/shell.h"
 #include "ash/wm/status_area_layout_manager.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/memory/ptr_util.h"
 #include "grit/ash_resources.h"
 #include "ui/aura/window.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/views/accessible_pane_view.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
-#include "ui/wm/core/easy_resize_window_targeter.h"
 
 namespace ash {
 
 namespace {
 
 // Size of black border at bottom (or side) of shelf.
 const int kNumBlackPixels = 3;
 
-// ShelfWindowTargeter makes it easier to resize windows with the mouse when the
-// window-edge slightly overlaps with the shelf edge. The targeter also makes it
-// easier to drag the shelf out with touch while it is hidden.
-class ShelfWindowTargeter : public ::wm::EasyResizeWindowTargeter,
-                            public ShelfLayoutManagerObserver {
- public:
-  ShelfWindowTargeter(aura::Window* container, ShelfLayoutManager* shelf)
-      : ::wm::EasyResizeWindowTargeter(container, gfx::Insets(), gfx::Insets()),
-        shelf_(shelf) {
-    WillChangeVisibilityState(shelf_->visibility_state());
-    shelf_->AddObserver(this);
-  }
-
-  ~ShelfWindowTargeter() override {
-    // |shelf_| may have been destroyed by this time.
-    if (shelf_)
-      shelf_->RemoveObserver(this);
-  }
-
- private:
-  gfx::Insets GetInsetsForAlignment(int distance, ShelfAlignment alignment) {
-    if (alignment == SHELF_ALIGNMENT_LEFT)
-      return gfx::Insets(0, 0, 0, distance);
-    if (alignment == SHELF_ALIGNMENT_RIGHT)
-      return gfx::Insets(0, distance, 0, 0);
-    return gfx::Insets(distance, 0, 0, 0);
-  }
-
-  // ShelfLayoutManagerObserver:
-  void WillDeleteShelfLayoutManager() override {
-    shelf_->RemoveObserver(this);
-    shelf_ = nullptr;
-  }
-
-  void WillChangeVisibilityState(ShelfVisibilityState new_state) override {
-    gfx::Insets mouse_insets;
-    gfx::Insets touch_insets;
-    if (new_state == SHELF_VISIBLE) {
-      // Let clicks at the very top of the shelf through so windows can be
-      // resized with the bottom-right corner and bottom edge.
-      mouse_insets = GetInsetsForAlignment(kWorkspaceAreaVisibleInset,
-                                           shelf_->GetAlignment());
-    } else if (new_state == SHELF_AUTO_HIDE) {
-      // Extend the touch hit target out a bit to allow users to drag shelf out
-      // while hidden.
-      touch_insets = GetInsetsForAlignment(-kWorkspaceAreaAutoHideInset,
-                                           shelf_->GetAlignment());
-    }
-
-    set_mouse_extend(mouse_insets);
-    set_touch_extend(touch_insets);
-  }
-
-  ShelfLayoutManager* shelf_;
-
-  DISALLOW_COPY_AND_ASSIGN(ShelfWindowTargeter);
-};
-
 }  // namespace
 
 // The contents view of the Shelf. This view contains ShelfView and
 // sizes it to the width of the shelf minus the size of the status area.
 class ShelfWidget::DelegateView : public views::WidgetDelegate,
                                   public views::AccessiblePaneView,
                                   public ShelfBackgroundAnimatorObserver {
  public:
   explicit DelegateView(ShelfWidget* shelf);
   ~DelegateView() override;
@@ skipping 212 matching lines @@
 void ShelfWidget::DelegateView::UpdateShelfOpaqueBackground(int alpha) {
   const float kMaxAlpha = 255.0f;
   opaque_background_.SetOpacity(alpha / kMaxAlpha);
 }
 
 void ShelfWidget::DelegateView::UpdateShelfAssetBackground(int alpha) {
   asset_background_alpha_ = alpha;
   SchedulePaint();
 }
 
-ShelfWidget::ShelfWidget(WmWindow* wm_shelf_container,
-                         WmWindow* wm_status_container,
+ShelfWidget::ShelfWidget(WmWindow* shelf_container,
+                         WmWindow* status_container,
                          WmShelfAura* wm_shelf_aura,
                          WorkspaceController* workspace_controller)
     : wm_shelf_aura_(wm_shelf_aura),
       delegate_view_(new DelegateView(this)),
       background_animator_(SHELF_BACKGROUND_DEFAULT, wm_shelf_aura_),
       activating_as_fallback_(false) {
   background_animator_.AddObserver(this);
   background_animator_.AddObserver(delegate_view_);
 
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.delegate = delegate_view_;
-  wm_shelf_container->GetRootWindowController()
+  shelf_container->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
-          this, wm_shelf_container->GetShellWindowId(), &params);
+          this, shelf_container->GetShellWindowId(), &params);
   Init(params);
 
   // The shelf should not take focus when initially shown.
   set_focus_on_creation(false);
   SetContentsView(delegate_view_);
   delegate_view_->SetParentLayer(GetLayer());
 
   shelf_layout_manager_ = new ShelfLayoutManager(this);
   shelf_layout_manager_->AddObserver(this);
-  wm_shelf_container->SetLayoutManager(base::WrapUnique(shelf_layout_manager_));
+  shelf_container->SetLayoutManager(base::WrapUnique(shelf_layout_manager_));
   shelf_layout_manager_->set_workspace_controller(workspace_controller);
   workspace_controller->SetShelf(shelf_layout_manager_);
   background_animator_.PaintBackground(
       shelf_layout_manager_->GetShelfBackgroundType(),
       BACKGROUND_CHANGE_IMMEDIATE);
   wm_shelf_aura_->SetShelfLayoutManager(shelf_layout_manager_);
 
   // TODO(jamescook): Move ownership to RootWindowController.
-  status_area_widget_ =
-      new StatusAreaWidget(wm_status_container, wm_shelf_aura_);
+  status_area_widget_ = new StatusAreaWidget(status_container, wm_shelf_aura_);
   status_area_widget_->CreateTrayViews();
   if (WmShell::Get()->GetSessionStateDelegate()->IsActiveUserSessionStarted())
     status_area_widget_->Show();
   WmShell::Get()->focus_cycler()->AddWidget(status_area_widget_);
   background_animator_.AddObserver(status_area_widget_);
-  wm_status_container->SetLayoutManager(
+  status_container->SetLayoutManager(
       base::MakeUnique<StatusAreaLayoutManager>(this));
 
-  aura::Window* shelf_container =
-      WmWindowAura::GetAuraWindow(wm_shelf_container);
-  aura::Window* status_container =
-      WmWindowAura::GetAuraWindow(wm_status_container);
-  shelf_container->SetEventTargeter(std::unique_ptr<ui::EventTargeter>(
-      new ShelfWindowTargeter(shelf_container, shelf_layout_manager_)));
-  status_container->SetEventTargeter(std::unique_ptr<ui::EventTargeter>(
-      new ShelfWindowTargeter(status_container, shelf_layout_manager_)));
+  WmWindowAura::GetAuraWindow(shelf_container)->SetEventTargeter(
+      base::MakeUnique<ShelfWindowTargeter>(shelf_container, wm_shelf_aura_));
+  WmWindowAura::GetAuraWindow(status_container)->SetEventTargeter(
+      base::MakeUnique<ShelfWindowTargeter>(status_container, wm_shelf_aura_));
 
   views::Widget::AddObserver(this);
 }
 
 ShelfWidget::~ShelfWidget() {
   // Must call Shutdown() before destruction.
   DCHECK(!status_area_widget_);
   WmShell::Get()->focus_cycler()->RemoveWidget(this);
   SetFocusCycler(nullptr);
   RemoveObserver(this);
@@ skipping 190 matching lines @@
     shelf_layout_manager_->UpdateAutoHideForMouseEvent(event);
 }
 
 void ShelfWidget::OnGestureEvent(ui::GestureEvent* event) {
   Widget::OnGestureEvent(event);
   if (Shell::GetInstance()->in_mus() && shelf_layout_manager_)
     shelf_layout_manager_->UpdateAutoHideForGestureEvent(event);
 }
 
 }  // namespace ash