ash / wm / workspace / multi_window_resize_controller.cc [blame]

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/wm/workspace/multi_window_resize_controller.h"

#include "ash/public/cpp/shell_window_ids.h"
#include "ash/resources/vector_icons/vector_icons.h"
#include "ash/root_window_controller.h"
#include "ash/shell.h"
#include "ash/wm/overview/overview_controller.h"
#include "ash/wm/resize_shadow_controller.h"
#include "ash/wm/splitview/split_view_utils.h"
#include "ash/wm/window_util.h"
#include "ash/wm/wm_metrics.h"
#include "ash/wm/workspace/workspace_window_resizer.h"
#include "base/containers/adapters.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/user_metrics.h"
#include "ui/aura/client/aura_constants.h"
#include "ui/aura/window_delegate.h"
#include "ui/base/hit_test.h"
#include "ui/chromeos/styles/cros_tokens_color_mappings.h"
#include "ui/display/screen.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/geometry/point_f.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/geometry/vector2d.h"
#include "ui/gfx/paint_vector_icon.h"
#include "ui/views/background.h"
#include "ui/wm/core/compound_event_filter.h"
#include "ui/wm/core/coordinate_conversion.h"
#include "ui/wm/core/window_animations.h"

namespace ash {

namespace {

// Delay before hiding the `resize_widget_`.
constexpr base::TimeDelta kHideDelay = base::Milliseconds(500);

// Padding from the bottom/right edge the resize widget is shown at.
const int kResizeWidgetPadding = 15;

// The size of the resize widget.
constexpr int kLongSide = 64;
constexpr int kShortSide = 52;

// Returns the widget init params needed to create the resize widget.
views::Widget::InitParams CreateWidgetParams(aura::Window* parent_window,
                                             const std::string& widget_name) {
  views::Widget::InitParams params(
      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
      views::Widget::InitParams::TYPE_POPUP);
  params.parent = parent_window;
  params.name = widget_name;
  params.opacity = views::Widget::InitParams::WindowOpacity::kTranslucent;
  return params;
}

gfx::PointF ConvertPointFromScreen(aura::Window* window,
                                   const gfx::PointF& point) {
  gfx::PointF result(point);
  ::wm::ConvertPointFromScreen(window, &result);
  return result;
}

gfx::Point ConvertPointToTarget(aura::Window* source,
                                aura::Window* target,
                                const gfx::Point& point) {
  gfx::Point result(point);
  aura::Window::ConvertPointToTarget(source, target, &result);
  return result;
}

gfx::Rect ConvertRectToScreen(aura::Window* source, const gfx::Rect& rect) {
  gfx::Rect result(rect);
  ::wm::ConvertRectToScreen(source, &result);
  return result;
}

bool ContainsX(aura::Window* window, int x) {
  return x >= 0 && x <= window->bounds().width();
}

bool ContainsScreenX(aura::Window* window, int x_in_screen) {
  gfx::PointF window_loc =
      ConvertPointFromScreen(window, gfx::PointF(x_in_screen, 0));
  return ContainsX(window, window_loc.x());
}

bool ContainsY(aura::Window* window, int y) {
  return y >= 0 && y <= window->bounds().height();
}

bool ContainsScreenY(aura::Window* window, int y_in_screen) {
  gfx::PointF window_loc =
      ConvertPointFromScreen(window, gfx::PointF(0, y_in_screen));
  return ContainsY(window, window_loc.y());
}

// Returns true if `p` is on the edge `edge_want` of `window`.
bool PointOnWindowEdge(aura::Window* window,
                       int edge_want,
                       const gfx::Point& p) {
  switch (edge_want) {
    case HTLEFT:
      return ContainsY(window, p.y()) && p.x() == 0;
    case HTRIGHT:
      return ContainsY(window, p.y()) && p.x() == window->bounds().width();
    case HTTOP:
      return ContainsX(window, p.x()) && p.y() == 0;
    case HTBOTTOM:
      return ContainsX(window, p.x()) && p.y() == window->bounds().height();
    default:
      NOTREACHED();
  }
}

bool Intersects(int x1, int max_1, int x2, int max_2) {
  return x2 <= max_1 && max_2 > x1;
}

}  // namespace

// -----------------------------------------------------------------------------
// ResizeView:
// View contained in the widget. Passes along mouse events to the
// MultiWindowResizeController so that it can start/stop the resize loop.

class MultiWindowResizeController::ResizeView : public views::View {
 public:
  ResizeView(MultiWindowResizeController* controller, Direction direction)
      : controller_(controller), direction_(direction) {}

