Refators display related functionality into own class

components/mus/ws/display.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/display.h"
 
 #include "base/debug/debugger.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/mus/common/types.h"
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/connection_manager_delegate.h"
 #include "components/mus/ws/display_binding.h"
+#include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/focus_controller.h"
 #include "components/mus/ws/platform_display.h"
 #include "components/mus/ws/window_manager_factory_service.h"
 #include "components/mus/ws/window_manager_state.h"
 #include "components/mus/ws/window_tree.h"
 #include "components/mus/ws/window_tree_binding.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"
 #include "mojo/shell/public/interfaces/connector.mojom.h"
@@ skipping 98 matching lines @@
   std::set<WindowManagerState*> states;
   for (auto& pair : window_manager_state_map_)
     states.insert(pair.second.get());
   for (WindowManagerState* state : states)
     connection_manager_->DestroyTree(state->tree());
 }
 
 void Display::Init(scoped_ptr<DisplayBinding> binding) {
   init_called_ = true;
   binding_ = std::move(binding);
-  connection_manager_->AddDisplay(this);
+  display_manager()->AddDisplay(this);
   InitWindowManagersIfNecessary();
 }
 
 void Display::SetFrameDecorationValues(mojom::FrameDecorationValuesPtr values) {
   // TODO(sky): this needs to be moved to WindowManagerState.
   frame_decoration_values_ = values.Clone();
   connection_manager_->ProcessFrameDecorationValuesChanged(this);
 }
 
