Remove dependency on SurfaceManager in FrameGenerator

services/ui/ws/frame_generator.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/frame_generator.h"
 
 #include "base/containers/adapters.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
-#include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_id.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "services/ui/surfaces/display_compositor.h"
 #include "services/ui/surfaces/surfaces_context_provider.h"
 #include "services/ui/ws/frame_generator_delegate.h"
 #include "services/ui/ws/server_window.h"
-#include "services/ui/ws/server_window_compositor_frame_sink.h"
 #include "services/ui/ws/server_window_compositor_frame_sink_manager.h"
+#include "services/ui/ws/server_window_delegate.h"
 
 namespace ui {
 
 namespace ws {
 
-FrameGenerator::FrameGenerator(
-    FrameGeneratorDelegate* delegate,
-    ServerWindow* root_window,
-    scoped_refptr<DisplayCompositor> display_compositor)
+FrameGenerator::FrameGenerator(FrameGeneratorDelegate* delegate,
+                               ServerWindow* root_window)
     : delegate_(delegate),
-      display_compositor_(display_compositor),
       frame_sink_id_(
           WindowIdToTransportId(root_window->id()),
           static_cast<uint32_t>(mojom::CompositorFrameSinkType::DEFAULT)),
       root_window_(root_window),
       draw_timer_(false, false),
       binding_(this),
       weak_factory_(this) {
   DCHECK(delegate_);
   surface_sequence_generator_.set_frame_sink_id(frame_sink_id_);
 }
@@ skipping 197 matching lines @@
   }
 }
 
 void FrameGenerator::AddOrUpdateSurfaceReference(
     mojom::CompositorFrameSinkType type,
     ServerWindow* window) {
   cc::SurfaceId surface_id =
       window->compositor_frame_sink_manager()->GetLatestSurfaceId(type);
   if (surface_id.is_null())
     return;
-  // TODO(fsamuel): Use mojo interface to give root window a surface reference.
-  cc::SurfaceManager* surface_manager = display_compositor_->manager();
   auto it = dependencies_.find(surface_id.frame_sink_id());
   if (it == dependencies_.end()) {
-    cc::Surface* surface = surface_manager->GetSurfaceForId(surface_id);
-    if (!surface) {
-      LOG(ERROR) << "Attempting to add dependency to nonexistent surface "
-                 << surface_id.ToString();
-      return;
-    }
     SurfaceDependency dependency = {
         surface_id.local_frame_id(),
         surface_sequence_generator_.CreateSurfaceSequence()};
-    surface->AddDestructionDependency(dependency.sequence);
     dependencies_[surface_id.frame_sink_id()] = dependency;
+    GetDisplayCompositor()->AddSurfaceReference(surface_id,
+                                                dependency.sequence);
     // Observe |window_surface|'s window so that we can release references when
     // the window is destroyed.
     Add(window);
     return;
   }
 
   // We are already holding a reference to this surface so there's no work to do
   // here.
   if (surface_id.local_frame_id() == it->second.local_frame_id)
     return;
@@ skipping 12 matching lines @@
   AddOrUpdateSurfaceReference(type, window);
 }
 
 void FrameGenerator::ReleaseFrameSinkReference(
     const cc::FrameSinkId& frame_sink_id) {
   auto it = dependencies_.find(frame_sink_id);
   if (it == dependencies_.end())
     return;
   std::vector<uint32_t> sequences;
   sequences.push_back(it->second.sequence.sequence);
-  cc::SurfaceManager* surface_manager = display_compositor_->manager();
-  surface_manager->DidSatisfySequences(frame_sink_id_, &sequences);
+  GetDisplayCompositor()->ReturnSurfaceReferences(frame_sink_id, sequences);
   dependencies_.erase(it);
 }
 
 void FrameGenerator::ReleaseAllSurfaceReferences() {
-  cc::SurfaceManager* surface_manager = display_compositor_->manager();
   std::vector<uint32_t> sequences;
   for (auto& dependency : dependencies_)
     sequences.push_back(dependency.second.sequence.sequence);
-  surface_manager->DidSatisfySequences(frame_sink_id_, &sequences);
+  GetDisplayCompositor()->ReturnSurfaceReferences(frame_sink_id_, sequences);
   dependencies_.clear();
 }
 
+ui::DisplayCompositor* FrameGenerator::GetDisplayCompositor() {
+  return root_window_->delegate()->GetDisplayCompositor();
+}
+
 void FrameGenerator::OnWindowDestroying(ServerWindow* window) {
   Remove(window);
   ServerWindowCompositorFrameSinkManager* compositor_frame_sink_manager =
       window->compositor_frame_sink_manager();
   // If FrameGenerator was observing |window|, then that means it had a
   // CompositorFrame at some point in time and should have a
   // ServerWindowCompositorFrameSinkManager.
   DCHECK(compositor_frame_sink_manager);
 
   cc::SurfaceId default_surface_id =
       window->compositor_frame_sink_manager()->GetLatestSurfaceId(
           mojom::CompositorFrameSinkType::DEFAULT);
   if (!default_surface_id.is_null())
     ReleaseFrameSinkReference(default_surface_id.frame_sink_id());
 
   cc::SurfaceId underlay_surface_id =
       window->compositor_frame_sink_manager()->GetLatestSurfaceId(
           mojom::CompositorFrameSinkType::UNDERLAY);
   if (!underlay_surface_id.is_null())
     ReleaseFrameSinkReference(underlay_surface_id.frame_sink_id());
 }
 
 }  // namespace ws
 
 }  // namespace ui