  ResizeView(const ResizeView&) = delete;
  ResizeView& operator=(const ResizeView&) = delete;
  ~ResizeView() override = default;

  // views::View:
  gfx::Size CalculatePreferredSize(
      const views::SizeBounds& available_size) const override {
    const bool vert = direction_ == Direction::kLeftRight;
    return gfx::Size(vert ? kLongSide : kShortSide,
                     vert ? kShortSide : kLongSide);
  }

  void OnPaint(gfx::Canvas* canvas) override {
    cc::PaintFlags flags;
    flags.setColor(
        GetColorProvider()->GetColor(cros_tokens::kCrosSysSystemBaseElevated));
    flags.setStyle(cc::PaintFlags::kFill_Style);
    flags.setAntiAlias(true);

    canvas->DrawPath(GeneratePath(GetLocalBounds()), flags);

    // Paint the chevron icons.
    constexpr int kIconSize = 20;
    constexpr int kHalfLong = kLongSide / 2;

    // Paint the left / up chevron icon.
    canvas->Save();
    int long_offset = (kHalfLong - kIconSize) / 2;
    int short_offset = (kShortSide - kIconSize) / 2;
    canvas->Translate(direction_ == Direction::kLeftRight
                          ? gfx::Vector2d(long_offset, short_offset)
                          : gfx::Vector2d(short_offset, long_offset));
    gfx::PaintVectorIcon(
        canvas,
        direction_ == Direction::kLeftRight ? kOverflowShelfLeftIcon
                                            : kChevronUpSmallIcon,
        kIconSize,
        GetColorProvider()->GetColor(cros_tokens::kCrosSysOnSurface));
    canvas->Restore();

    // Paint the right / down chevron icon.
    canvas->Save();
    long_offset = kHalfLong + (kHalfLong - kIconSize) / 2;
    canvas->Translate(direction_ == Direction::kLeftRight
                          ? gfx::Vector2d(long_offset, short_offset)
                          : gfx::Vector2d(short_offset, long_offset));
    gfx::PaintVectorIcon(
        canvas,
        direction_ == Direction::kLeftRight ? kOverflowShelfRightIcon
                                            : kChevronDownSmallIcon,
        kIconSize,
        GetColorProvider()->GetColor(cros_tokens::kCrosSysOnSurface));
    canvas->Restore();
  }

  bool OnMousePressed(const ui::MouseEvent& event) override {
    gfx::Point location(event.location());
    views::View::ConvertPointToScreen(this, &location);
    controller_->StartResize(gfx::PointF(location));
    return true;
  }

  bool OnMouseDragged(const ui::MouseEvent& event) override {
    gfx::Point location(event.location());
    views::View::ConvertPointToScreen(this, &location);
    controller_->Resize(gfx::PointF(location), event.flags());
    return true;
  }

  void OnMouseReleased(const ui::MouseEvent& event) override {
    controller_->CompleteResize();
  }

  void OnMouseCaptureLost() override { controller_->CancelResize(); }

  gfx::NativeCursor GetCursor(const ui::MouseEvent& event) override {
    int component = (direction_ == Direction::kLeftRight) ? HTRIGHT : HTBOTTOM;
    return ::wm::CompoundEventFilter::CursorForWindowComponent(component);
  }

 private:
  raw_ptr<MultiWindowResizeController> controller_;
  const Direction direction_;

