Moves move logic into WM instead of WS

components/mus/ws/event_dispatcher.cc

 // Copyright 2015 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 "components/mus/ws/event_dispatcher.h"
 
 #include "cc/surfaces/surface_hittest.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/event_dispatcher_delegate.h"
-#include "components/mus/ws/move_loop.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_delegate.h"
 #include "components/mus/ws/window_coordinate_conversions.h"
 #include "components/mus/ws/window_finder.h"
 #include "components/mus/ws/window_tree_host_impl.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point_conversions.h"
 
 namespace mus {
 namespace ws {
 namespace {
 
 bool IsPointerEvent(const mojo::Event& event) {
   return event.action == mojo::EVENT_TYPE_POINTER_CANCEL ||
          event.action == mojo::EVENT_TYPE_POINTER_DOWN ||
          event.action == mojo::EVENT_TYPE_POINTER_MOVE ||
          event.action == mojo::EVENT_TYPE_POINTER_UP;
 }
 
-}  // namespace
-
-namespace {
-
 bool IsMouseEventFlag(int32_t event_flags) {
   return !!(event_flags & (mojo::EVENT_FLAGS_LEFT_MOUSE_BUTTON |
                            mojo::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
                            mojo::EVENT_FLAGS_RIGHT_MOUSE_BUTTON));
 }
 
 bool IsOnlyOneMouseButtonDown(mojo::EventFlags flags) {
   const uint32_t mouse_only_flags =
       flags & (mojo::EVENT_FLAGS_LEFT_MOUSE_BUTTON |
                mojo::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
                mojo::EVENT_FLAGS_RIGHT_MOUSE_BUTTON);
   return mouse_only_flags == mojo::EVENT_FLAGS_LEFT_MOUSE_BUTTON ||
          mouse_only_flags == mojo::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON ||
          mouse_only_flags == mojo::EVENT_FLAGS_RIGHT_MOUSE_BUTTON;
 }
 
+bool IsLocationInNonclientArea(const ServerWindow* target,
+                               const gfx::Point& location) {
+  return target->parent() &&
+         !target->client_area().Contains(location);
+}
+
+gfx::Point EventLocationToPoint(const mojo::Event& event) {
+  return gfx::ToFlooredPoint(gfx::PointF(event.pointer_data->location->x,
+                                         event.pointer_data->location->y));
+}
+
 }  // namespace
 
 class EventMatcher {
  public:
   explicit EventMatcher(const mojo::EventMatcher& matcher)
       : fields_to_match_(NONE),
         event_type_(mojo::EVENT_TYPE_UNKNOWN),
         event_flags_(mojo::EVENT_FLAGS_NONE),
         keyboard_code_(mojo::KEYBOARD_CODE_UNKNOWN),
         pointer_kind_(mojo::POINTER_KIND_MOUSE) {
@@ skipping 74 matching lines @@
   mojo::EventType event_type_;
   mojo::EventFlags event_flags_;
   mojo::KeyboardCode keyboard_code_;
   mojo::PointerKind pointer_kind_;
   gfx::RectF pointer_region_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
-    : delegate_(delegate), root_(nullptr), capture_window_(nullptr) {}
+    : delegate_(delegate),
+      root_(nullptr),
+      capture_window_(nullptr),
+      capture_in_nonclient_area_(false) {}
 
 EventDispatcher::~EventDispatcher() {}
 
 void EventDispatcher::AddAccelerator(uint32_t id,
                                      mojo::EventMatcherPtr event_matcher) {
   EventMatcher matcher(*event_matcher);
 #if !defined(NDEBUG)
   for (const auto& pair : accelerators_) {
     DCHECK_NE(pair.first, id);
     DCHECK(!matcher.Equals(pair.second));
@@ skipping 14 matching lines @@
 
   if (event->action == mojo::EVENT_TYPE_KEY_PRESSED &&
       !event->key_data->is_char) {
     uint32_t accelerator = 0u;
     if (FindAccelerator(*event, &accelerator)) {
       delegate_->OnAccelerator(accelerator, event.Pass());
       return;
     }
   }
 
-  // If there is a MoveLoop all pointer events are forwarded to it.
-  if (move_loop_ && IsPointerEvent(*event)) {
-    if (move_loop_->Move(*event) == MoveLoop::DONE) {
-      move_loop_.reset();
-      ResetCaptureWindowIfPointerUp(*event);
-    }
-
-    return;
-  }
-
   ServerWindow* target = FindEventTarget(event.get());
+  bool in_nonclient_area = false;
 
   if (IsMouseEventFlag(event->flags)) {
-    if (!capture_window_ && (event->action == mojo::EVENT_TYPE_POINTER_DOWN))
+    if (!capture_window_ && target &&
+        (event->action == mojo::EVENT_TYPE_POINTER_DOWN)) {
+      // TODO(sky): |capture_window_| needs to be reset when window removed
+      // from hierarchy.
       capture_window_ = target;
-    else
-      ResetCaptureWindowIfPointerUp(*event);
+      // TODO(sky): this needs to happen for pointer down events too.
+      capture_in_nonclient_area_ =
+          IsLocationInNonclientArea(target, EventLocationToPoint(*event));
+      in_nonclient_area = capture_in_nonclient_area_;
+    } else if (event->action == mojo::EVENT_TYPE_POINTER_UP &&
+               IsOnlyOneMouseButtonDown(event->flags)) {
+      capture_window_ = nullptr;
+    }
+    in_nonclient_area = capture_in_nonclient_area_;
   }
 
   if (target) {
-    if (event->action == mojo::EVENT_TYPE_POINTER_DOWN) {
+    if (event->action == mojo::EVENT_TYPE_POINTER_DOWN)
       delegate_->SetFocusedWindowFromEventDispatcher(target);
 
-      if (!move_loop_) {
-        move_loop_ = MoveLoop::Create(target, *event);
-        if (move_loop_)
-          return;
-      }
-    }
-
-    delegate_->DispatchInputEventToWindow(target, event.Pass());
+    delegate_->DispatchInputEventToWindow(target, in_nonclient_area,
+                                          event.Pass());
   }
 }
 
 bool EventDispatcher::FindAccelerator(const mojo::Event& event,
                                       uint32_t* accelerator_id) {
   DCHECK(event.key_data);
   for (const auto& pair : accelerators_) {
     if (pair.second.MatchesEvent(event)) {
       *accelerator_id = pair.first;
       return true;
@@ skipping 24 matching lines @@
 
   if (!target) {
     target = FindDeepestVisibleWindow(root_, surface_id_, &location);
   } else {
     gfx::Transform transform(GetTransformToWindow(surface_id_, target));
     transform.TransformPoint(&location);
   }
 
   event_location->x = location.x();
   event_location->y = location.y();
+
   return target;
 }
 
-void EventDispatcher::ResetCaptureWindowIfPointerUp(const mojo::Event& event) {
-  if (event.action == mojo::EVENT_TYPE_POINTER_UP &&
-      IsOnlyOneMouseButtonDown(event.flags)) {
-    capture_window_ = nullptr;
-  }
-}
-
 }  // namespace ws
 }  // namespace mus