Change CaptureSynchronizer and PointerWatcherEventRouter to support multiple CaptureClients.

ui/aura/mus/window_tree_client.cc

 // Copyright 2014 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/aura/mus/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "mojo/public/cpp/bindings/map.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/common/accelerator_util.h"
 #include "services/ui/public/cpp/gpu/gpu.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/interfaces/constants.mojom.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "services/ui/public/interfaces/window_manager_window_tree_factory.mojom.h"
 #include "ui/aura/client/aura_constants.h"
+#include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/mus/capture_synchronizer.h"
 #include "ui/aura/mus/drag_drop_controller_mus.h"
 #include "ui/aura/mus/focus_synchronizer.h"
 #include "ui/aura/mus/in_flight_change.h"
 #include "ui/aura/mus/input_method_mus.h"
 #include "ui/aura/mus/mus_context_factory.h"
 #include "ui/aura/mus/property_converter.h"
@@ skipping 425 matching lines @@
     tree_ptr_->GetWindowManagerClient(MakeRequest(
         &window_manager_internal_client_, tree_ptr_.associated_group()));
   }
 }
 
 void WindowTreeClient::WindowTreeConnectionEstablished(
     ui::mojom::WindowTree* window_tree) {
   tree_ = window_tree;
 
   drag_drop_controller_ = base::MakeUnique<DragDropControllerMus>(this, tree_);
-  capture_synchronizer_ =
-      base::MakeUnique<CaptureSynchronizer>(this, tree_, GetCaptureClient());
+  capture_synchronizer_ = base::MakeUnique<CaptureSynchronizer>(this, tree_);
   focus_synchronizer_ = base::MakeUnique<FocusSynchronizer>(this, tree_);
 }
 
 void WindowTreeClient::OnConnectionLost() {
   delegate_->OnLostConnection(this);
 }
 
 bool WindowTreeClient::HandleInternalPropertyChanged(WindowMus* window,
                                                      const void* key) {
   if (key != client::kModalKey)
@@ skipping 340 matching lines @@
       base::MakeUnique<InFlightDragChange>(window_mus, ChangeType::MOVE_LOOP));
   // Tell the window manager to take over moving us.
   tree_->PerformWindowMove(current_move_loop_change_, window_mus->server_id(),
                            source, cursor_location);
 }
 
 void WindowTreeClient::CancelWindowMove(Window* window) {
   tree_->CancelWindowMove(WindowMus::Get(window)->server_id());
 }
 
+void WindowTreeClient::OnCaptureClientSet(
+    client::CaptureClient* capture_client) {
+  capture_client->AddObserver(capture_synchronizer_.get());
+}
+
+void WindowTreeClient::OnCaptureClientUnset(
+    client::CaptureClient* capture_client) {
+  capture_synchronizer_->SetCaptureWindow(nullptr);
+  capture_client->RemoveObserver(capture_synchronizer_.get());

[sadrul, 2017/01/27 01:06:53]

Can this be replaced by adding functions on CaptureSynchronizer instead? e.g. in
OnCaptureClientSet() above:

  capture_synchronizer_->AttachToCaptureClient(capture_client);

and here:

  capture_synchronizer_->DetachFromCaptureClient(capture_client);

The CaptureSynchronizer can take care of updating its internal state, instead of
having to do that from here (the call to SetCaptureWindow(nullptr))

+}
+
 void WindowTreeClient::AddObserver(WindowTreeClientObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowTreeClient::RemoveObserver(WindowTreeClientObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WindowTreeClient::AddTestObserver(WindowTreeClientTestObserver* observer) {
   test_observers_.AddObserver(observer);
@@ skipping 981 matching lines @@
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForFocus(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightFocusChange>(
       this, focus_synchronizer_.get(), window));
 }
 
 }  // namespace aura