Start to decouple display::Display from ws::PlatformDisplay.

services/ui/ws/display_manager.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 "services/ui/ws/display_manager.h"
 
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
+#include "services/ui/display/viewport_metrics.h"
 #include "services/ui/ws/cursor_location_manager.h"
 #include "services/ui/ws/display.h"
 #include "services/ui/ws/display_binding.h"
 #include "services/ui/ws/event_dispatcher.h"
-#include "services/ui/ws/platform_display_init_params.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/user_display_manager.h"
 #include "services/ui/ws/user_display_manager_delegate.h"
 #include "services/ui/ws/user_id_tracker.h"
 #include "services/ui/ws/window_manager_state.h"
 #include "services/ui/ws/window_manager_window_tree_factory.h"
 #include "services/ui/ws/window_server_delegate.h"
 #include "services/ui/ws/window_tree.h"
 
 namespace ui {
@@ skipping 65 matching lines @@
   while (!displays_.empty())
     DestroyDisplay(*displays_.begin());
   DCHECK(displays_.empty());
 }
 
 std::set<const Display*> DisplayManager::displays() const {
   std::set<const Display*> ret_value(displays_.begin(), displays_.end());
   return ret_value;
 }
 
-void DisplayManager::OnDisplayUpdate(Display* display) {
+void DisplayManager::OnDisplayUpdate(const display::Display& display) {
   for (const auto& pair : user_display_managers_)
-    pair.second->OnDisplayUpdate(display->ToDisplay());
+    pair.second->OnDisplayUpdate(display);
 }
 
 Display* DisplayManager::GetDisplayContaining(const ServerWindow* window) {
   return const_cast<Display*>(
       static_cast<const DisplayManager*>(this)->GetDisplayContaining(window));
 }
 
 const Display* DisplayManager::GetDisplayContaining(
     const ServerWindow* window) const {
   while (window && window->parent())
@@ skipping 60 matching lines @@
                                    ->mouse_pointer_last_location();
     previous_window_manager_state->Deactivate();
   }
 
   WindowManagerState* current_window_manager_state =
       window_server_->GetWindowManagerStateForUser(active_id);
   if (current_window_manager_state)
     current_window_manager_state->Activate(mouse_location_on_screen);
 }
 
-void DisplayManager::OnDisplayAdded(int64_t id,
+void DisplayManager::OnDisplayAdded(const display::Display& display,
                                     const display::ViewportMetrics& metrics) {
-  TRACE_EVENT1("mus-ws", "OnDisplayAdded", "id", id);
-  PlatformDisplayInitParams params;
-  params.display_id = id;
-  params.metrics = metrics;
+  VLOG(1) << "OnDisplayAdded: " << display.ToString();

[sky, 2017/03/13 18:29:06]

We've been using level 3 for informational messages (which this fits in). Also,
can you use DVLOG?

[kylechar, 2017/03/13 19:28:02]

Done.

 
-  ws::Display* display = new ws::Display(window_server_);
-  display->Init(params, nullptr);
+  ws::Display* ws_display = new ws::Display(window_server_);
+  ws_display->SetDisplay(display);
+  ws_display->Init(metrics, nullptr);
 }
 
-void DisplayManager::OnDisplayRemoved(int64_t id) {
-  TRACE_EVENT1("mus-ws", "OnDisplayRemoved", "id", id);
-  Display* display = GetDisplayById(id);
+void DisplayManager::OnDisplayRemoved(int64_t display_id) {
+  VLOG(1) << "OnDisplayRemoved: " << display_id;
+  Display* display = GetDisplayById(display_id);
   if (display)
     DestroyDisplay(display);
 }
 
 void DisplayManager::OnDisplayModified(
-    int64_t id,
+    const display::Display& display,
     const display::ViewportMetrics& metrics) {
-  TRACE_EVENT1("mus-ws", "OnDisplayModified", "id", id);
+  VLOG(1) << "OnDisplayModified: " << display.ToString();
 
-  Display* display = GetDisplayById(id);
-  DCHECK(display);
+  Display* ws_display = GetDisplayById(display.id());
+  DCHECK(ws_display);
 
+  ws_display->SetDisplay(display);
   // Update the platform display and check if anything has actually changed.
-  if (!display->platform_display()->UpdateViewportMetrics(metrics))
+  if (!ws_display->platform_display()->UpdateViewportMetrics(metrics))
     return;
 
   // Send IPCs to WM clients first with new display information.
   std::vector<WindowManagerWindowTreeFactory*> factories =
       window_server_->window_manager_window_tree_factory_set()->GetFactories();
   for (WindowManagerWindowTreeFactory* factory : factories) {
     if (factory->window_tree())
-      factory->window_tree()->OnWmDisplayModified(display->ToDisplay());
+      factory->window_tree()->OnWmDisplayModified(display);
   }
 
   // Change the root ServerWindow size after sending IPC to WM.
-  display->OnViewportMetricsChanged(metrics);
+  ws_display->OnViewportMetricsChanged(metrics);
   OnDisplayUpdate(display);
 }
 
 void DisplayManager::OnPrimaryDisplayChanged(int64_t primary_display_id) {
+  VLOG(1) << "OnPrimaryDisplayChanged: " << primary_display_id;
   // TODO(kylechar): Send IPCs to WM clients first.
 
   // Send IPCs to any DisplayManagerObservers.
   for (const auto& pair : user_display_managers_)
     pair.second->OnPrimaryDisplayChanged(primary_display_id);
 }
 
 }  // namespace ws
 }  // namespace ui