Fix bug in keeping capture in sync during destruction

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 "services/service_manager/public/cpp/connector.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/focus_client.h"
 #include "ui/aura/client/transient_window_client.h"
+#include "ui/aura/mus/capture_synchronizer.h"
 #include "ui/aura/mus/drag_drop_controller_mus.h"
 #include "ui/aura/mus/in_flight_change.h"
 #include "ui/aura/mus/input_method_mus.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/surface_id_handler.h"
 #include "ui/aura/mus/window_manager_delegate.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
@@ skipping 112 matching lines @@
       delegate_(delegate),
       window_manager_delegate_(window_manager_delegate),
       binding_(this),
       tree_(nullptr),
       in_destructor_(false),
       weak_factory_(this) {
   // Allow for a null request in tests.
   if (request.is_pending())
     binding_.Bind(std::move(request));
   delegate_->GetFocusClient()->AddObserver(this);
-  delegate_->GetCaptureClient()->AddObserver(this);
   client::GetTransientWindowClient()->AddObserver(this);
   if (window_manager_delegate)
     window_manager_delegate->SetWindowManagerClient(this);
 }
 
 WindowTreeClient::~WindowTreeClient() {
   in_destructor_ = true;
 
   for (WindowTreeClientObserver& observer : observers_)
     observer.OnWillDestroyClient(this);
@@ skipping 14 matching lines @@
 
   // Delete the non-owned windows last. In the typical case these are roots. The
   // exception is the window manager and embed roots, which may know about
   // other random windows that it doesn't own.
   while (!tracker.windows().empty())
     delete tracker.windows().front();
 
   for (WindowTreeClientObserver& observer : observers_)
     observer.OnDidDestroyClient(this);
 
+  capture_synchronizer_.reset();
+
   client::GetTransientWindowClient()->RemoveObserver(this);
-  delegate_->GetCaptureClient()->RemoveObserver(this);
   delegate_->GetFocusClient()->RemoveObserver(this);
 }
 
 void WindowTreeClient::ConnectViaWindowTreeFactory(
     service_manager::Connector* connector) {
   // The client id doesn't really matter, we use 101 purely for debugging.
   client_id_ = 101;
 
   ui::mojom::WindowTreeFactoryPtr factory;
   connector->ConnectToInterface("service:ui", &factory);
@@ skipping 137 matching lines @@
   if (!focus_client)
     return;
 
   DCHECK(!setting_focus_);
   base::AutoReset<bool> focus_reset(&setting_focus_, true);
   base::AutoReset<WindowMus*> window_setting_focus_to_reset(
       &window_setting_focus_to_, window);
   focus_client->FocusWindow(window ? window->GetWindow() : nullptr);
 }
 
