Changes ownership of WindowTreeHostConnection

components/mus/ws/window_tree_host_impl.cc

 // Copyright 2015 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_host_impl.h"
 
 #include "base/debug/debugger.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/mus/common/types.h"
 #include "components/mus/public/interfaces/input_event_constants.mojom.h"
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/focus_controller.h"
-#include "components/mus/ws/window_tree_host_delegate.h"
+#include "components/mus/ws/window_tree_host_connection.h"
 #include "components/mus/ws/window_tree_impl.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 
 namespace mus {
 namespace ws {
 namespace {
 
 base::TimeDelta GetDefaultAckTimerDelay() {
@@ skipping 59 matching lines @@
 
 WindowTreeHostImpl::QueuedEvent::QueuedEvent() {}
 WindowTreeHostImpl::QueuedEvent::~QueuedEvent() {}
 
 WindowTreeHostImpl::WindowTreeHostImpl(
     ConnectionManager* connection_manager,
     mojo::Connector* connector,
     const scoped_refptr<GpuState>& gpu_state,
     const scoped_refptr<SurfacesState>& surfaces_state)
     : id_(next_id++),
-      delegate_(nullptr),
       connection_manager_(connection_manager),
       event_dispatcher_(this),
       display_manager_(
           DisplayManager::Create(connector, gpu_state, surfaces_state)),
       tree_awaiting_input_ack_(nullptr),
       last_cursor_(0) {
   frame_decoration_values_ = mojom::FrameDecorationValues::New();
   frame_decoration_values_->normal_client_area_insets = mojo::Insets::New();
   frame_decoration_values_->maximized_client_area_insets = mojo::Insets::New();
   frame_decoration_values_->max_title_bar_button_width = 0u;
 
   display_manager_->Init(this);
 }
 
 WindowTreeHostImpl::~WindowTreeHostImpl() {
   DestroyFocusController();
   for (ServerWindow* window : windows_needing_frame_destruction_)
     window->RemoveObserver(this);
 }
 
-void WindowTreeHostImpl::Init(WindowTreeHostDelegate* delegate) {
-  delegate_ = delegate;
-  if (delegate_ && root_)
-    delegate_->OnDisplayInitialized();
+void WindowTreeHostImpl::Init(scoped_ptr<WindowTreeHostConnection> connection) {
+  window_tree_host_connection_ = std::move(connection);
+  connection_manager_->AddHost(this);
+  CallOnDisplayInitializedIfNecessary();
 }
 
 const WindowTreeImpl* WindowTreeHostImpl::GetWindowTree() const {
-  return delegate_ ? delegate_->GetWindowTree() : nullptr;
+  return window_tree_;
 }
 
 WindowTreeImpl* WindowTreeHostImpl::GetWindowTree() {
-  return delegate_ ? delegate_->GetWindowTree() : nullptr;
+  return window_tree_;
 }
 
 void WindowTreeHostImpl::SetFrameDecorationValues(
     mojom::FrameDecorationValuesPtr values) {
   frame_decoration_values_ = values.Clone();
   connection_manager_->ProcessFrameDecorationValuesChanged(this);
 }
 
 bool WindowTreeHostImpl::IsWindowAttachedToRoot(
     const ServerWindow* window) const {
@@ skipping 111 matching lines @@
   if (tree_awaiting_input_ack_ != tree) {
     // TODO(sad): The ack must have arrived after the timeout. We should do
     // something here, and in OnEventAckTimeout().
     return;
   }
   tree_awaiting_input_ack_ = nullptr;
   event_ack_timer_.Stop();
   ProcessNextEventFromQueue();
 }
 
+void WindowTreeHostImpl::CallOnDisplayInitializedIfNecessary() {
+  if (window_tree_host_connection_ && root_) {
+    connection_manager_->OnWindowTreeHostDisplayAvailable(this);
+    window_tree_ = window_tree_host_connection_->CreateWindowTree(root_.get());
+  }
+}
+
 void WindowTreeHostImpl::OnEventAckTimeout() {
   // TODO(sad): Figure out what we should do.
   NOTIMPLEMENTED() << "Event ACK timed out.";
   OnEventAck(tree_awaiting_input_ack_);
 }
 
 void WindowTreeHostImpl::QueueEvent(
     mojom::EventPtr event,
     scoped_ptr<ProcessedEventTarget> processed_event_target) {
   scoped_ptr<QueuedEvent> queued_event(new QueuedEvent);
@@ skipping 81 matching lines @@
     return;
   }
   event_dispatcher_.ProcessEvent(std::move(mojo_event));
 }
 
 void WindowTreeHostImpl::OnNativeCaptureLost() {
   SetCapture(nullptr, false);
 }
 
 void WindowTreeHostImpl::OnDisplayClosed() {
-  if (delegate_)
-    delegate_->OnDisplayClosed();
+  connection_manager_->DestroyHost(this);
 }
 
 void WindowTreeHostImpl::OnViewportMetricsChanged(
     const mojom::ViewportMetrics& old_metrics,
     const mojom::ViewportMetrics& new_metrics) {
   if (!root_) {
     root_.reset(connection_manager_->CreateServerWindow(
         RootWindowId(connection_manager_->GetAndAdvanceNextHostId()),
         ServerWindow::Properties()));
     root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels.To<gfx::Size>()));
     root_->SetVisible(true);
     focus_controller_.reset(new FocusController(this, root_.get()));
     focus_controller_->AddObserver(this);
-    if (delegate_)
-      delegate_->OnDisplayInitialized();
+    CallOnDisplayInitializedIfNecessary();
     event_dispatcher_.set_root(root_.get());
   } else {
     root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels.To<gfx::Size>()));
   }
   connection_manager_->ProcessViewportMetricsChanged(this, old_metrics,
                                                      new_metrics);
 }
 
 void WindowTreeHostImpl::OnTopLevelSurfaceChanged(cc::SurfaceId surface_id) {
   event_dispatcher_.set_surface_id(surface_id);
@@ skipping 67 matching lines @@
     if (embedded_connection_new &&
         embedded_connection_new != owning_connection_old &&
         embedded_connection_new != embedded_connection_old) {
       DCHECK_NE(owning_connection_new, embedded_connection_new);
       embedded_connection_new->ProcessFocusChanged(old_focused_window,
                                                    new_focused_window);
     }
   }
 
   // Ensure that we always notify the root connection of a focus change.
