WIP: Propagate SurfaceID up window tree hierarchy

services/ui/ws/window_server.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 "services/ui/ws/window_server.h"
 
 #include <set>
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
+#include "cc/surfaces/surface.h"
 #include "services/shell/public/cpp/connection.h"
 #include "services/ui/ws/display.h"
 #include "services/ui/ws/display_binding.h"
 #include "services/ui/ws/display_manager.h"
 #include "services/ui/ws/gpu_service_proxy.h"
 #include "services/ui/ws/operation.h"
 #include "services/ui/ws/server_window.h"
+#include "services/ui/ws/server_window_surface_manager.h"
 #include "services/ui/ws/user_activity_monitor.h"
 #include "services/ui/ws/window_coordinate_conversions.h"
 #include "services/ui/ws/window_manager_access_policy.h"
 #include "services/ui/ws/window_manager_display_root.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"
 #include "services/ui/ws/window_tree_binding.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace ui {
 namespace ws {
 
 struct WindowServer::CurrentMoveLoopState {
   uint32_t change_id;
   ServerWindow* window;
   WindowTree* initiator;
   gfx::Rect revert_bounds;
 };
 
 struct WindowServer::CurrentDragLoopState {
   uint32_t change_id;
   ServerWindow* window;
   WindowTree* initiator;
 };
 
 WindowServer::WindowServer(WindowServerDelegate* delegate)
     : delegate_(delegate),
-      surfaces_state_(new SurfacesState()),
+      display_compositor_(new surfaces::DisplayCompositor(this)),
       next_client_id_(1),
       display_manager_(new DisplayManager(this, &user_id_tracker_)),
       current_operation_(nullptr),
       in_destructor_(false),
       next_wm_change_id_(0),
       gpu_proxy_(new GpuServiceProxy(this)),
       window_manager_window_tree_factory_set_(this, &user_id_tracker_) {
   user_id_tracker_.AddObserver(this);
   OnUserIdAdded(user_id_tracker_.active_id());
 }
@@ skipping 308 matching lines @@
 
 void WindowServer::ProcessWindowBoundsChanged(const ServerWindow* window,
                                               const gfx::Rect& old_bounds,
                                               const gfx::Rect& new_bounds) {
   for (auto& pair : tree_map_) {
     pair.second->ProcessWindowBoundsChanged(window, old_bounds, new_bounds,
                                             IsOperationSource(pair.first));
   }
 }
 
+void WindowServer::ProcessWindowSurfaceCreated(
+    ServerWindow* window,
+    const gfx::Size& size,
+    float device_scale_factor,
+    const cc::SurfaceId& surface_id) {
+  ServerWindowSurfaceManager* surface_manager =
+      window->GetOrCreateSurfaceManager();
+  for (auto& pair : tree_map_) {
+    cc::SurfaceSequence surface_sequence =
+        surface_manager->CreateSurfaceSequence();
+    surfaces::DisplayCompositor* compositor = GetDisplayCompositor();
+    compositor->manager()
+        ->GetSurfaceForId(surface_id)
+        ->AddDestructionDependency(surface_sequence);
+    pair.second->ProcessWindowSurfaceCreated(window, size,
+                                             1.0f /* device_scale_factor */,
+                                             surface_id, surface_sequence);
+  }
+}
+
 void WindowServer::ProcessClientAreaChanged(
     const ServerWindow* window,
     const gfx::Insets& new_client_area,
     const std::vector<gfx::Rect>& new_additional_client_areas) {
   for (auto& pair : tree_map_) {
     pair.second->ProcessClientAreaChanged(window, new_client_area,
                                           new_additional_client_areas,
                                           IsOperationSource(pair.first));
   }
 }
@@ skipping 148 matching lines @@
 void WindowServer::OnNoMoreDisplays() {
   delegate_->OnNoMoreDisplays();
 }
 
 WindowManagerState* WindowServer::GetWindowManagerStateForUser(
     const UserId& user_id) {
   return window_manager_window_tree_factory_set_.GetWindowManagerStateForUser(
       user_id);
 }
 
-ui::SurfacesState* WindowServer::GetSurfacesState() {
-  return surfaces_state_.get();
+ui::surfaces::DisplayCompositor* WindowServer::GetDisplayCompositor() {
+  return display_compositor_.get();
 }
 
 bool WindowServer::GetFrameDecorationsForUser(
     const UserId& user_id,
     mojom::FrameDecorationValuesPtr* values) {
   WindowManagerState* window_manager_state =
       window_manager_window_tree_factory_set_.GetWindowManagerStateForUser(
           user_id);
   if (!window_manager_state)
     return false;
   if (values && window_manager_state->got_frame_decoration_values())
     *values = window_manager_state->frame_decoration_values().Clone();
   return window_manager_state->got_frame_decoration_values();
 }
 
+void WindowServer::OnSurfaceCreated(const gfx::Size& size,
+                                    float device_scale_factor,
+                                    const cc::SurfaceId& surface_id) {
+  WindowId window_id(surface_id.client_id(), surface_id.sink_id());
+  ServerWindow* window = GetWindow(window_id);
+  if (!window)
+    return;
+  ProcessWindowSurfaceCreated(window, size, device_scale_factor, surface_id);
+}
+
 bool WindowServer::GetAndClearInFlightWindowManagerChange(
     uint32_t window_manager_change_id,
     InFlightWindowManagerChange* change) {
   // There are valid reasons as to why we wouldn't know about the id. The
   // most likely is the client disconnected before the response from the window
   // manager came back.
   auto iter = in_flight_wm_change_map_.find(window_manager_change_id);
   if (iter == in_flight_wm_change_map_.end())
     return false;
 
@@ skipping 260 matching lines @@
 void WindowServer::OnUserIdAdded(const UserId& id) {
   activity_monitor_map_[id] = base::MakeUnique<UserActivityMonitor>(nullptr);
 }
 
 void WindowServer::OnUserIdRemoved(const UserId& id) {
   activity_monitor_map_.erase(id);
 }
 
 }  // namespace ws
 }  // namespace ui