Changes ownership of ClientConnection

components/mus/ws/window_tree_impl.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 "components/mus/ws/window_tree_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 52 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TargetedEvent);
 };
 
 WindowTreeImpl::WindowTreeImpl(ConnectionManager* connection_manager,
                                ServerWindow* root,
                                uint32_t policy_bitmask)
     : connection_manager_(connection_manager),
       id_(connection_manager_->GetAndAdvanceNextConnectionId()),
       next_window_id_(1),
-      client_(nullptr),
       event_ack_id_(0),
       event_source_host_(nullptr),
       is_embed_root_(false),
       window_manager_internal_(nullptr) {
   if (root)
     roots_.insert(root);
   // TODO(sky): pass in type rather than inferring it.
   if (root && root->id().connection_id == kInvalidConnectionId) {
     access_policy_.reset(new WindowManagerAccessPolicy(id_, this));
     is_embed_root_ = true;
   } else {
     access_policy_.reset(new DefaultAccessPolicy(id_, this));
     is_embed_root_ = (policy_bitmask & WindowTree::kAccessPolicyEmbedRoot) != 0;
   }
 }
 
 WindowTreeImpl::~WindowTreeImpl() {
   DestroyWindows();
 }
 
-void WindowTreeImpl::Init(mojom::WindowTreeClient* client,
+void WindowTreeImpl::Init(scoped_ptr<ClientConnection> client_connection,
                           mojom::WindowTreePtr tree) {
-  DCHECK(!client_);
-  client_ = client;
+  DCHECK(!client_connection_);
+  client_connection_ = std::move(client_connection);
 
   if (roots_.empty())
     return;
 
   std::vector<const ServerWindow*> to_send;
   CHECK_EQ(1u, roots_.size());
   GetUnknownWindowsFrom(*roots_.begin(), &to_send);
 
   WindowTreeHostImpl* host = GetHost(*roots_.begin());
   const ServerWindow* focused_window =
       host ? host->GetFocusedWindow() : nullptr;
   if (focused_window)
     focused_window = access_policy_->GetWindowForFocusChange(focused_window);
   ClientWindowId focused_window_id;
   if (focused_window)
     IsWindowKnown(focused_window, &focused_window_id);
 
-  client->OnEmbed(id_, WindowToWindowData(to_send.front()), std::move(tree),
-                  focused_window_id.id,
-                  is_embed_root_ ? WindowTree::kAccessPolicyEmbedRoot
-                                 : WindowTree::kAccessPolicyDefault);
+  client()->OnEmbed(id_, WindowToWindowData(to_send.front()), std::move(tree),
+                    focused_window_id.id,
+                    is_embed_root_ ? WindowTree::kAccessPolicyEmbedRoot
+                                   : WindowTree::kAccessPolicyDefault);
 }
 
 void WindowTreeImpl::ConfigureWindowManager() {
   DCHECK(!window_manager_internal_);
-  window_manager_internal_ =
-      connection_manager_->GetClientConnection(this)->GetWindowManager();
+  window_manager_internal_ = client_connection_->GetWindowManager();
 }
 
 const ServerWindow* WindowTreeImpl::GetWindow(const WindowId& id) const {
   if (id_ == id.connection_id) {
     auto iter = created_window_map_.find(id);
     return iter == created_window_map_.end() ? nullptr : iter->second;
   }
   return connection_manager_->GetWindow(id);
 }
 
@@ skipping 26 matching lines @@
                 : nullptr;
 }
 
 void WindowTreeImpl::OnWindowDestroyingTreeImpl(WindowTreeImpl* connection) {
   // Notify our client if |connection| was embedded in any of our views.
   for (const auto* connection_root : connection->roots_) {
     const bool owns_connection_root =
         connection_root->id().connection_id == id_;
     if (owns_connection_root ||
         (is_embed_root_ && IsWindowKnown(connection_root))) {
-      client_->OnEmbeddedAppDisconnected(
+      client()->OnEmbeddedAppDisconnected(
           ClientWindowIdForWindow(connection_root).id);
     }
   }
 }
 
 void WindowTreeImpl::OnWillDestroyWindowTreeHost(
     WindowTreeHostImpl* tree_host) {
   if (event_source_host_ == tree_host)
     event_source_host_ = nullptr;
 }
 
 void WindowTreeImpl::NotifyChangeCompleted(
     uint32_t change_id,
     mojom::WindowManagerErrorCode error_code) {
-  client_->OnChangeCompleted(
+  client()->OnChangeCompleted(
       change_id, error_code == mojom::WindowManagerErrorCode::SUCCESS);
 }
 
 bool WindowTreeImpl::NewWindow(
     const ClientWindowId& client_window_id,
     const std::map<std::string, std::vector<uint8_t>>& properties) {
   if (!IsValidIdForNewWindow(client_window_id))
     return false;
   const WindowId window_id = GenerateNewWindowId();
   DCHECK(!GetWindow(window_id));
@@ skipping 98 matching lines @@
          waiting_for_top_level_window_info_->wm_change_id == wm_change_id;
 }
 
 void WindowTreeImpl::OnWindowManagerCreatedTopLevelWindow(
     uint32_t wm_change_id,
     uint32_t client_change_id,
     const ServerWindow* window) {
   DCHECK(IsWaitingForNewTopLevelWindow(wm_change_id));
   scoped_ptr<WaitingForTopLevelWindowInfo> waiting_for_top_level_window_info(
       std::move(waiting_for_top_level_window_info_));
-  connection_manager_->GetClientConnection(this)
-      ->SetIncomingMethodCallProcessingPaused(false);
+  client_connection_->SetIncomingMethodCallProcessingPaused(false);
   // We were paused, so the id should still be valid.
   DCHECK(IsValidIdForNewWindow(
       waiting_for_top_level_window_info->client_window_id));
   client_id_to_window_id_map_[waiting_for_top_level_window_info
                                   ->client_window_id] = window->id();
   window_id_to_client_id_map_[window->id()] =
       waiting_for_top_level_window_info->client_window_id;
   roots_.insert(window);
-  client_->OnTopLevelCreated(client_change_id, WindowToWindowData(window));
+  client()->OnTopLevelCreated(client_change_id, WindowToWindowData(window));
 }
 
 void WindowTreeImpl::OnChangeCompleted(uint32_t change_id, bool success) {
-  client_->OnChangeCompleted(change_id, success);
+  client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTreeImpl::OnAccelerator(uint32_t accelerator_id,
                                    mojom::EventPtr event) {
   DCHECK(window_manager_internal_);
   window_manager_internal_->OnAccelerator(accelerator_id, std::move(event));
 }
 
 void WindowTreeImpl::ProcessWindowBoundsChanged(const ServerWindow* window,
                                                 const gfx::Rect& old_bounds,
                                                 const gfx::Rect& new_bounds,
                                                 bool originated_change) {
   ClientWindowId client_window_id;
   if (originated_change || !IsWindowKnown(window, &client_window_id))
     return;
-  client_->OnWindowBoundsChanged(client_window_id.id, Rect::From(old_bounds),
-                                 Rect::From(new_bounds));
+  client()->OnWindowBoundsChanged(client_window_id.id, Rect::From(old_bounds),
+                                  Rect::From(new_bounds));
 }
 
 void WindowTreeImpl::ProcessClientAreaChanged(
     const ServerWindow* window,
     const gfx::Insets& new_client_area,
     const std::vector<gfx::Rect>& new_additional_client_areas,
     bool originated_change) {
   ClientWindowId client_window_id;
   if (originated_change || !IsWindowKnown(window, &client_window_id))
     return;
-  client_->OnClientAreaChanged(
+  client()->OnClientAreaChanged(
       client_window_id.id, mojo::Insets::From(new_client_area),
       mojo::Array<mojo::RectPtr>::From(new_additional_client_areas));
 }
 
 void WindowTreeImpl::ProcessViewportMetricsChanged(
     WindowTreeHostImpl* host,
     const mojom::ViewportMetrics& old_metrics,
     const mojom::ViewportMetrics& new_metrics,
     bool originated_change) {
   mojo::Array<Id> window_ids;
   for (const ServerWindow* root : roots_) {
     if (GetHost(root) == host) {
       ClientWindowId client_window_id;
       const bool known = IsWindowKnown(root, &client_window_id);
       DCHECK(known);
       window_ids.push_back(client_window_id.id);
     }
   }
   if (window_ids.size() == 0u)
     return;
 
-  client_->OnWindowViewportMetricsChanged(
+  client()->OnWindowViewportMetricsChanged(
       std::move(window_ids), old_metrics.Clone(), new_metrics.Clone());
 }
 
 void WindowTreeImpl::ProcessWillChangeWindowHierarchy(
     const ServerWindow* window,
     const ServerWindow* new_parent,
     const ServerWindow* old_parent,
     bool originated_change) {
   if (originated_change)
     return;
@@ skipping 16 matching lines @@
     return;
 
   ClientWindowId client_window_id;
   if (!IsWindowKnown(window, &client_window_id))
     return;
 
   Array<uint8_t> data(nullptr);
   if (new_data)
     data = Array<uint8_t>::From(*new_data);
 
-  client_->OnWindowSharedPropertyChanged(client_window_id.id, String(name),
-                                         std::move(data));
+  client()->OnWindowSharedPropertyChanged(client_window_id.id, String(name),
+                                          std::move(data));
 }
 
 void WindowTreeImpl::ProcessWindowHierarchyChanged(
     const ServerWindow* window,
     const ServerWindow* new_parent,
     const ServerWindow* old_parent,
     bool originated_change) {
   const bool knows_new = new_parent && IsWindowKnown(new_parent);
   if (originated_change && !IsWindowKnown(window) && knows_new) {
     std::vector<const ServerWindow*> unused;
@@ skipping 18 matching lines @@
   const bool knows_old = old_parent && IsWindowKnown(old_parent);
   if (!knows_old && !knows_new)
     return;
 
   const ClientWindowId new_parent_client_window_id =
       knows_new ? ClientWindowIdForWindow(new_parent) : ClientWindowId();
   const ClientWindowId old_parent_client_window_id =
       knows_old ? ClientWindowIdForWindow(old_parent) : ClientWindowId();
   const ClientWindowId client_window_id =
       window ? ClientWindowIdForWindow(window) : ClientWindowId();
-  client_->OnWindowHierarchyChanged(
+  client()->OnWindowHierarchyChanged(
       client_window_id.id, new_parent_client_window_id.id,
       old_parent_client_window_id.id, WindowsToWindowDatas(to_send));
   connection_manager_->OnConnectionMessagedClient(id_);
 }
 
 void WindowTreeImpl::ProcessWindowReorder(const ServerWindow* window,
                                           const ServerWindow* relative_window,
                                           mojom::OrderDirection direction,
                                           bool originated_change) {
   DCHECK_EQ(window->parent(), relative_window->parent());
   ClientWindowId client_window_id, relative_client_window_id;
   if (originated_change || !IsWindowKnown(window, &client_window_id) ||
       !IsWindowKnown(relative_window, &relative_client_window_id) ||
       connection_manager_->DidConnectionMessageClient(id_))
     return;
 
   // Do not notify ordering changes of the root windows, since the client
   // doesn't know about the ancestors of the roots, and so can't do anything
   // about this ordering change of the root.
   if (HasRoot(window) || HasRoot(relative_window))
     return;
 
-  client_->OnWindowReordered(client_window_id.id, relative_client_window_id.id,
-                             direction);
+  client()->OnWindowReordered(client_window_id.id, relative_client_window_id.id,
+                              direction);
   connection_manager_->OnConnectionMessagedClient(id_);
 }
 
 void WindowTreeImpl::ProcessWindowDeleted(const ServerWindow* window,
                                           bool originated_change) {
   if (window->id().connection_id == id_)
     created_window_map_.erase(window->id());
 
   ClientWindowId client_window_id;
   if (!IsWindowKnown(window, &client_window_id))
     return;
 
   if (HasRoot(window))
     RemoveRoot(window, RemoveRootReason::DELETED);
   else
     RemoveFromMaps(window);
 
   if (originated_change)
     return;
 
-  client_->OnWindowDeleted(client_window_id.id);
+  client()->OnWindowDeleted(client_window_id.id);
   connection_manager_->OnConnectionMessagedClient(id_);
 }
 
 void WindowTreeImpl::ProcessWillChangeWindowVisibility(
     const ServerWindow* window,
     bool originated_change) {
   if (originated_change)
     return;
 
   ClientWindowId client_window_id;
   if (IsWindowKnown(window, &client_window_id)) {
-    client_->OnWindowVisibilityChanged(client_window_id.id, !window->visible());
+    client()->OnWindowVisibilityChanged(client_window_id.id,
+                                        !window->visible());
     return;
   }
 
   bool window_target_drawn_state;
   if (window->visible()) {
     // Window is being hidden, won't be drawn.
     window_target_drawn_state = false;
   } else {
     // Window is being shown. Window will be drawn if its parent is drawn.
     window_target_drawn_state = window->parent() && window->parent()->IsDrawn();
   }
 
   NotifyDrawnStateChanged(window, window_target_drawn_state);
 }
 
 void WindowTreeImpl::ProcessCursorChanged(const ServerWindow* window,
                                           int32_t cursor_id,
                                           bool originated_change) {
   if (originated_change)
     return;
   ClientWindowId client_window_id;
   if (!IsWindowKnown(window, &client_window_id))
     return;
 
-  client_->OnWindowPredefinedCursorChanged(client_window_id.id,
-                                           mojom::Cursor(cursor_id));
+  client()->OnWindowPredefinedCursorChanged(client_window_id.id,
+                                            mojom::Cursor(cursor_id));
 }
 
 void WindowTreeImpl::ProcessFocusChanged(
     const ServerWindow* old_focused_window,
     const ServerWindow* new_focused_window) {
   const ServerWindow* window =
       new_focused_window
           ? access_policy_->GetWindowForFocusChange(new_focused_window)
           : nullptr;
   ClientWindowId client_window_id;
   // If the window isn't known we'll supply null, which is ok.
   IsWindowKnown(window, &client_window_id);
   // TODO(sky): this should only notify if this results in a change of focus
   // for the client.
-  client_->OnWindowFocused(client_window_id.id);
+  client()->OnWindowFocused(client_window_id.id);
 }
 
 void WindowTreeImpl::ProcessTransientWindowAdded(
     const ServerWindow* window,
     const ServerWindow* transient_window,
     bool originated_change) {
   if (originated_change)
     return;
 
   ClientWindowId client_window_id, transient_client_window_id;
   if (!IsWindowKnown(window, &client_window_id) ||
       !IsWindowKnown(transient_window, &transient_client_window_id)) {
     return;
   }
-  client_->OnTransientWindowAdded(client_window_id.id,
-                                  transient_client_window_id.id);
+  client()->OnTransientWindowAdded(client_window_id.id,
+                                   transient_client_window_id.id);
 }
 
 void WindowTreeImpl::ProcessTransientWindowRemoved(
     const ServerWindow* window,
     const ServerWindow* transient_window,
     bool originated_change) {
   if (originated_change)
     return;
   ClientWindowId client_window_id, transient_client_window_id;
   if (!IsWindowKnown(window, &client_window_id) ||
       !IsWindowKnown(transient_window, &transient_client_window_id)) {
     return;
   }
-  client_->OnTransientWindowRemoved(client_window_id.id,
-                                    transient_client_window_id.id);
+  client()->OnTransientWindowRemoved(client_window_id.id,
+                                     transient_client_window_id.id);
 }
 
 WindowTreeHostImpl* WindowTreeImpl::GetHostForWindowManager() {
   // The WindowTreeImpl for the wm has one and only one root.
   CHECK_EQ(1u, roots_.size());
 
   // Indicates this connection is for the wm.
   DCHECK(window_manager_internal_);
 
   WindowTreeHostImpl* host = GetHost(*roots_.begin());
@@ skipping 153 matching lines @@
   DCHECK(roots_.count(window) > 0);
   roots_.erase(window);
 
   const ClientWindowId client_window_id(ClientWindowIdForWindow(window));
 
   // No need to do anything if we created the window.
   if (window->id().connection_id == id_)
     return;
 
   if (reason == RemoveRootReason::EMBED) {
-    client_->OnUnembed(client_window_id.id);
-    client_->OnWindowDeleted(client_window_id.id);
+    client()->OnUnembed(client_window_id.id);
+    client()->OnWindowDeleted(client_window_id.id);
     connection_manager_->OnConnectionMessagedClient(id_);
   }
 
   // This connection no longer knows about the window. Unparent any windows that
   // were parented to windows in the root.
   std::vector<ServerWindow*> local_windows;
   RemoveFromKnown(window, &local_windows);
   for (size_t i = 0; i < local_windows.size(); ++i)
     local_windows[i]->parent()->Remove(local_windows[i]);
 }
@@ skipping 49 matching lines @@
 
 void WindowTreeImpl::NotifyDrawnStateChanged(const ServerWindow* window,
                                              bool new_drawn_value) {
   // Even though we don't know about window, it may be an ancestor of our root,
   // in which case the change may effect our roots drawn state.
   if (roots_.empty())
     return;
 
   for (auto* root : roots_) {
     if (window->Contains(root) && (new_drawn_value != root->IsDrawn())) {
-      client_->OnWindowDrawnStateChanged(ClientWindowIdForWindow(root).id,
-                                         new_drawn_value);
+      client()->OnWindowDrawnStateChanged(ClientWindowIdForWindow(root).id,
+                                          new_drawn_value);
     }
   }
 }
 
 void WindowTreeImpl::DestroyWindows() {
   if (created_window_map_.empty())
     return;
 
   Operation op(this, connection_manager_, OperationType::DELETE_WINDOW);
   // If we get here from the destructor we're not going to get
@@ skipping 44 matching lines @@
                                             mojom::EventPtr event) {
   DCHECK(!event_ack_id_);
   // We do not want to create a sequential id for each event, because that can
   // leak some information to the client. So instead, manufacture the id from
   // the event pointer.
   event_ack_id_ =
       0x1000000 | (reinterpret_cast<uintptr_t>(event.get()) & 0xffffff);
   event_source_host_ = GetHost(target);
   // Should only get events from windows attached to a host.
   DCHECK(event_source_host_);
-  client_->OnWindowInputEvent(event_ack_id_, ClientWindowIdForWindow(target).id,
-                              std::move(event));
+  client()->OnWindowInputEvent(
+      event_ack_id_, ClientWindowIdForWindow(target).id, std::move(event));
 }
 
 void WindowTreeImpl::NewWindow(
     uint32_t change_id,
     Id transport_window_id,
     mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
   std::map<std::string, std::vector<uint8_t>> properties;
   if (!transport_properties.is_null()) {
     properties =
         transport_properties.To<std::map<std::string, std::vector<uint8_t>>>();
   }
-  client_->OnChangeCompleted(
+  client()->OnChangeCompleted(
       change_id, NewWindow(ClientWindowId(transport_window_id), properties));
 }
 
 void WindowTreeImpl::NewTopLevelWindow(
     uint32_t change_id,
     Id transport_window_id,
     mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
   DCHECK(!waiting_for_top_level_window_info_);
   const ClientWindowId client_window_id(transport_window_id);
   WindowTreeHostImpl* tree_host =
       connection_manager_->GetActiveWindowTreeHost();
   // TODO(sky): need a way for client to provide context.
   WindowManagerState* wms =
       tree_host ? tree_host->GetFirstWindowManagerState() : nullptr;
   if (!wms || wms->tree() == this || !IsValidIdForNewWindow(client_window_id)) {
-    client_->OnChangeCompleted(change_id, false);
+    client()->OnChangeCompleted(change_id, false);
     return;
   }
 
   // The server creates the real window. Any further messages from the client
   // may try to alter the window. Pause incoming messages so that we know we
   // can't get a message for a window before the window is created. Once the
   // window is created we'll resume processing.
-  connection_manager_->GetClientConnection(this)
-      ->SetIncomingMethodCallProcessingPaused(true);
+  client_connection_->SetIncomingMethodCallProcessingPaused(true);
 
   const uint32_t wm_change_id =
       connection_manager_->GenerateWindowManagerChangeId(this, change_id);
 
   waiting_for_top_level_window_info_.reset(
       new WaitingForTopLevelWindowInfo(client_window_id, wm_change_id));
 
   wms->tree()->window_manager_internal_->WmCreateTopLevelWindow(
       wm_change_id, std::move(transport_properties));
 }
 
 void WindowTreeImpl::DeleteWindow(uint32_t change_id, Id transport_window_id) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   bool success = false;
   bool should_close = window && (access_policy_->CanDeleteWindow(window) ||
                                  ShouldRouteToWindowManager(window));
   if (should_close) {
     WindowTreeImpl* connection =
         connection_manager_->GetConnection(window->id().connection_id);
     success = connection && connection->DeleteWindowImpl(this, window);
   }
-  client_->OnChangeCompleted(change_id, success);
+  client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTreeImpl::AddWindow(uint32_t change_id, Id parent_id, Id child_id) {
-  client_->OnChangeCompleted(change_id, AddWindow(ClientWindowId(parent_id),
-                                                  ClientWindowId(child_id)));
+  client()->OnChangeCompleted(change_id, AddWindow(ClientWindowId(parent_id),
+                                                   ClientWindowId(child_id)));
 }
 
 void WindowTreeImpl::RemoveWindowFromParent(uint32_t change_id, Id window_id) {
   bool success = false;
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   if (window && window->parent() &&
       access_policy_->CanRemoveWindowFromParent(window)) {
     success = true;
     Operation op(this, connection_manager_,
                  OperationType::REMOVE_WINDOW_FROM_PARENT);
     window->parent()->Remove(window);
   }
-  client_->OnChangeCompleted(change_id, success);
+  client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTreeImpl::AddTransientWindow(uint32_t change_id,
                                         Id window,
                                         Id transient_window) {
-  client_->OnChangeCompleted(
+  client()->OnChangeCompleted(
       change_id, AddTransientWindow(ClientWindowId(window),
                                     ClientWindowId(transient_window)));
 }
 
 void WindowTreeImpl::RemoveTransientWindowFromParent(uint32_t change_id,
                                                      Id transient_window_id) {
   bool success = false;
   ServerWindow* transient_window =
       GetWindowByClientId(ClientWindowId(transient_window_id));
   if (transient_window && transient_window->transient_parent() &&
       access_policy_->CanRemoveTransientWindowFromParent(transient_window)) {
     success = true;
     Operation op(this, connection_manager_,
                  OperationType::REMOVE_TRANSIENT_WINDOW_FROM_PARENT);
     transient_window->transient_parent()->RemoveTransientWindow(
         transient_window);
   }
-  client_->OnChangeCompleted(change_id, success);
+  client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTreeImpl::ReorderWindow(uint32_t change_id,
                                    Id window_id,
                                    Id relative_window_id,
                                    mojom::OrderDirection direction) {
   bool success = false;
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   ServerWindow* relative_window =
       GetWindowByClientId(ClientWindowId(relative_window_id));
   if (CanReorderWindow(window, relative_window, direction)) {
     success = true;
     Operation op(this, connection_manager_, OperationType::REORDER_WINDOW);
     window->Reorder(relative_window, direction);
     connection_manager_->ProcessWindowReorder(window, relative_window,
                                               direction);
   }
-  client_->OnChangeCompleted(change_id, success);
+  client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTreeImpl::GetWindowTree(
     Id window_id,
     const Callback<void(Array<mojom::WindowDataPtr>)>& callback) {
   std::vector<const ServerWindow*> windows(
       GetWindowTree(ClientWindowId(window_id)));
   callback.Run(WindowsToWindowDatas(windows));
 }
 
 void WindowTreeImpl::SetCapture(uint32_t change_id, Id window_id) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   WindowTreeHostImpl* host = GetHost(window);
   ServerWindow* current_capture_window =
       host ? host->GetCaptureWindow() : nullptr;
   bool success = window && access_policy_->CanSetCapture(window) && host &&
                  (!current_capture_window ||
                   access_policy_->CanSetCapture(current_capture_window)) &&
                  event_ack_id_;
   if (success) {
     Operation op(this, connection_manager_, OperationType::SET_CAPTURE);
     host->SetCapture(window, !HasRoot(window));
   }
-  client_->OnChangeCompleted(change_id, success);
+  client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTreeImpl::ReleaseCapture(uint32_t change_id, Id window_id) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   WindowTreeHostImpl* host = GetHost(window);
   ServerWindow* current_capture_window =
       host ? host->GetCaptureWindow() : nullptr;
   bool success = window && host &&
                  (!current_capture_window ||
                   access_policy_->CanSetCapture(current_capture_window)) &&
                  window == current_capture_window;
   if (success) {
     Operation op(this, connection_manager_, OperationType::RELEASE_CAPTURE);
     host->SetCapture(nullptr, false);
   }
-  client_->OnChangeCompleted(change_id, success);
+  client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTreeImpl::SetWindowBounds(uint32_t change_id,
                                      Id window_id,
                                      mojo::RectPtr bounds) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   if (window && ShouldRouteToWindowManager(window)) {
     const uint32_t wm_change_id =
         connection_manager_->GenerateWindowManagerChangeId(this, change_id);
     // |window_id| may be a client id, use the id from the window to ensure
     // the windowmanager doesn't get an id it doesn't know about.
     WindowManagerState* wms =
         connection_manager_->GetWindowManagerAndHost(window)
             .window_manager_state;
     wms->tree()->window_manager_internal_->WmSetBounds(
         wm_change_id, wms->tree()->ClientWindowIdForWindow(window).id,
         std::move(bounds));
     return;
   }
 
   // Only the owner of the window can change the bounds.
   bool success = window && access_policy_->CanSetWindowBounds(window);
   if (success) {
     Operation op(this, connection_manager_, OperationType::SET_WINDOW_BOUNDS);
     window->SetBounds(bounds.To<gfx::Rect>());
   }
-  client_->OnChangeCompleted(change_id, success);
+  client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTreeImpl::SetWindowVisibility(uint32_t change_id,
                                          Id transport_window_id,
                                          bool visible) {
-  client_->OnChangeCompleted(
+  client()->OnChangeCompleted(
       change_id,
       SetWindowVisibility(ClientWindowId(transport_window_id), visible));
 }
 
 void WindowTreeImpl::SetWindowProperty(uint32_t change_id,
                                        Id transport_window_id,
                                        const mojo::String& name,
                                        mojo::Array<uint8_t> value) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
@@ skipping 11 matching lines @@
   const bool success = window && access_policy_->CanSetWindowProperties(window);
   if (success) {
     Operation op(this, connection_manager_, OperationType::SET_WINDOW_PROPERTY);
     if (value.is_null()) {
       window->SetProperty(name, nullptr);
     } else {
       std::vector<uint8_t> data = value.To<std::vector<uint8_t>>();
       window->SetProperty(name, &data);
     }
   }
-  client_->OnChangeCompleted(change_id, success);
+  client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTreeImpl::AttachSurface(
     Id transport_window_id,
     mojom::SurfaceType type,
     mojo::InterfaceRequest<mojom::Surface> surface,
     mojom::SurfaceClientPtr client) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   const bool success =
@@ skipping 87 matching lines @@
   //             FocusController.
   // TODO(sky): this doesn't work to clear focus. That is because if window is
   // null, then |host| is null and we fail.
   WindowTreeHostImpl* host = GetHost(window);
   const bool success = window && window->IsDrawn() && window->can_focus() &&
                        access_policy_->CanSetFocus(window) && host;
   if (success) {
     Operation op(this, connection_manager_, OperationType::SET_FOCUS);
     host->SetFocusedWindow(window);
   }
-  client_->OnChangeCompleted(change_id, success);
+  client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTreeImpl::SetCanFocus(Id transport_window_id, bool can_focus) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   // TODO(sky): there should be an else case (it shouldn't route to wm and
   // policy allows, then set_can_focus).
   if (window && ShouldRouteToWindowManager(window))
     window->set_can_focus(can_focus);
 }
 
 void WindowTreeImpl::SetPredefinedCursor(uint32_t change_id,
                                          Id transport_window_id,
                                          mus::mojom::Cursor cursor_id) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
 
   // Only the owner of the window can change the bounds.
   bool success = window && access_policy_->CanSetCursorProperties(window);
   if (success) {
     Operation op(this, connection_manager_,
                  OperationType::SET_WINDOW_PREDEFINED_CURSOR);
     window->SetPredefinedCursor(cursor_id);
   }
-  client_->OnChangeCompleted(change_id, success);
+  client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTreeImpl::GetWindowManagerClient(
     mojo::AssociatedInterfaceRequest<mojom::WindowManagerClient> internal) {
   if (!access_policy_->CanSetWindowManager() || !window_manager_internal_ ||
       window_manager_internal_client_binding_) {
     return;
   }
   window_manager_internal_client_binding_.reset(
       new mojo::AssociatedBinding<mojom::WindowManagerClient>(
@@ skipping 67 matching lines @@
   // Only the WindowManager should be using this.
   WindowTreeHostImpl* host = GetHostForWindowManager();
   if (!host)
     return;
 
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   WindowTreeImpl* connection =
       connection_manager_->GetConnectionWithRoot(window);
   if (connection && connection != this) {
-    connection->client_->RequestClose(
+    connection->client()->RequestClose(
         connection->ClientWindowIdForWindow(window).id);
   }
   // TODO(sky): think about what else case means.
 }
 
 void WindowTreeImpl::WmSetFrameDecorationValues(
     mojom::FrameDecorationValuesPtr values) {
   if (GetHostForWindowManager())
     GetHostForWindowManager()->SetFrameDecorationValues(std::move(values));
 }
@@ skipping 35 matching lines @@
 
   for (const auto* root : roots_) {
     if (root->Contains(window))
       return true;
   }
   return false;
 }
 
 }  // namespace ws
 }  // namespace mus