  SkPath GeneratePath(const gfx::Rect& bounds) {
    //           /\
    //      ----    ----
    //    /              \
    //    \              /
    //      ----    ----
    //           \/
    //
    // Generate the path for the shape above when `direction_` is
    // `Direction::kLeftRight`. If the `direction_` is `Direction::kTopBottom`,
    // generate the path for the shape above with 90 degree rotated.

    static constexpr int kLargeCurveRadius = 16;
    static constexpr int kSmallCurveRadius = 10;

    // The resize shape is symmetric horizontally and vertically, hence only
    // need to manually generate the path for the quarter and then flip twice;
    const gfx::RectF quarter_bounds(bounds.x(), bounds.y(), bounds.width() / 2,
                                    bounds.height() / 2);
    SkPath path;
    if (direction_ == Direction::kLeftRight) {
      //           /|
      //      ----  |
      //    / ____  |

      // Generate the path for the quarter of the resize shape which looks like
      // the shape above, starting from left bottom to the right top and then
      // back to the left bottom.
      path.moveTo(quarter_bounds.x(), quarter_bounds.bottom());
      path.arcTo(
          quarter_bounds.x(), quarter_bounds.bottom() - kLargeCurveRadius,
          quarter_bounds.x() + kLargeCurveRadius,
          quarter_bounds.bottom() - kLargeCurveRadius, kLargeCurveRadius);
      path.lineTo(quarter_bounds.right() - kSmallCurveRadius,
                  quarter_bounds.bottom() - kLargeCurveRadius);
      path.arcTo(quarter_bounds.right(),
                 quarter_bounds.bottom() - kLargeCurveRadius,
                 quarter_bounds.right(), quarter_bounds.y(), kSmallCurveRadius);
      path.lineTo(quarter_bounds.right(), quarter_bounds.bottom());
    } else {
      // Similar to the way when `direction_` is `Direction::kLeftRight`,
      // starting from the right top to the left bottom and then back to the
      // right top.
      path.moveTo(quarter_bounds.right(), quarter_bounds.y());
      path.arcTo(quarter_bounds.right() - kLargeCurveRadius, quarter_bounds.y(),
                 quarter_bounds.right() - kLargeCurveRadius,
                 quarter_bounds.y() + kLargeCurveRadius, kLargeCurveRadius);
      path.lineTo(quarter_bounds.right() - kLargeCurveRadius,
                  quarter_bounds.bottom() - kSmallCurveRadius);
      path.arcTo(quarter_bounds.right() - kLargeCurveRadius,
                 quarter_bounds.bottom(), quarter_bounds.x(),
                 quarter_bounds.bottom(), kSmallCurveRadius);
      path.lineTo(quarter_bounds.right(), quarter_bounds.bottom());
    }
    path.close();

    // Flip vertically and horizontally and vertically to get the full path.
    SkMatrix flip;
    flip.setScale(1, -1, quarter_bounds.width(), quarter_bounds.height());
    path.addPath(path, flip);
    flip.setScale(-1, 1, quarter_bounds.width(), quarter_bounds.height());
    path.addPath(path, flip);

    return path;
  }
};

// -----------------------------------------------------------------------------
// ResizeMouseWatcherHost:
// MouseWatcherHost implementation for MultiWindowResizeController. Forwards
// Contains() to MultiWindowResizeController.

class MultiWindowResizeController::ResizeMouseWatcherHost
    : public views::MouseWatcherHost {
 public:
  explicit ResizeMouseWatcherHost(MultiWindowResizeController* host)
      : host_(host) {}

  ResizeMouseWatcherHost(const ResizeMouseWatcherHost&) = delete;
  ResizeMouseWatcherHost& operator=(const ResizeMouseWatcherHost&) = delete;
  ~ResizeMouseWatcherHost() override = default;

  // views::MouseWatcherHost:
  bool Contains(const gfx::Point& point_in_screen, EventType type) override {
    return (type == EventType::kPress)
               ? host_->IsOverResizeWidget(point_in_screen)
               : host_->IsOverWindows(point_in_screen);
  }

 private:
  raw_ptr<MultiWindowResizeController> host_;
};

MultiWindowResizeController::ResizeWindows::ResizeWindows()
    : direction(Direction::kTopBottom) {}

MultiWindowResizeController::ResizeWindows::ResizeWindows(
    const ResizeWindows& other) = default;

MultiWindowResizeController::ResizeWindows::~ResizeWindows() = default;

bool MultiWindowResizeController::ResizeWindows::Equals(
    const ResizeWindows& other) const {
  return window1 == other.window1 && window2 == other.window2 &&
         direction == other.direction;
}

// -----------------------------------------------------------------------------
// MultiWindowResizeController:

MultiWindowResizeController::MultiWindowResizeController() {
  Shell::Get()->overview_controller()->AddObserver(this);
}

MultiWindowResizeController::~MultiWindowResizeController() {
  if (Shell::Get()->overview_controller()) {
    Shell::Get()->overview_controller()->RemoveObserver(this);
  }

  ResetResizer();
}

void MultiWindowResizeController::Show(aura::Window* window,
                                       int component,
                                       const gfx::Point& point_in_window) {
  // When the resize widget is showing we ignore Show() requests. Instead we
  // only care about mouse movements from MouseWatcher. This is necessary as
  // WorkspaceEventHandler only sees mouse movements over the windows, not all
  // windows or over the desktop.
  if (resize_widget_)
    return;

  ResizeWindows windows(DetermineWindows(window, component, point_in_window));
  if (IsShowing() && windows_.Equals(windows))
    return;

  Hide();
  if (!windows.is_valid()) {
    windows_ = ResizeWindows();
    return;
  }

  windows_ = windows;
  StartObserving(windows_.window1);
  StartObserving(windows_.window2);
  show_location_in_parent_ =
      ConvertPointToTarget(window, window->parent(), point_in_window);
  show_timer_.Start(FROM_HERE, kShowDelay, this,
                    &MultiWindowResizeController::ShowIfValidMouseLocation);
}

void MultiWindowResizeController::MouseMovedOutOfHost() {
  Hide();
}

void MultiWindowResizeController::OnWindowPropertyChanged(aura::Window* window,
                                                          const void* key,
                                                          intptr_t old) {
  // If the window is now non-resizeable, make sure the resizer is not showing.
  if ((window->GetProperty(aura::client::kResizeBehaviorKey) &
       aura::client::kResizeBehaviorCanResize) == 0)
    ResetResizer();
}

void MultiWindowResizeController::OnWindowVisibilityChanged(
    aura::Window* window,
    bool visible) {
  // OnWindowVisibilityChanged() is fired not only for observed windows but
  // also its descendants (and ancestors), but multi-window resizing should keep
  // running even if the resized window’s child window gets hidden. So here, we
  // only handles events for windows being resized (i.e. observed windows).
  if (!IsObserving(window))
    return;

  if (!visible)
    ResetResizer();
}

void MultiWindowResizeController::OnWindowDestroying(aura::Window* window) {
  ResetResizer();
}

void MultiWindowResizeController::OnPostWindowStateTypeChange(
    WindowState* window_state,
    chromeos::WindowStateType old_type) {
  if (window_state->IsMaximized() || window_state->IsFullscreen() ||
      window_state->IsMinimized()) {
    ResetResizer();
  }
}

void MultiWindowResizeController::OnOverviewModeStarting() {
  // Hide resizing UI when entering overview.
  Shell::Get()->resize_shadow_controller()->HideAllShadows();
  ResetResizer();
}

void MultiWindowResizeController::OnOverviewModeEndingAnimationComplete(
    bool canceled) {
  if (canceled) {
    return;
  }

  // Show shadow for the resizer after exiting overview.
  Shell::Get()->resize_shadow_controller()->TryShowAllShadows();
}

MultiWindowResizeController::ResizeWindows
MultiWindowResizeController::DetermineWindowsFromScreenPoint(
    aura::Window* window) const {
  gfx::Point mouse_location(
      display::Screen::GetScreen()->GetCursorScreenPoint());
  wm::ConvertPointFromScreen(window, &mouse_location);
  const int component =
      window_util::GetNonClientComponent(window, mouse_location);
  return DetermineWindows(window, component, mouse_location);
}

void MultiWindowResizeController::CreateMouseWatcher() {
  mouse_watcher_ = std::make_unique<views::MouseWatcher>(
      std::make_unique<ResizeMouseWatcherHost>(this), this);
  mouse_watcher_->set_notify_on_exit_time(kHideDelay);
  DCHECK(resize_widget_);
  mouse_watcher_->Start(resize_widget_->GetNativeWindow());
}

MultiWindowResizeController::ResizeWindows
MultiWindowResizeController::DetermineWindows(aura::Window* window,
                                              int window_component,
                                              const gfx::Point& point) const {
  ResizeWindows result;

  // Check if the window is non-resizeable.
  if ((window->GetProperty(aura::client::kResizeBehaviorKey) &
       aura::client::kResizeBehaviorCanResize) == 0) {
    return result;
  }

  gfx::Point point_in_parent =
      ConvertPointToTarget(window, window->parent(), point);
  switch (window_component) {
    case HTRIGHT:
      result.direction = Direction::kLeftRight;
      result.window1 = window;
      result.window2 = FindWindowByEdge(
          window, HTLEFT, window->bounds().right(), point_in_parent.y());
      break;
    case HTLEFT:
      result.direction = Direction::kLeftRight;
      result.window1 = FindWindowByEdge(window, HTRIGHT, window->bounds().x(),
                                        point_in_parent.y());
      result.window2 = window;
      break;
    case HTTOP:
      result.direction = Direction::kTopBottom;
      result.window1 = FindWindowByEdge(window, HTBOTTOM, point_in_parent.x(),
                                        window->bounds().y());
      result.window2 = window;
      break;
    case HTBOTTOM:
      result.direction = Direction::kTopBottom;
      result.window1 = window;
      result.window2 = FindWindowByEdge(window, HTTOP, point_in_parent.x(),
                                        window->bounds().bottom());
      break;
    default:
      break;
  }
  return result;
}

aura::Window* MultiWindowResizeController::FindWindowByEdge(
    aura::Window* window_to_ignore,
    int edge_want,
    int x_in_parent,
    int y_in_parent) const {
  aura::Window* parent = window_to_ignore->parent();
  const aura::Window::Windows& windows = parent->children();
  for (aura::Window* window : base::Reversed(windows)) {
    if (window == window_to_ignore || !window->IsVisible())
      continue;

    // Ignore windows without a non-client area.
    if (!window->delegate())
      continue;

    // Return the window if it is resizeable and the wanted edge has the point.
    if ((window->GetProperty(aura::client::kResizeBehaviorKey) &
         aura::client::kResizeBehaviorCanResize) != 0 &&
        PointOnWindowEdge(
            window, edge_want,
            ConvertPointToTarget(parent, window,
                                 gfx::Point(x_in_parent, y_in_parent)))) {
      return window;
    }

    // Having determined that the window is not a suitable return value, if it
    // contains the point, then it is obscuring that point on any remaining
    // window that also contains the point.
    if (window->bounds().Contains(x_in_parent, y_in_parent))
      return nullptr;
  }
  return nullptr;
}

aura::Window* MultiWindowResizeController::FindWindowTouching(
    aura::Window* window,
    Direction direction) const {
  int right = window->bounds().right();
  int bottom = window->bounds().bottom();
  aura::Window* parent = window->parent();
  const aura::Window::Windows& windows = parent->children();
  for (aura::Window* other : base::Reversed(windows)) {
    if (other == window || !other->IsVisible())
      continue;
    switch (direction) {
      case Direction::kTopBottom:
        if (other->bounds().y() == bottom &&
            Intersects(other->bounds().x(), other->bounds().right(),
                       window->bounds().x(), window->bounds().right())) {
          return other;
        }
        break;
      case Direction::kLeftRight:
        if (other->bounds().x() == right &&
            Intersects(other->bounds().y(), other->bounds().bottom(),
                       window->bounds().y(), window->bounds().bottom())) {
          return other;
        }
        break;
      default:
        NOTREACHED();
    }
  }
  return nullptr;
}

void MultiWindowResizeController::FindWindowsTouching(
    aura::Window* start,
    Direction direction,
    aura::Window::Windows* others) const {
  while (start) {
    start = FindWindowTouching(start, direction);
    if (start)
      others->push_back(start);
  }
}

void MultiWindowResizeController::StartObserving(aura::Window* window) {
  window_observations_.AddObservation(window);
  window_state_observations_.AddObservation(WindowState::Get(window));
}

void MultiWindowResizeController::StopObserving(aura::Window* window) {
  window_observations_.RemoveObservation(window);
  window_state_observations_.RemoveObservation(WindowState::Get(window));
}

bool MultiWindowResizeController::IsObserving(aura::Window* window) const {
  return window_observations_.IsObservingSource(window);
}

void MultiWindowResizeController::ShowIfValidMouseLocation() {
  if (DetermineWindowsFromScreenPoint(windows_.window1).Equals(windows_) ||
      DetermineWindowsFromScreenPoint(windows_.window2).Equals(windows_)) {
    ShowNow();
  } else {
    Hide();
  }
}

void MultiWindowResizeController::ShowNow() {
  DCHECK(!resize_widget_.get());
  DCHECK(windows_.is_valid());
  show_timer_.Stop();
  aura::Window* window1 = windows_.window1;
  aura::Window* window2 = windows_.window2;

  resize_widget_ = std::make_unique<views::Widget>();
  resize_widget_->set_focus_on_creation(false);
  aura::Window* parent_window = window1->GetRootWindow()->GetChildById(
      kShellWindowId_AlwaysOnTopContainer);
  resize_widget_->Init(CreateWidgetParams(
      parent_window, /*widget_name=*/"MultiWindowResizeController"));

  ::wm::SetWindowVisibilityAnimationType(
      resize_widget_->GetNativeWindow(),
      ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
  resize_widget_->SetContentsView(
      std::make_unique<ResizeView>(this, windows_.direction));
  gfx::Rect resize_widget_bounds =
      CalculateResizeWidgetBounds(gfx::PointF(show_location_in_parent_));
  resize_widget_show_bounds_in_screen_ =
      ConvertRectToScreen(window1->parent(), resize_widget_bounds);
  resize_widget_->SetBounds(resize_widget_show_bounds_in_screen_);
  resize_widget_->Show();

  base::RecordAction(base::UserMetricsAction(kMultiWindowResizerShow));
  base::UmaHistogramBoolean(kMultiWindowResizerShowHistogramName, true);

  if (WindowState::Get(window1)->IsSnapped() &&
      WindowState::Get(window2)->IsSnapped()) {
    base::RecordAction(
        base::UserMetricsAction(kMultiWindowResizerShowTwoWindowsSnapped));
    base::UmaHistogramBoolean(
        kMultiWindowResizerShowTwoWindowsSnappedHistogramName, true);
  }

  CreateMouseWatcher();
}

bool MultiWindowResizeController::IsShowing() const {
  return resize_widget_.get() || show_timer_.IsRunning();
}

void MultiWindowResizeController::Hide() {
  // Ignore `Hide` while actively resizing.
  if (window_resizer_) {
    return;
  }

  if (windows_.window1) {
    StopObserving(windows_.window1);
    windows_.window1 = nullptr;
  }
  if (windows_.window2) {
    StopObserving(windows_.window2);
    windows_.window2 = nullptr;
  }

  show_timer_.Stop();

  if (!resize_widget_) {
    return;
  }

  for (aura::Window* window : windows_.other_windows) {
    StopObserving(window);
  }

  mouse_watcher_.reset();
  resize_widget_.reset();
  windows_ = ResizeWindows();
}

void MultiWindowResizeController::ResetResizer() {
  // Have to explicitly reset the WindowResizer, otherwise Hide() does nothing.
  window_resizer_.reset();
  Hide();
}

void MultiWindowResizeController::StartResize(
    const gfx::PointF& location_in_screen) {
  DCHECK(!window_resizer_.get());
  DCHECK(windows_.is_valid());
  gfx::PointF location_in_parent =
      ConvertPointFromScreen(windows_.window2->parent(), location_in_screen);
  aura::Window::Windows windows;
  windows.push_back(windows_.window2.get());
  DCHECK(windows_.other_windows.empty());
  FindWindowsTouching(windows_.window2, windows_.direction,
                      &windows_.other_windows);

  for (aura::Window* other_window : windows_.other_windows) {
    StartObserving(other_window);
    windows.push_back(other_window);
  }

  int component =
      windows_.direction == Direction::kLeftRight ? HTRIGHT : HTBOTTOM;
  WindowState* window_state = WindowState::Get(windows_.window1);
  window_state->CreateDragDetails(location_in_parent, component,
                                  ::wm::WINDOW_MOVE_SOURCE_MOUSE);
  window_resizer_ = WorkspaceWindowResizer::Create(window_state, windows);

  // Do not hide the resize widget while a drag is active.
  mouse_watcher_.reset();
  base::RecordAction(base::UserMetricsAction(kMultiWindowResizerClick));
  base::UmaHistogramBoolean(kMultiWindowResizerClickHistogramName, true);

  if (WindowState::Get(windows_.window1)->IsSnapped() &&
      WindowState::Get(windows_.window2)->IsSnapped()) {
    base::RecordAction(
        base::UserMetricsAction(kMultiWindowResizerClickTwoWindowsSnapped));
    base::UmaHistogramBoolean(
        kMultiWindowResizerClickTwoWindowsSnappedHistogramName, true);
  }
}

void MultiWindowResizeController::Resize(const gfx::PointF& location_in_screen,
                                         int event_flags) {
  gfx::PointF location_in_parent =
      ConvertPointFromScreen(windows_.window1->parent(), location_in_screen);
  window_resizer_->Drag(location_in_parent, event_flags);
  gfx::Rect bounds =
      ConvertRectToScreen(windows_.window1->parent(),
                          CalculateResizeWidgetBounds(location_in_parent));

  if (windows_.direction == Direction::kLeftRight) {
    bounds.set_y(resize_widget_show_bounds_in_screen_.y());
  } else {
    bounds.set_x(resize_widget_show_bounds_in_screen_.x());
  }

  resize_widget_->SetBounds(bounds);
}

void MultiWindowResizeController::CompleteResize() {
  window_resizer_->CompleteDrag();
  WindowState::Get(window_resizer_->GetTarget())->DeleteDragDetails();
  window_resizer_.reset();

  // Mouse may still be over resizer, if not hide.
  gfx::Point screen_loc = display::Screen::GetScreen()->GetCursorScreenPoint();
  if (!resize_widget_->GetWindowBoundsInScreen().Contains(screen_loc)) {
    Hide();
  } else {
    // If the mouse is over the resizer we need to remove observers on any of
    // the `other_windows`. If we start another resize we'll recalculate the
    // `other_windows` and invoke AddObserver() as necessary.
    for (aura::Window* other_window : windows_.other_windows) {
      StopObserving(other_window);
    }

    windows_.other_windows.clear();
    CreateMouseWatcher();
  }
}

void MultiWindowResizeController::CancelResize() {
  // Happens if window was destroyed and we nuked the WindowResizer.
  if (!window_resizer_) {
    return;
  }

  window_resizer_->RevertDrag();
  WindowState::Get(window_resizer_->GetTarget())->DeleteDragDetails();
  ResetResizer();
}

gfx::Rect MultiWindowResizeController::CalculateResizeWidgetBounds(
    const gfx::PointF& location_in_parent) const {
  gfx::Size pref = resize_widget_->GetContentsView()->GetPreferredSize();
  int x = 0, y = 0;
  if (windows_.direction == Direction::kLeftRight) {
    x = windows_.window1->bounds().right() - pref.width() / 2;
    y = location_in_parent.y() + kResizeWidgetPadding;
    if (y + pref.height() / 2 > windows_.window1->bounds().bottom() &&
        y + pref.height() / 2 > windows_.window2->bounds().bottom()) {
      y = location_in_parent.y() - kResizeWidgetPadding - pref.height();
    }
  } else {
    x = location_in_parent.x() + kResizeWidgetPadding;
    if (x + pref.height() / 2 > windows_.window1->bounds().right() &&
        x + pref.height() / 2 > windows_.window2->bounds().right()) {
      x = location_in_parent.x() - kResizeWidgetPadding - pref.width();
    }
    y = windows_.window1->bounds().bottom() - pref.height() / 2;
  }
  return gfx::Rect(x, y, pref.width(), pref.height());
}

bool MultiWindowResizeController::IsOverResizeWidget(
    const gfx::Point& location_in_screen) const {
  return resize_widget_->GetWindowBoundsInScreen().Contains(location_in_screen);
}

bool MultiWindowResizeController::IsOverWindows(
    const gfx::Point& location_in_screen) const {
  if (IsOverResizeWidget(location_in_screen)) {
    return true;
  }

  if (windows_.direction == Direction::kTopBottom) {
    if (!ContainsScreenX(windows_.window1, location_in_screen.x()) ||
        !ContainsScreenX(windows_.window2, location_in_screen.x())) {
      return false;
    }
  } else {
    if (!ContainsScreenY(windows_.window1, location_in_screen.y()) ||
        !ContainsScreenY(windows_.window2, location_in_screen.y())) {
      return false;
    }
  }

  // Check whether `location_in_screen` is in the event target's resize region.
  // This is tricky because a window's resize region can extend outside a
  // window's bounds.
  aura::Window* target = RootWindowController::ForWindow(windows_.window1)
                             ->FindEventTarget(location_in_screen);
  if (target == windows_.window1) {
    return IsOverComponent(
        windows_.window1, location_in_screen,
        windows_.direction == Direction::kTopBottom ? HTBOTTOM : HTRIGHT);
  }
  if (target == windows_.window2) {
    return IsOverComponent(
        windows_.window2, location_in_screen,
        windows_.direction == Direction::kTopBottom ? HTTOP : HTLEFT);
  }
  return false;
}

bool MultiWindowResizeController::IsOverComponent(
    aura::Window* window,
    const gfx::Point& location_in_screen,
    int component) const {
  gfx::Point window_loc(location_in_screen);
  ::wm::ConvertPointFromScreen(window, &window_loc);
  return window_util::GetNonClientComponent(window, window_loc) == component;
}

}  // namespace ash