-  WindowTreeImpl* root_tree = GetWindowTree();
-  if (root_tree != owning_connection_old &&
-      root_tree != embedded_connection_old &&
-      root_tree != owning_connection_new &&
-      root_tree != embedded_connection_new) {
-    root_tree->ProcessFocusChanged(old_focused_window, new_focused_window);
+  if (window_tree_ != owning_connection_old &&
+      window_tree_ != embedded_connection_old &&
+      window_tree_ != owning_connection_new &&
+      window_tree_ != embedded_connection_new) {
+    window_tree_->ProcessFocusChanged(old_focused_window, new_focused_window);
   }
 
   UpdateTextInputState(new_focused_window,
                        new_focused_window->text_input_state());
 }
 
 void WindowTreeHostImpl::OnAccelerator(uint32_t accelerator_id,
                                        mojom::EventPtr event) {
-  GetWindowTree()->OnAccelerator(accelerator_id, std::move(event));
+  window_tree_->OnAccelerator(accelerator_id, std::move(event));
 }
 
 void WindowTreeHostImpl::SetFocusedWindowFromEventDispatcher(
     ServerWindow* new_focused_window) {
   SetFocusedWindow(new_focused_window);
 }
 
 ServerWindow* WindowTreeHostImpl::GetFocusedWindowForEventDispatcher() {
   return GetFocusedWindow();
 }
@@ skipping 24 matching lines @@
   DispatchInputEventToWindowImpl(target, in_nonclient_area, std::move(event));
 }
 
 void WindowTreeHostImpl::OnWindowDestroyed(ServerWindow* window) {
   windows_needing_frame_destruction_.erase(window);
   window->RemoveObserver(this);
 }
 
 }  // namespace ws
 }  // namespace mus