Wires up WmShellMus::Add/RemovePointerWatcher

ash/mus/window_manager.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 "ash/mus/window_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 15 matching lines @@
 #include "services/ui/common/types.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/mus_constants.mojom.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "ui/app_list/presenter/app_list_presenter.h"
 #include "ui/base/hit_test.h"
 #include "ui/events/mojo/event.mojom.h"
+#include "ui/views/mus/pointer_watcher_event_router.h"
 #include "ui/views/mus/screen_mus.h"
 
 namespace ash {
 namespace mus {
 
 void AssertTrue(bool success) {
   DCHECK(success);
 }
 
 // TODO(jamescook): Port ash::sysui::AppListPresenterMus and eliminate this.
@@ skipping 24 matching lines @@
 
 WindowManager::~WindowManager() {
   // NOTE: |window_tree_client_| may already be null.
   delete window_tree_client_;
 }
 
 void WindowManager::Init(ui::WindowTreeClient* window_tree_client) {
   DCHECK(!window_tree_client_);
   window_tree_client_ = window_tree_client;
 
+  pointer_watcher_event_router_.reset(

[James Cook, 2016/08/12 16:08:53]

optional: MakeUnique?

[sky, 2016/08/12 17:59:37]

I tend to feel that having to create a temp just to assign is overkill. WDYT? By
that I mean this code becomes:

pointer_watcher_event_router_ =
base::MakeUnique<views::PointerWatcherEventRouter>(window_tree_client);

[James Cook, 2016/08/12 18:26:12]

OK, makes sense.

+      new views::PointerWatcherEventRouter(window_tree_client));
+
   shadow_controller_.reset(new ShadowController(window_tree_client));
 
   // The insets are roughly what is needed by CustomFrameView. The expectation
   // is at some point we'll write our own NonClientFrameView and get the insets
   // from it.
   ui::mojom::FrameDecorationValuesPtr frame_decoration_values =
       ui::mojom::FrameDecorationValues::New();
   const gfx::Insets client_area_insets =
       NonClientFrameController::GetPreferredClientAreaInsets();
   frame_decoration_values->normal_client_area_insets = client_area_insets;
   frame_decoration_values->maximized_client_area_insets = client_area_insets;
   frame_decoration_values->max_title_bar_button_width =
       NonClientFrameController::GetMaxTitleBarButtonWidth();
   window_manager_client_->SetFrameDecorationValues(
       std::move(frame_decoration_values));
 
   std::unique_ptr<ShellDelegate> shell_delegate(new ShellDelegateMus(
       base::MakeUnique<AppListPresenterStub>(), connector_));
-  shell_.reset(new WmShellMus(std::move(shell_delegate), this));
+  shell_.reset(new WmShellMus(std::move(shell_delegate), this,
+                              pointer_watcher_event_router_.get()));
   shell_->Initialize();
   lookup_.reset(new WmLookupMus);
 }
 
 void WindowManager::SetScreenLocked(bool is_locked) {
   // TODO: screen locked state needs to be persisted for newly added displays.
   for (auto& root_window_controller : root_window_controllers_) {
     WmWindowMus* non_lock_screen_containers_container =
         root_window_controller->GetWindowByShellWindowId(
             kShellWindowId_NonLockScreenContainersContainer);
@@ skipping 100 matching lines @@
   // |root_window_controllers_|.
   DCHECK(root_window_controllers_.empty());
 
   lookup_.reset();
   shell_.reset();
   shadow_controller_.reset();
 
   FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                     OnWindowTreeClientDestroyed());
 
+  pointer_watcher_event_router_.reset();
+
   window_tree_client_ = nullptr;
   window_manager_client_ = nullptr;
 }
 
 void WindowManager::OnPointerEventObserved(const ui::PointerEvent& event,
                                            ui::Window* target) {
-  // Does not use PointerWatchers.
+  pointer_watcher_event_router_->OnPointerEventObserved(event, target);
 }
 
 void WindowManager::SetWindowManagerClient(ui::WindowManagerClient* client) {
   window_manager_client_ = client;
 }
 
 bool WindowManager::OnWmSetBounds(ui::Window* window, gfx::Rect* bounds) {
   // TODO(sky): this indirectly sets bounds, which is against what
   // OnWmSetBounds() recommends doing. Remove that restriction, or fix this.
   WmWindowMus::Get(window)->SetBounds(*bounds);
@@ skipping 62 matching lines @@
                                                     const ui::Event& event) {
   auto iter = accelerator_handlers_.find(GetAcceleratorNamespaceId(id));
   if (iter == accelerator_handlers_.end())
     return ui::mojom::EventResult::HANDLED;
 
   return iter->second->OnAccelerator(id, event);
 }
 
 }  // namespace mus
 }  // namespace ash