-bool Display::SchedulePaintIfInViewport(const ServerWindow* window,
-                                        const gfx::Rect& bounds) {
-  if (root_->Contains(window)) {
-    platform_display_->SchedulePaint(window, bounds);
-    return true;
-  }
-  return false;
+void Display::SchedulePaint(const ServerWindow* window,
+                            const gfx::Rect& bounds) {
+  DCHECK(root_->Contains(window));
+  platform_display_->SchedulePaint(window, bounds);
 }
 
 void Display::ScheduleSurfaceDestruction(ServerWindow* window) {
   if (!platform_display_->IsFramePending()) {
     window->DestroySurfacesScheduledForDestruction();
     return;
   }
   if (windows_needing_frame_destruction_.count(window))
     return;
   windows_needing_frame_destruction_.insert(window);
@@ skipping 82 matching lines @@
   platform_display_->UpdateTextInputState(state);
 }
 
 void Display::SetImeVisibility(ServerWindow* window, bool visible) {
   // Do not need to show or hide IME for unfocused window.
   if (focus_controller_->GetFocusedWindow() != window)
     return;
   platform_display_->SetImeVisibility(visible);
 }
 
-void Display::OnWindowTreeConnectionError(WindowTree* tree) {
+void Display::OnWillDestroyTree(WindowTree* tree) {
   for (auto it = window_manager_state_map_.begin();
        it != window_manager_state_map_.end(); ++it) {
     if (it->second->tree() == tree) {
       window_manager_state_map_.erase(it);
       break;
     }
   }
 
   if (tree_awaiting_input_ack_ != tree)
     return;
@@ skipping 30 matching lines @@
   }
   tree_awaiting_input_ack_ = nullptr;
   event_ack_timer_.Stop();
   ProcessNextEventFromQueue();
 }
 
 void Display::InitWindowManagersIfNecessary() {
   if (!init_called_ || !root_)
     return;
 
-  connection_manager_->OnDisplayAcceleratedWidgetAvailable(this);
+  display_manager()->OnDisplayAcceleratedWidgetAvailable(this);
   if (binding_) {
     scoped_ptr<WindowManagerState> wms_ptr(new WindowManagerState(this));
     WindowManagerState* wms = wms_ptr.get();
     // For this case we never create additional WindowManagerStates, so any
     // id works.
     window_manager_state_map_[mojo::shell::mojom::kRootUserID] =
         std::move(wms_ptr);
     wms->tree_ = binding_->CreateWindowTree(wms->root());
   } else {
     CreateWindowManagerStatesFromRegistry();
   }
 }
 
+DisplayManager* Display::display_manager() {
+  return connection_manager_->display_manager();
+}
+
+const DisplayManager* Display::display_manager() const {
+  return connection_manager_->display_manager();
+}
+
 void Display::OnEventAckTimeout() {
   // TODO(sad): Figure out what we should do.
   NOTIMPLEMENTED() << "Event ACK timed out.";
   OnEventAck(tree_awaiting_input_ack_);
 }
 
 void Display::QueueEvent(
     const ui::Event& event,
     scoped_ptr<ProcessedEventTarget> processed_event_target) {
   scoped_ptr<QueuedEvent> queued_event(new QueuedEvent);
@@ skipping 103 matching lines @@
     return;
   }
   event_dispatcher_.ProcessEvent(event);
 }
 
 void Display::OnNativeCaptureLost() {
   SetCapture(nullptr, false);
 }
 
 void Display::OnDisplayClosed() {
-  connection_manager_->DestroyDisplay(this);
+  display_manager()->DestroyDisplay(this);
 }
 
 void Display::OnViewportMetricsChanged(
     const mojom::ViewportMetrics& old_metrics,
     const mojom::ViewportMetrics& new_metrics) {
   if (!root_) {
     root_.reset(connection_manager_->CreateServerWindow(
-        RootWindowId(connection_manager_->GetAndAdvanceNextRootId()),
+        display_manager()->GetAndAdvanceNextRootId(),
         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);
     InitWindowManagersIfNecessary();
     event_dispatcher_.set_root(root_.get());
   } else {
     root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels.To<gfx::Size>()));
     const gfx::Rect wm_bounds(root_->bounds().size());
@@ skipping 78 matching lines @@
       DCHECK_NE(owning_tree_new, embedded_tree_new);
       embedded_tree_new->ProcessFocusChanged(old_focused_window,
                                              new_focused_window);
     }
   }
 
   // WindowManagers are always notified of focus changes.
   WindowTree* wms_tree_with_old_focused_window = nullptr;
   if (old_focused_window) {
     WindowManagerState* wms =
-        connection_manager_->GetWindowManagerAndDisplay(old_focused_window)
+        display_manager()
+            ->GetWindowManagerAndDisplay(old_focused_window)
             .window_manager_state;
     wms_tree_with_old_focused_window = wms ? wms->tree() : nullptr;
     if (wms_tree_with_old_focused_window &&
         wms_tree_with_old_focused_window != owning_tree_old &&
         wms_tree_with_old_focused_window != embedded_tree_old &&
         wms_tree_with_old_focused_window != owning_tree_new &&
         wms_tree_with_old_focused_window != embedded_tree_new) {
       wms_tree_with_old_focused_window->ProcessFocusChanged(old_focused_window,
                                                             new_focused_window);
     }
   }
   if (new_focused_window) {
     WindowManagerState* wms =
-        connection_manager_->GetWindowManagerAndDisplay(new_focused_window)
+        display_manager()
+            ->GetWindowManagerAndDisplay(new_focused_window)
             .window_manager_state;
     WindowTree* wms_tree = wms ? wms->tree() : nullptr;
     if (wms_tree && wms_tree != wms_tree_with_old_focused_window &&
         wms_tree != owning_tree_old && wms_tree != embedded_tree_old &&
         wms_tree != owning_tree_new && wms_tree != embedded_tree_new) {
       wms_tree->ProcessFocusChanged(old_focused_window, new_focused_window);
     }
   }
 
   UpdateTextInputState(new_focused_window,
@@ skipping 54 matching lines @@
 void Display::OnUserIdAdded(const UserId& id) {}
 
 void Display::OnUserIdRemoved(const UserId& id) {
   if (binding_)
     return;
 
   WindowManagerState* state = GetWindowManagerStateForUser(id);
   if (!state)
     return;
 
-  // DestroyTree() calls back to OnWindowTreeConnectionError() and the
-  // WindowManagerState is destroyed (and removed).
+  // DestroyTree() calls back to OnWillDestroyTree() and the WindowManagerState
+  // is destroyed (and removed).
   connection_manager_->DestroyTree(state->tree());
   DCHECK_EQ(0u, window_manager_state_map_.count(id));
 }
 
 void Display::OnWindowManagerFactorySet(WindowManagerFactoryService* service) {
   CreateWindowManagerStateFromService(service);
 }
 
 }  // namespace ws
 }  // namespace mus