Update ui::PointerEvent to support mouse wheel and capture change events.

services/ui/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 "services/ui/ws/event_dispatcher.h"
 
 #include <algorithm>
 
 #include "base/time/time.h"
 #include "services/ui/ws/accelerator.h"
@@ skipping 35 matching lines @@
 
   for (const auto& rect : target->additional_client_areas()) {
     if (rect.Contains(location))
       return false;
   }
 
   return true;
 }
 
 uint32_t PointerId(const ui::LocatedEvent& event) {
-  if (event.IsPointerEvent())
-    return event.AsPointerEvent()->pointer_id();
-  if (event.IsMouseWheelEvent())
-    return ui::PointerEvent::kMousePointerId;
-
-  NOTREACHED();
-  return 0;
+  DCHECK(event.IsPointerEvent());
+  return event.AsPointerEvent()->pointer_id();
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
     : delegate_(delegate),
       capture_window_(nullptr),
       capture_window_client_id_(kInvalidClientId),
@@ skipping 207 matching lines @@
         delegate_->OnAccelerator(
             pre_target->id(), event,
             EventDispatcherDelegate::AcceleratorPhase::PRE);
         return;
       }
     }
     ProcessKeyEvent(*key_event, match_phase);
     return;
   }
 
-  if (event.IsPointerEvent() || event.IsMouseWheelEvent()) {
+  if (event.IsPointerEvent()) {
     ProcessLocatedEvent(*event.AsLocatedEvent());
     return;
   }
 
   NOTREACHED();
 }
 
 void EventDispatcher::ProcessKeyEvent(const ui::KeyEvent& event,
                                       AcceleratorMatchPhase match_phase) {
   Accelerator* post_target =
       FindAccelerator(event, ui::mojom::AcceleratorPhase::POST_TARGET);
   ServerWindow* focused_window =
       delegate_->GetFocusedWindowForEventDispatcher();
   if (focused_window) {
     // Assume key events are for the client area.
     const bool in_nonclient_area = false;
     const ClientSpecificId client_id =
         delegate_->GetEventTargetClientId(focused_window, in_nonclient_area);
     delegate_->DispatchInputEventToWindow(focused_window, client_id, event,
                                           post_target);
     return;
   }
   delegate_->OnEventTargetNotFound(event);
   if (post_target)
     delegate_->OnAccelerator(post_target->id(), event,
                              EventDispatcherDelegate::AcceleratorPhase::POST);
 }
 
 void EventDispatcher::ProcessLocatedEvent(const ui::LocatedEvent& event) {

[sadrul, 2016/08/22 17:15:57]

ProcessPointerEvent(const ui::PointerEvent&)?

[riajiang, 2016/08/22 20:16:41]

Sorry I forgot. Done.

-  DCHECK(event.IsPointerEvent() || event.IsMouseWheelEvent());
-  const bool is_mouse_event =
-      event.IsMousePointerEvent() || event.IsMouseWheelEvent();
+  // TODO(moshayedi): crbug.com/602859. Handle scroll events as
+  // they are once we have proper support for scroll events.
+  DCHECK(event.IsPointerEvent());
+  const bool is_mouse_event = event.IsMousePointerEvent();
 
   if (is_mouse_event) {
     mouse_pointer_last_location_ = event.root_location();
     delegate_->OnMouseCursorLocationChanged(event.root_location());
   }
 
   // Release capture on pointer up. For mouse we only release if there are
   // no buttons down.
   const bool is_pointer_going_up =
       (event.type() == ui::ET_POINTER_UP ||
        event.type() == ui::ET_POINTER_CANCELLED) &&
       (!is_mouse_event || IsOnlyOneMouseButtonDown(event.flags()));
 
   // Update mouse down state upon events which change it.
   if (is_mouse_event) {
     if (event.type() == ui::ET_POINTER_DOWN)
       mouse_button_down_ = true;
     else if (is_pointer_going_up)
       mouse_button_down_ = false;
   }
 
   if (capture_window_) {
     mouse_cursor_source_window_ = capture_window_;
     DispatchToClient(capture_window_, capture_window_client_id_, event);
     return;
   }
 
   const int32_t pointer_id = PointerId(event);

[sadrul, 2016/08/22 17:15:57]

Just use |event.pointer_id()| (since |event| will be PointerEvent)

[riajiang, 2016/08/22 20:16:41]

Done.

   if (!IsTrackingPointer(pointer_id) ||
       !pointer_targets_[pointer_id].is_pointer_down) {
     const bool any_pointers_down = AreAnyPointersDown();
     UpdateTargetForPointer(pointer_id, event);
     if (is_mouse_event)
       mouse_cursor_source_window_ = pointer_targets_[pointer_id].window;
 
     PointerTarget& pointer_target = pointer_targets_[pointer_id];
     if (pointer_target.is_pointer_down) {
       if (is_mouse_event)
@@ skipping 209 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace ui