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;
 }
 
 }  // namespace views