-void WindowTreeClient::SetCaptureFromServer(WindowMus* window) {
-  // In order for us to get here we had to have exposed a window, which implies
-  // we got a client.
-  DCHECK(tree_);
-  if (capture_window_ == window)
-    return;
-  DCHECK(!setting_capture_);
-  base::AutoReset<bool> capture_reset(&setting_capture_, true);
-  base::AutoReset<WindowMus*> window_setting_capture_to_reset(
-      &window_setting_capture_to_, window);
-  delegate_->GetCaptureClient()->SetCapture(window ? window->GetWindow()
-                                                   : nullptr);
-}
-
 InFlightChange* WindowTreeClient::GetOldestInFlightChangeMatching(
     const InFlightChange& change) {
   for (const auto& pair : in_flight_map_) {
     if (pair.second->window() == change.window() &&
         pair.second->change_type() == change.change_type() &&
         pair.second->Matches(change)) {
       return pair.second.get();
     }
   }
   return nullptr;
@@ skipping 118 matching lines @@
   window_mus->SetBoundsFromServer(window_data->bounds);
   if (parent)
     parent->AddChildFromServer(window_port_mus_ptr);
   if (window_data->visible)
     window_mus->SetVisibleFromServer(true);
   return window_port_mus_ptr;
 }
 
 void WindowTreeClient::SetWindowTree(ui::mojom::WindowTreePtr window_tree_ptr) {
   tree_ptr_ = std::move(window_tree_ptr);
-  tree_ = tree_ptr_.get();
-
-  drag_drop_controller_ = base::MakeUnique<DragDropControllerMus>(this, tree_);
-
+  WindowTreeConnectionEstablished(tree_ptr_.get());
   tree_ptr_->GetCursorLocationMemory(
       base::Bind(&WindowTreeClient::OnReceivedCursorLocationMemory,
                  weak_factory_.GetWeakPtr()));
 
   tree_ptr_.set_connection_error_handler(base::Bind(
       &WindowTreeClient::OnConnectionLost, weak_factory_.GetWeakPtr()));
 
   if (window_manager_delegate_) {
     tree_ptr_->GetWindowManagerClient(GetProxy(&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_, delegate_->GetCaptureClient());
+}
+
 void WindowTreeClient::OnConnectionLost() {
   delegate_->OnLostConnection(this);
 }
 
 bool WindowTreeClient::HandleInternalPropertyChanged(WindowMus* window,
                                                      const void* key) {
   if (key != client::kModalKey)
     return false;
 
   if (window->GetWindow()->GetProperty(client::kModalKey) ==
@@ skipping 12 matching lines @@
 }
 
 void WindowTreeClient::OnEmbedImpl(ui::mojom::WindowTree* window_tree,
                                    ClientSpecificId client_id,
                                    ui::mojom::WindowDataPtr root_data,
                                    int64_t display_id,
                                    Id focused_window_id,
                                    bool drawn) {
   // WARNING: this is only called if WindowTreeClient was created as the
   // result of an embedding.
-  tree_ = window_tree;
   client_id_ = client_id;
+  WindowTreeConnectionEstablished(window_tree);
 
   DCHECK(roots_.empty());
   Window* root = CreateWindowTreeHost(RootWindowType::EMBED, root_data,
                                       display_id, nullptr);
   // TODO: needs to deal with drawn and display_id.
 
   SetFocusFromServer(GetWindowByServerId(focused_window_id));
 
   delegate_->OnEmbed(root);
 }
@@ skipping 406 matching lines @@
   delete window;
 }
 
 void WindowTreeClient::OnCaptureChanged(Id new_capture_window_id,
                                         Id old_capture_window_id) {
   WindowMus* new_capture_window = GetWindowByServerId(new_capture_window_id);
   WindowMus* lost_capture_window = GetWindowByServerId(old_capture_window_id);
   if (!new_capture_window && !lost_capture_window)
     return;
 
-  InFlightCaptureChange change(this, new_capture_window);
+  InFlightCaptureChange change(this, capture_synchronizer_.get(),
+                               new_capture_window);
   if (ApplyServerChangeToExistingInFlightChange(change))
     return;
 
-  SetCaptureFromServer(new_capture_window);
+  capture_synchronizer_->SetCaptureFromServer(new_capture_window);
 }
 
 void WindowTreeClient::OnTopLevelCreated(uint32_t change_id,
                                          ui::mojom::WindowDataPtr data,
                                          int64_t display_id,
                                          bool drawn) {
   // The server ack'd the top level window we created and supplied the state
   // of the window at the time the server created it. For properties we do not
   // have changes in flight for we can update them immediately. For properties
   // with changes in flight we set the revert value from the server.
@@ skipping 142 matching lines @@
   if (window && relative_window && parent &&
       parent == WindowMus::Get(relative_window->GetWindow()->parent())) {
     parent->ReorderFromServer(window, relative_window, direction);
   }
 }
 
 void WindowTreeClient::OnWindowDeleted(Id window_id) {
   delete GetWindowByServerId(window_id)->GetWindow();
 }
 
-Window* WindowTreeClient::GetCaptureWindow() {
-  return capture_window_ ? capture_window_->GetWindow() : nullptr;
-}
-
 void WindowTreeClient::OnWindowVisibilityChanged(Id window_id, bool visible) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
   InFlightVisibleChange new_change(this, window, visible);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   SetWindowVisibleFromServer(window, visible);
@@ skipping 452 matching lines @@
     return;
   }
 
   const uint32_t change_id = ScheduleInFlightChange(
       base::MakeUnique<InFlightFocusChange>(this, focused_window_));
   focused_window_ = gained_focus_mus;
   tree_->SetFocus(change_id, focused_window_ ? focused_window_->server_id()
                                              : kInvalidServerId);
 }
 
-void WindowTreeClient::OnCaptureChanged(Window* lost_capture,
-                                        Window* gained_capture) {
-  WindowMus* gained_capture_mus = WindowMus::Get(gained_capture);
-  if (setting_capture_ && gained_capture_mus == window_setting_capture_to_) {
-    capture_window_ = gained_capture_mus;
-    return;
-  }
-
-  const uint32_t change_id = ScheduleInFlightChange(
-      base::MakeUnique<InFlightCaptureChange>(this, capture_window_));
-  WindowMus* old_capture_window = capture_window_;
-  capture_window_ = gained_capture_mus;
-  if (capture_window_)
-    tree_->SetCapture(change_id, capture_window_->server_id());
-  else
-    tree_->ReleaseCapture(change_id, old_capture_window->server_id());
-}
-
 void WindowTreeClient::SetRootWindowBounds(Window* window, gfx::Rect* bounds) {
   WindowTreeHostMus* window_tree_host = GetWindowTreeHostMus(window);
   switch (window_tree_host->root_window_type()) {
     case RootWindowType::EMBED:
       NOTREACHED();
       return;
     case RootWindowType::TOP_LEVEL:
       // Top level requests are always in display coordinates.
       break;
     case RootWindowType::DISPLAY: {
@@ skipping 38 matching lines @@
       ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
           child_mus, ChangeType::REMOVE_TRANSIENT_WINDOW_FROM_PARENT));
   tree_->RemoveTransientWindowFromParent(change_id, child_mus->server_id());
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForDrag(WindowMus* window) {
   return ScheduleInFlightChange(
       base::MakeUnique<InFlightDragChange>(window, ChangeType::DRAG_LOOP));
 }
 
+uint32_t WindowTreeClient::CreateChangeIdForCapture(WindowMus* window) {
+  return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
+      this, capture_synchronizer_.get(), window));
+}
+
 }  // namespace aura