Change CaptureSynchronizer and PointerWatcherEventRouter to support multiple CaptureClients.

ui/aura/mus/capture_synchronizer.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/aura/mus/capture_synchronizer.h"
 
 #include "base/auto_reset.h"
 #include "services/ui/public/interfaces/window_tree.mojom.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/mus/capture_synchronizer_delegate.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/window.h"
+#include "ui/aura/window_property.h"
 
 namespace aura {
 
 CaptureSynchronizer::CaptureSynchronizer(CaptureSynchronizerDelegate* delegate,
-                                         ui::mojom::WindowTree* window_tree,
-                                         client::CaptureClient* capture_client)
-    : delegate_(delegate),
-      window_tree_(window_tree),
-      capture_client_(capture_client) {
-  capture_client_->AddObserver(this);
-}
+                                         ui::mojom::WindowTree* window_tree)
+    : delegate_(delegate), window_tree_(window_tree) {}
 
-CaptureSynchronizer::~CaptureSynchronizer() {
-  SetCaptureWindow(nullptr);
-  capture_client_->RemoveObserver(this);
-}
+CaptureSynchronizer::~CaptureSynchronizer() {}
 
 void CaptureSynchronizer::SetCaptureFromServer(WindowMus* window) {
   if (window == capture_window_)
     return;
 
   DCHECK(!setting_capture_);
-  // Don't immediately set |capture_client_|. It's possible the change will be
+  // Don't immediately set capture client. It's possible the change will be
   // rejected.
   base::AutoReset<bool> capture_reset(&setting_capture_, true);
   base::AutoReset<WindowMus*> window_setting_capture_to_reset(
       &window_setting_capture_to_, window);
-  capture_client_->SetCapture(window ? window->GetWindow() : nullptr);
+  client::CaptureClient* capture_client =
+      window ? client::GetCaptureClient(window->GetWindow()->GetRootWindow())
+             : client::GetCaptureClient(
+                   capture_window_->GetWindow()->GetRootWindow());
+  capture_client->SetCapture(window ? window->GetWindow() : nullptr);
+}
+
+void CaptureSynchronizer::Attach(client::CaptureClient* capture_client) {
+  if (capture_client)
+    capture_client->AddObserver(this);
 }
 
 void CaptureSynchronizer::SetCaptureWindow(WindowMus* window) {
   if (capture_window_)
     capture_window_->GetWindow()->RemoveObserver(this);
   capture_window_ = window;
-  if (capture_window_)
+  if (capture_window_ && !capture_window_->GetWindow()->HasObserver(this))
     capture_window_->GetWindow()->AddObserver(this);
 }
 
+void CaptureSynchronizer::OnWindowPropertyChanged(Window* window,
+                                                  const void* key,
+                                                  intptr_t old) {
+  if (key == client::kRootWindowCaptureClientKey)
+    Attach(client::GetCaptureClient(window));

[sadrul, 2017/01/18 22:14:44]

So, this sort of suck a little bit. I know this is what we suggested when
talking offline. But can you think of something better? like, maybe the
CaptureSynchronizer can be created *after* we know that the window has a
capture-client set?

[riajiang, 2017/01/20 20:14:28]

As discussed offline, CaptureSynchronizer has to be created before windows and
their capture clients get created so updated the approach to be (still similar
to previous approach): handling capture client setting as a special case in
WindowTreeClient::HandleInternalPropertyChanged and then attach
CaptureSynchronizer as the observer for that capture client.

+}
+
 void CaptureSynchronizer::OnWindowDestroying(Window* window) {
   // The CaptureClient implementation handles resetting capture when a window
   // is destroyed, but because of observer ordering this may be called first.
-  DCHECK_EQ(window, capture_window_->GetWindow());
-  SetCaptureWindow(nullptr);
+  if (capture_window_) {
+    DCHECK_EQ(window, capture_window_->GetWindow());
+    SetCaptureWindow(nullptr);
+  }
   // The server will release capture when a window is destroyed, so no need
   // explicitly schedule a change.
 }
 
 void CaptureSynchronizer::OnCaptureChanged(Window* lost_capture,
                                            Window* gained_capture) {
   if (!gained_capture && !capture_window_)
     return;  // Happens if the window is deleted during notification.
 
   WindowMus* gained_capture_mus = WindowMus::Get(gained_capture);
   if (setting_capture_ && gained_capture_mus == window_setting_capture_to_) {
     SetCaptureWindow(gained_capture_mus);
     return;
   }
 
   const uint32_t change_id =
       delegate_->CreateChangeIdForCapture(capture_window_);
   WindowMus* old_capture_window = capture_window_;
   SetCaptureWindow(gained_capture_mus);
   if (capture_window_)
     window_tree_->SetCapture(change_id, capture_window_->server_id());
   else
     window_tree_->ReleaseCapture(change_id, old_capture_window->server_id());
 }
 
 }  // namespace aura