Revert of Improve the logic for hiding the multi-window resize handle

ash/wm/workspace/multi_window_resize_controller.cc

 // Copyright (c) 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/wm/workspace/multi_window_resize_controller.h"
 
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/workspace/workspace_event_handler.h"
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "grit/ash_resources.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/resource/resource_bundle.h"
-#include "ui/events/event_targeter.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/compound_event_filter.h"
 #include "ui/wm/core/coordinate_conversion.h"
 
 using aura::Window;
 
 namespace ash {
 namespace {
 
 // Delay before showing.
 const int kShowDelayMS = 400;
 
 // Delay before hiding.
 const int kHideDelayMS = 500;
 
 // Padding from the bottom/right edge the resize widget is shown at.
 const int kResizeWidgetPadding = 15;
 
 bool ContainsX(Window* window, int x) {
-  return x >= 0 && x <= window->bounds().width();
-}
-
-bool ContainsScreenX(Window* window, int x_in_screen) {
-  gfx::Point window_loc(x_in_screen, 0);
-  ::wm::ConvertPointFromScreen(window, &window_loc);
-  return ContainsX(window, window_loc.x());
+  return window->bounds().x() <= x && window->bounds().right() >= x;
 }
 
 bool ContainsY(Window* window, int y) {
-  return y >= 0 && y <= window->bounds().height();
-}
-
-bool ContainsScreenY(Window* window, int y_in_screen) {
-  gfx::Point window_loc(0, y_in_screen);
-  ::wm::ConvertPointFromScreen(window, &window_loc);
-  return ContainsY(window, window_loc.y());
+  return window->bounds().y() <= y && window->bounds().bottom() >= y;
 }
 
 bool Intersects(int x1, int max_1, int x2, int max_2) {
   return x2 <= max_1 && max_2 > x1;
 }
 
 }  // namespace
 
 // View contained in the widget. Passes along mouse events to the
 // MultiWindowResizeController so that it can start/stop the resize loop.
@@ skipping 95 matching lines @@
                                        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))
+  if (IsShowing()) {
+    if (windows_.Equals(windows))
+      return;  // Over the same windows.
+    DelayedHide();
+  }
+
+  if (!windows.is_valid())
     return;
-
   Hide();
   windows_ = windows;
-  if (!windows.is_valid())
-    return;
-
   windows_.window1->AddObserver(this);
   windows_.window2->AddObserver(this);
   show_location_in_parent_ = point_in_window;
   Window::ConvertPointToTarget(
       window, window->parent(), &show_location_in_parent_);
