mus: Add watcher for all touch events.

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 "services/shell/public/cpp/connection.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/ui/common/gpu_service.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/cpp/window.h"
 #include "services/ui/public/cpp/window_property.h"
 #include "services/ui/public/cpp/window_tree_client.h"
 #include "services/ui/public/interfaces/event_matcher.mojom.h"
 #include "services/ui/public/interfaces/window_tree.mojom.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/touch_event_watcher.h"
 #include "ui/views/views_delegate.h"
 
 namespace views {
 namespace {
 
 using WindowManagerConnectionPtr =
     base::ThreadLocalPointer<views::WindowManagerConnection>;
 
 // Env is thread local so that aura may be used on multiple threads.
 base::LazyInstance<WindowManagerConnectionPtr>::Leaky lazy_tls_ptr =
@@ skipping 40 matching lines @@
     return nullptr;
   std::map<std::string, std::vector<uint8_t>> properties = props;
   NativeWidgetMus::ConfigurePropertiesForNewWindow(init_params, &properties);
   properties[ui::mojom::WindowManager::kAppID_Property] =
       mojo::ConvertTo<std::vector<uint8_t>>(identity_.name());
   return new NativeWidgetMus(delegate, connector_, NewWindow(properties),
                              ui::mojom::SurfaceType::DEFAULT);
 }
 
 void WindowManagerConnection::AddPointerWatcher(PointerWatcher* watcher) {
+  // TODO(riajiang): Support multiple event matchers (crbug.com/627146).
+  DCHECK(!HasTouchEventWatcher());
   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.
     ui::mojom::EventMatcherPtr matcher = ui::mojom::EventMatcher::New();
     matcher->type_matcher = ui::mojom::EventTypeMatcher::New();
     matcher->type_matcher->type = ui::mojom::EventType::POINTER_DOWN;
     client_->SetEventObserver(std::move(matcher));
   }
 }
 
 void WindowManagerConnection::RemovePointerWatcher(PointerWatcher* watcher) {
   pointer_watchers_.RemoveObserver(watcher);
   if (!HasPointerWatcher()) {
     // Last PointerWatcher removed, stop the event observer.
     client_->SetEventObserver(nullptr);
   }
 }
 
+void WindowManagerConnection::AddTouchEventWatcher(TouchEventWatcher* watcher) {
+  // TODO(riajiang): Support multiple event matchers (crbug.com/627146).
+  DCHECK(!HasPointerWatcher());
+  bool had_watcher = HasTouchEventWatcher();
+  touch_event_watchers_.AddObserver(watcher);
+  if (!had_watcher) {
+    ui::mojom::EventMatcherPtr matcher = ui::mojom::EventMatcher::New();
+    matcher->pointer_kind_matcher = ui::mojom::PointerKindMatcher::New();
+    matcher->pointer_kind_matcher->pointer_kind = ui::mojom::PointerKind::TOUCH;
+    client_->SetEventObserver(std::move(matcher));
+  }
+}
+
+void WindowManagerConnection::RemoveTouchEventWatcher(
+    TouchEventWatcher* watcher) {
+  touch_event_watchers_.RemoveObserver(watcher);
+  if (!HasTouchEventWatcher()) {
+    // Last PointerWatcher removed, stop the event observer.
+    client_->SetEventObserver(nullptr);
+  }
+}
+
 const std::set<ui::Window*>& WindowManagerConnection::GetRoots() const {
   return client_->GetRoots();
 }
 
 WindowManagerConnection::WindowManagerConnection(
     shell::Connector* connector,
     const shell::Identity& identity)
     : connector_(connector), identity_(identity) {
   lazy_tls_ptr.Pointer()->Set(this);
 
@@ skipping 30 matching lines @@
 }
 
 bool WindowManagerConnection::HasPointerWatcher() {
   // Check to see if we really have any observers left. This doesn't use
   // base::ObserverList<>::might_have_observers() because that returns true
   // during iteration over the list even when the last observer is removed.
   base::ObserverList<PointerWatcher>::Iterator iterator(&pointer_watchers_);
   return !!iterator.GetNext();
 }
 
+bool WindowManagerConnection::HasTouchEventWatcher() {
+  // Check to see if we really have any observers left. This doesn't use
+  // base::ObserverList<>::might_have_observers() because that returns true
+  // during iteration over the list even when the last observer is removed.
+  base::ObserverList<TouchEventWatcher>::Iterator iterator(
+      &touch_event_watchers_);
+  return !!iterator.GetNext();
+}
+
 void WindowManagerConnection::OnEmbed(ui::Window* root) {}
 
 void WindowManagerConnection::OnDidDestroyClient(ui::WindowTreeClient* client) {
   if (client_.get() == client) {
     client_.release();
   } else {
     DCHECK(!client_);
   }
 }
 
 void WindowManagerConnection::OnEventObserved(const ui::Event& event,
                                               ui::Window* target) {
   if (!event.IsLocatedEvent())
     return;
   Widget* target_widget = nullptr;
   if (target) {
     ui::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));
-  } else if (event.type() == ui::ET_TOUCH_PRESSED) {
-    FOR_EACH_OBSERVER(PointerWatcher, pointer_watchers_,
-                      OnTouchPressed(*event.AsTouchEvent(), location_in_screen,
-                                     target_widget));
+  if (HasPointerWatcher()) {
+    if (event.type() == ui::ET_MOUSE_PRESSED) {
+      FOR_EACH_OBSERVER(PointerWatcher, pointer_watchers_,
+                        OnMousePressed(*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));
+    }
+  } else {
+    DCHECK(HasTouchEventWatcher());
+    // Receives TouchEvent and TouchPointerEvent
+    if (event.IsTouchEvent() || event.IsTouchPointerEvent()) {

[sadrul, 2016/07/12 19:21:05]

DCHECK(IsTouchEvent() || IsTouchPointerEvent())

[riajiang, 2016/07/12 20:35:47]

Done.

[riajiang, 2016/07/13 20:03:08]

Changed both DCHECKs for (HasTouchEventWatcher()) and (event.IsTouchEvent() ||
event.IsTouchPointerEvent()) back to ifs. If we remove the watcher just after
receiving the event but observer is not updated on the server yet, the first
DCHECK would fail. For the second one, we want to just not send any events to
watchers when it's a non-supported event (e.g. MouseEvent) instead of failing
the DCHECK.

+      FOR_EACH_OBSERVER(
+          TouchEventWatcher, touch_event_watchers_,
+          OnTouchEventObserved(*event.AsLocatedEvent(), target_widget));
+    }
   }
 }
 
 void WindowManagerConnection::OnWindowManagerFrameValuesChanged() {
   if (client_)
     NativeWidgetMus::NotifyFrameChanged(client_.get());
 }
 
 gfx::Point WindowManagerConnection::GetCursorScreenPoint() {
   return client_->GetCursorScreenPoint();
 }
 
 }  // namespace views