WIP: Propagate SurfaceID up window tree hierarchy

services/ui/ws/server_window_surface_manager.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 "services/ui/ws/server_window_surface_manager.h"
 
-#include "services/ui/surfaces/surfaces_state.h"
+#include "services/ui/surfaces/display_compositor.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/server_window_delegate.h"
 #include "services/ui/ws/server_window_surface.h"
 
 namespace ui {
 namespace ws {
 
 ServerWindowSurfaceManager::ServerWindowSurfaceManager(ServerWindow* window)
     : window_(window),
+      frame_sink_id_(window->id().client_id, window->id().window_id),
       waiting_for_initial_frames_(
           window_->properties().count(ui::mojom::kWaitForUnderlay_Property) >
           0) {
+  surface_sequence_generator_.set_frame_sink_id(frame_sink_id_);
 }
 
 ServerWindowSurfaceManager::~ServerWindowSurfaceManager() {
   // Explicitly clear the type to surface manager so that this manager
   // is still valid prior during ~ServerWindowSurface.
   type_to_surface_map_.clear();
 }
 
 bool ServerWindowSurfaceManager::ShouldDraw() {
   if (!waiting_for_initial_frames_)
     return true;
 
   waiting_for_initial_frames_ =
       !IsSurfaceReadyAndNonEmpty(mojom::SurfaceType::DEFAULT) ||
       !IsSurfaceReadyAndNonEmpty(mojom::SurfaceType::UNDERLAY);
   return !waiting_for_initial_frames_;
 }
 
 void ServerWindowSurfaceManager::CreateSurface(
     mojom::SurfaceType surface_type,
     mojo::InterfaceRequest<mojom::Surface> request,
     mojom::SurfaceClientPtr client) {
+  cc::FrameSinkId id = frame_sink_id_;
+  // TODO(fsamuel): For non-default surfaces let's give them a unique ID that's
+  // different.
+  if (surface_type != mojom::SurfaceType::DEFAULT) {
+    // TODO(fsamuel): HUGE HACK!
+    id = cc::FrameSinkId(
+        100000000,
+        window_->delegate()->GetDisplayCompositor()->next_client_id());
+  }
+
   std::unique_ptr<ServerWindowSurface> surface(
-      new ServerWindowSurface(this, std::move(request), std::move(client)));
+      new ServerWindowSurface(this, id, std::move(request), std::move(client)));
   type_to_surface_map_[surface_type] = std::move(surface);
 }
 
+cc::SurfaceSequence ServerWindowSurfaceManager::CreateSurfaceSequence() {
+  return surface_sequence_generator_.CreateSurfaceSequence();
+}
+
+void ServerWindowSurfaceManager::SatisfySurfaceSequence(
+    const cc::SurfaceSequence& sequence) {
+  std::vector<uint32_t> sequences;
+  sequences.push_back(sequence.sequence);
+  window_->delegate()->GetDisplayCompositor()->manager()->
+    DidSatisfySequences(sequence.frame_sink_id, &sequences);
+}
+
 ServerWindowSurface* ServerWindowSurfaceManager::GetDefaultSurface() const {
   return GetSurfaceByType(mojom::SurfaceType::DEFAULT);
 }
 
 ServerWindowSurface* ServerWindowSurfaceManager::GetUnderlaySurface() const {
   return GetSurfaceByType(mojom::SurfaceType::UNDERLAY);
 }
 
 ServerWindowSurface* ServerWindowSurfaceManager::GetSurfaceByType(
     mojom::SurfaceType type) const {
   auto iter = type_to_surface_map_.find(type);
   return iter == type_to_surface_map_.end() ? nullptr : iter->second.get();
 }
 
 bool ServerWindowSurfaceManager::HasSurfaceOfType(
     mojom::SurfaceType type) const {
   return type_to_surface_map_.count(type) > 0;
 }
 
 bool ServerWindowSurfaceManager::HasAnySurface() const {
   return GetDefaultSurface() || GetUnderlaySurface();
 }
 
 cc::SurfaceManager* ServerWindowSurfaceManager::GetSurfaceManager() {
-  return window()->delegate()->GetSurfacesState()->manager();
+  return window()->delegate()->GetDisplayCompositor()->manager();
 }
 
 bool ServerWindowSurfaceManager::IsSurfaceReadyAndNonEmpty(
     mojom::SurfaceType type) const {
   auto iter = type_to_surface_map_.find(type);
   if (iter == type_to_surface_map_.end())
     return false;
   if (iter->second->last_submitted_frame_size().IsEmpty())
     return false;
   const gfx::Size& last_submitted_frame_size =
       iter->second->last_submitted_frame_size();
   return last_submitted_frame_size.width() >= window_->bounds().width() &&
          last_submitted_frame_size.height() >= window_->bounds().height();
 }
 
 }  // namespace ws
 }  // namespace ui