Change CaptureSynchronizer and PointerWatcherEventRouter to support multiple CaptureClients.

ui/views/mus/pointer_watcher_event_router.cc

 // Copyright 2016 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/pointer_watcher_event_router.h"
 
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/mus/window_tree_client.h"
 #include "ui/aura/window.h"
 #include "ui/display/screen.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/events/event.h"
 #include "ui/views/pointer_watcher.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 
 namespace views {
 namespace {
 
 bool HasPointerWatcher(
     base::ObserverList<views::PointerWatcher, true>* observer_list) {
   return observer_list->begin() != observer_list->end();
 }
 
 }  // namespace
 
 PointerWatcherEventRouter::PointerWatcherEventRouter(
     aura::WindowTreeClient* window_tree_client)
     : window_tree_client_(window_tree_client) {
   window_tree_client->AddObserver(this);
-  window_tree_client_->GetCaptureClient()->AddObserver(this);
 }
 
 PointerWatcherEventRouter::~PointerWatcherEventRouter() {
-  if (window_tree_client_) {
+  if (window_tree_client_)
     window_tree_client_->RemoveObserver(this);
-    window_tree_client_->GetCaptureClient()->RemoveObserver(this);
-  }
 }
 
 void PointerWatcherEventRouter::AddPointerWatcher(PointerWatcher* watcher,
                                                   bool wants_moves) {
   // Pointer watchers cannot be added multiple times.
   DCHECK(!move_watchers_.HasObserver(watcher));
   DCHECK(!non_move_watchers_.HasObserver(watcher));
   if (wants_moves) {
     move_watchers_.AddObserver(watcher);
     if (event_types_ != EventTypes::MOVE_EVENTS) {
@@ skipping 77 matching lines @@
                                     target_widget);
   }
   if (event.type() != ui::ET_POINTER_MOVED) {
     for (PointerWatcher& observer : non_move_watchers_) {
       observer.OnPointerEventObserved(updated_event, location_in_screen,
                                       target_widget);
     }
   }
 }
 
+void PointerWatcherEventRouter::AttachToCaptureClient(
+    aura::client::CaptureClient* capture_client) {
+  capture_client->AddObserver(this);
+}
+
+void PointerWatcherEventRouter::DetachFromCaptureClient(
+    aura::client::CaptureClient* capture_client) {
+  capture_client->RemoveObserver(this);
+}
+
 PointerWatcherEventRouter::EventTypes
 PointerWatcherEventRouter::DetermineEventTypes() {
   if (HasPointerWatcher(&move_watchers_))
     return EventTypes::MOVE_EVENTS;
 
   if (HasPointerWatcher(&non_move_watchers_))
     return EventTypes::NON_MOVE_EVENTS;
 
   return EventTypes::NONE;
 }
 
 void PointerWatcherEventRouter::OnCaptureChanged(aura::Window* lost_capture,
                                                  aura::Window* gained_capture) {
   const ui::MouseEvent mouse_event(ui::ET_MOUSE_CAPTURE_CHANGED, gfx::Point(),
                                    gfx::Point(), ui::EventTimeForNow(), 0, 0);
   const ui::PointerEvent event(mouse_event);
   gfx::Point location_in_screen =
       display::Screen::GetScreen()->GetCursorScreenPoint();
   for (PointerWatcher& observer : move_watchers_)
     observer.OnPointerEventObserved(event, location_in_screen, nullptr);
   for (PointerWatcher& observer : non_move_watchers_)
     observer.OnPointerEventObserved(event, location_in_screen, nullptr);
 }
 
 void PointerWatcherEventRouter::OnDidDestroyClient(
     aura::WindowTreeClient* client) {
   // We expect that all observers have been removed by this time.
   DCHECK_EQ(event_types_, EventTypes::NONE);
   DCHECK_EQ(client, window_tree_client_);
-  window_tree_client_->GetCaptureClient()->RemoveObserver(this);
   window_tree_client_->RemoveObserver(this);
   window_tree_client_ = nullptr;

[sadrul, 2017/01/30 19:37:58]

It would make sense to continue to RemoveObserver from |client|.

[riajiang, 2017/01/30 20:24:09]

I thought that by the time the WindowTreeClient is being destroyed, the
PointerWatcherEventRouter should have already removed itself as an observer for
all the CaptureClients (when DesktopWindowTreeHostMus gets closed and when
WindowManager gets shut down)? And now that we don't just have one capture
client anymore, we can't get the one capture client from WindowTreeClient?

[sadrul, 2017/01/30 20:52:12]

Oh yeah, of course. You are right.

 }
 
 }  // namespace views