+  if (show_timer_.IsRunning())
+    return;
   show_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(kShowDelayMS),
       this, &MultiWindowResizeController::ShowIfValidMouseLocation);
 }
 
 void MultiWindowResizeController::Hide() {
+  hide_timer_.Stop();
   if (window_resizer_)
     return;  // Ignore hides while actively resizing.
 
   if (windows_.window1) {
     windows_.window1->RemoveObserver(this);
     windows_.window1 = NULL;
   }
   if (windows_.window2) {
     windows_.window2->RemoveObserver(this);
     windows_.window2 = NULL;
@@ skipping 26 matching lines @@
 MultiWindowResizeController::DetermineWindowsFromScreenPoint(
     aura::Window* window) const {
   gfx::Point mouse_location(
       gfx::Screen::GetScreenFor(window)->GetCursorScreenPoint());
   ::wm::ConvertPointFromScreen(window, &mouse_location);
   const int component =
       window->delegate()->GetNonClientComponent(mouse_location);
   return DetermineWindows(window, component, mouse_location);
 }
 
-void MultiWindowResizeController::CreateMouseWatcher() {
-  mouse_watcher_.reset(new views::MouseWatcher(
-      new ResizeMouseWatcherHost(this), this));
-  mouse_watcher_->set_notify_on_exit_time(
-      base::TimeDelta::FromMilliseconds(kHideDelayMS));
-  mouse_watcher_->Start();
-}
-
 MultiWindowResizeController::ResizeWindows
 MultiWindowResizeController::DetermineWindows(
     Window* window,
     int window_component,
     const gfx::Point& point) const {
   ResizeWindows result;
   gfx::Point point_in_parent(point);
   Window::ConvertPointToTarget(window, window->parent(), &point_in_parent);
   switch (window_component) {
     case HTRIGHT:
@@ skipping 22 matching lines @@
       break;
     default:
       break;
   }
   return result;
 }
 
 Window* MultiWindowResizeController::FindWindowByEdge(
     Window* window_to_ignore,
     int edge_want,
-    int x_in_parent,
-    int y_in_parent) const {
+    int x,
+    int y) const {
   Window* parent = window_to_ignore->parent();
   const Window::Windows& windows(parent->children());
   for (Window::Windows::const_reverse_iterator i = windows.rbegin();
        i != windows.rend(); ++i) {
     Window* window = *i;
     if (window == window_to_ignore || !window->IsVisible())
       continue;
-
-    // Ignore windows without a delegate. A delegate is necessary to query the
-    // non-client component.
-    if (!window->delegate())
-      continue;
-
-    gfx::Point p(x_in_parent, y_in_parent);
-    aura::Window::ConvertPointToTarget(parent, window, &p);
     switch (edge_want) {
       case HTLEFT:
-        if (ContainsY(window, p.y()) && p.x() == 0)
+        if (ContainsY(window, y) && window->bounds().x() == x)
           return window;
         break;
       case HTRIGHT:
-        if (ContainsY(window, p.y()) && p.x() == window->bounds().width())
+        if (ContainsY(window, y) && window->bounds().right() == x)
           return window;
         break;
       case HTTOP:
-        if (ContainsX(window, p.x()) && p.y() == 0)
+        if (ContainsX(window, x) && window->bounds().y() == y)
           return window;
         break;
       case HTBOTTOM:
-        if (ContainsX(window, p.x()) && p.y() == window->bounds().height())
+        if (ContainsX(window, x) && window->bounds().bottom() == y)
           return window;
         break;
       default:
         NOTREACHED();
     }
     // Window doesn't contain the edge, but if window contains |point|
     // it's obscuring any other window that could be at the location.
-    if (window->bounds().Contains(x_in_parent, y_in_parent))
+    if (window->bounds().Contains(x, y))
       return NULL;
   }
   return NULL;
 }
 
 aura::Window* MultiWindowResizeController::FindWindowTouching(
     aura::Window* window,
     Direction direction) const {
   int right = window->bounds().right();
   int bottom = window->bounds().bottom();
@@ skipping 30 matching lines @@
     aura::Window* start,
     Direction direction,
     std::vector<aura::Window*>* others) const {
   while (start) {
     start = FindWindowTouching(start, direction);
     if (start)
       others->push_back(start);
   }
 }
 
+void MultiWindowResizeController::DelayedHide() {
+  if (hide_timer_.IsRunning())
+    return;
+
+  hide_timer_.Start(FROM_HERE,
+                    base::TimeDelta::FromMilliseconds(kHideDelayMS),
+                    this, &MultiWindowResizeController::Hide);
+}
+
 void MultiWindowResizeController::ShowIfValidMouseLocation() {
   if (DetermineWindowsFromScreenPoint(windows_.window1).Equals(windows_) ||
       DetermineWindowsFromScreenPoint(windows_.window2).Equals(windows_)) {
     ShowNow();
   } else {
     Hide();
   }
 }
 
 void MultiWindowResizeController::ShowNow() {
@@ skipping 12 matching lines @@
   ::wm::SetWindowVisibilityAnimationType(
       resize_widget_->GetNativeWindow(),
       ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
   resize_widget_->GetNativeWindow()->SetName("MultiWindowResizeController");
   resize_widget_->SetContentsView(view);
   show_bounds_in_screen_ = ScreenUtil::ConvertRectToScreen(
       windows_.window1->parent(),
       CalculateResizeWidgetBounds(show_location_in_parent_));
   resize_widget_->SetBounds(show_bounds_in_screen_);
   resize_widget_->Show();
-  CreateMouseWatcher();
+  mouse_watcher_.reset(new views::MouseWatcher(
+                           new ResizeMouseWatcherHost(this),
+                           this));
+  mouse_watcher_->set_notify_on_exit_time(
+      base::TimeDelta::FromMilliseconds(kHideDelayMS));
+  mouse_watcher_->Start();
 }
 
 bool MultiWindowResizeController::IsShowing() const {
   return resize_widget_.get() || show_timer_.IsRunning();
 }
 
 void MultiWindowResizeController::StartResize(
     const gfx::Point& location_in_screen) {
   DCHECK(!window_resizer_.get());
   DCHECK(windows_.is_valid());
+  hide_timer_.Stop();
   gfx::Point location_in_parent(location_in_screen);
   aura::client::GetScreenPositionClient(windows_.window2->GetRootWindow())->
       ConvertPointFromScreen(windows_.window2->parent(), &location_in_parent);
   std::vector<aura::Window*> windows;
   windows.push_back(windows_.window2);
   DCHECK(windows_.other_windows.empty());
   FindWindowsTouching(windows_.window2, windows_.direction,
                       &windows_.other_windows);
   for (size_t i = 0; i < windows_.other_windows.size(); ++i) {
     windows_.other_windows[i]->AddObserver(this);
     windows.push_back(windows_.other_windows[i]);
   }
   int component = windows_.direction == LEFT_RIGHT ? HTRIGHT : HTBOTTOM;
   wm::WindowState* window_state = wm::GetWindowState(windows_.window1);
   window_state->CreateDragDetails(windows_.window1,
                                   location_in_parent,
                                   component,
                                   aura::client::WINDOW_MOVE_SOURCE_MOUSE);
   window_resizer_.reset(WorkspaceWindowResizer::Create(window_state, windows));
-
-  // Do not hide the resize widget while a drag is active.
-  mouse_watcher_.reset();
 }
 
 void MultiWindowResizeController::Resize(const gfx::Point& location_in_screen,
                                          int event_flags) {
   gfx::Point location_in_parent(location_in_screen);
   aura::client::GetScreenPositionClient(windows_.window1->GetRootWindow())->
       ConvertPointFromScreen(windows_.window1->parent(), &location_in_parent);
   window_resizer_->Drag(location_in_parent, event_flags);
   gfx::Rect bounds = ScreenUtil::ConvertRectToScreen(
       windows_.window1->parent(),
@@ skipping 15 matching lines @@
   gfx::Point screen_loc = Shell::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 (size_t i = 0; i < windows_.other_windows.size(); ++i)
       windows_.other_windows[i]->RemoveObserver(this);
     windows_.other_windows.clear();
-
-    CreateMouseWatcher();
   }
 }
 
 void MultiWindowResizeController::CancelResize() {
   if (!window_resizer_)
     return;  // Happens if window was destroyed and we nuked the WindowResizer.
   window_resizer_->RevertDrag();
   wm::GetWindowState(window_resizer_->GetTarget())->DeleteDragDetails();
   window_resizer_.reset();
   Hide();
@@ skipping 16 matching lines @@
         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::IsOverWindows(
     const gfx::Point& location_in_screen) const {
+  if (window_resizer_)
+    return true;  // Ignore hides while actively resizing.
+
   if (resize_widget_->GetWindowBoundsInScreen().Contains(location_in_screen))
     return true;
 
+  int hit1, hit2;
   if (windows_.direction == TOP_BOTTOM) {
-    if (!ContainsScreenX(windows_.window1, location_in_screen.x()) ||
-        !ContainsScreenX(windows_.window2, location_in_screen.x())) {
-      return false;
-    }
+    hit1 = HTBOTTOM;
+    hit2 = HTTOP;
   } else {
-    if (!ContainsScreenY(windows_.window1, location_in_screen.y()) ||
-        !ContainsScreenY(windows_.window2, location_in_screen.y())) {
-      return false;
-    }
+    hit1 = HTRIGHT;
+    hit2 = HTLEFT;
   }
 
-  // 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.
-  gfx::Point location_in_root(location_in_screen);
-  aura::Window* root = windows_.window1->GetRootWindow();
-  ::wm::ConvertPointFromScreen(root, &location_in_root);
-  ui::MouseEvent test_event(ui::ET_MOUSE_MOVED, location_in_root,
-                            location_in_root, ui::EF_NONE, ui::EF_NONE);
-  ui::EventTarget* event_handler = static_cast<ui::EventTarget*>(root)
-                                       ->GetEventTargeter()
-                                       ->FindTargetForEvent(root, &test_event);
-  if (event_handler == windows_.window1) {
-    return IsOverComponent(
-        windows_.window1,
-        location_in_screen,
-        windows_.direction == TOP_BOTTOM ? HTBOTTOM : HTRIGHT);
-  } else if (event_handler == windows_.window2) {
-    return IsOverComponent(
-        windows_.window2,
-        location_in_screen,
-        windows_.direction == TOP_BOTTOM ? HTTOP : HTLEFT);
-  }
-  return false;
+  return IsOverWindow(windows_.window1, location_in_screen, hit1) ||
+      IsOverWindow(windows_.window2, location_in_screen, hit2);
 }
 
-bool MultiWindowResizeController::IsOverComponent(
+bool MultiWindowResizeController::IsOverWindow(
     aura::Window* window,
     const gfx::Point& location_in_screen,
     int component) const {
+  if (!window->delegate())
+    return false;
+
   gfx::Point window_loc(location_in_screen);
-  ::wm::ConvertPointFromScreen(window, &window_loc);
-  return window->delegate()->GetNonClientComponent(window_loc) == component;
+  aura::Window::ConvertPointToTarget(
+      window->GetRootWindow(), window, &window_loc);
+  return window->ContainsPoint(window_loc) &&
+      window->delegate()->GetNonClientComponent(window_loc) == component;
 }
 
 }  // namespace ash