Touch HUD app for mustash

ui/views/mus/window_manager_connection.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 "ui/views/mus/window_manager_connection.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/threading/thread_local.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_property.h"
 #include "components/mus/public/cpp/window_tree_client.h"
 #include "components/mus/public/interfaces/event_matcher.mojom.h"
 #include "components/mus/public/interfaces/window_tree.mojom.h"
+#include "mojo/common/common_type_converters.h"
 #include "services/shell/public/cpp/connection.h"
 #include "services/shell/public/cpp/connector.h"
 #include "ui/views/mus/clipboard_mus.h"
 #include "ui/views/mus/native_widget_mus.h"
 #include "ui/views/mus/screen_mus.h"
 #include "ui/views/pointer_watcher.h"
 #include "ui/views/views_delegate.h"
 
 namespace views {
 namespace {
@@ skipping 52 matching lines @@
                              mus::mojom::SurfaceType::DEFAULT);
 }
 
 void WindowManagerConnection::AddPointerWatcher(PointerWatcher* watcher) {
   bool had_watcher = HasPointerWatcher();
   pointer_watchers_.AddObserver(watcher);
   if (!had_watcher) {
     // Start a watcher for pointer down.
     // TODO(jamescook): Extend event observers to handle multiple event types.
     mus::mojom::EventMatcherPtr matcher = mus::mojom::EventMatcher::New();
-    matcher->type_matcher = mus::mojom::EventTypeMatcher::New();
-    matcher->type_matcher->type = ui::mojom::EventType::POINTER_DOWN;
+    matcher->types_matcher = mus::mojom::EventMultTypeMatcher::New();
+
+    matcher->types_matcher->types = mojo::Array<ui::mojom::EventType>::New(4);
+    matcher->types_matcher->types.push_back(ui::mojom::EventType::POINTER_DOWN);
+    matcher->types_matcher->types.push_back(ui::mojom::EventType::POINTER_UP);
+    matcher->types_matcher->types.push_back(ui::mojom::EventType::POINTER_MOVE);
+    matcher->types_matcher->types.push_back(
+      ui::mojom::EventType::POINTER_CANCEL);
     client_->SetEventObserver(std::move(matcher));

[sadrul, 2016/06/27 14:44:54]

We currently have PointerWatcher instances that want only the POINTER_DOWN
events. So for most of these cases, we should continue to register only for
POINTER_DOWN. For the cases where we want additional types of events, we should
introduce a new explicit API, for example:
WindowManagerConnection::AddTouchEventWatcher().

I think for now, we won't have clients that use both a PointerWatcher and a
TouchEventWatcher. So WindowManagerConnection (WMC) does not need to merge the
two requests. But in case some clients do want to install both types of watcher,
WMC would need to merge the two requests to make sure it receives the right set
of events.

[riajiang, 2016/06/28 21:52:51]

Done.

   }
 }
 
 void WindowManagerConnection::RemovePointerWatcher(PointerWatcher* watcher) {
   pointer_watchers_.RemoveObserver(watcher);
   if (!HasPointerWatcher()) {
     // Last PointerWatcher removed, stop the event observer.
     client_->SetEventObserver(nullptr);
   }
 }
@@ skipping 60 matching lines @@
     mus::Window* root = target->GetRoot();
     target_widget = NativeWidgetMus::GetWidgetForWindow(root);
   }
 
   // The mojo input events type converter uses the event root_location field
   // to store screen coordinates. Screen coordinates really should be returned
   // separately. See http://crbug.com/608547
   gfx::Point location_in_screen = event.AsLocatedEvent()->root_location();
   if (event.type() == ui::ET_MOUSE_PRESSED) {
     FOR_EACH_OBSERVER(PointerWatcher, pointer_watchers_,
-                      OnMousePressed(*event.AsMouseEvent(), location_in_screen,
-                                     target_widget));
+                      OnMousePressObserved(
+                        *event.AsMouseEvent(), location_in_screen,
+                        target_widget));
   } else if (event.type() == ui::ET_TOUCH_PRESSED) {
     FOR_EACH_OBSERVER(PointerWatcher, pointer_watchers_,
-                      OnTouchPressed(*event.AsTouchEvent(), location_in_screen,
-                                     target_widget));
+                      OnTouchPressObserved(
+                        *event.AsTouchEvent(), location_in_screen,
+                        target_widget));
+  } else if (event.type() == ui::ET_TOUCH_RELEASED) {
+    FOR_EACH_OBSERVER(PointerWatcher, pointer_watchers_,
+                      OnTouchReleaseObserved(
+                        *event.AsTouchEvent(), location_in_screen,
+                        target_widget));
+  } else if (event.type() == ui::ET_TOUCH_MOVED) {
+    FOR_EACH_OBSERVER(PointerWatcher, pointer_watchers_,
+                      OnTouchMoveObserved(
+                        *event.AsTouchEvent(), location_in_screen,
+                        target_widget));
+  } else if (event.type() == ui::ET_TOUCH_CANCELLED) {
+    FOR_EACH_OBSERVER(PointerWatcher, pointer_watchers_,
+                      OnTouchCancellObserved(
+                        *event.AsTouchEvent(), location_in_screen,
+                        target_widget));
   }
 }
 
 void WindowManagerConnection::OnWindowManagerFrameValuesChanged() {
   if (client_)
     NativeWidgetMus::NotifyFrameChanged(client_.get());
 }
 
 gfx::Point WindowManagerConnection::GetCursorScreenPoint() {
   return client_->GetCursorScreenPoint();
 }
 
 }  // namespace views