Introducing SurfaceReferenceFactory

blimp/client/core/compositor/blimp_compositor.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 "blimp/client/core/compositor/blimp_compositor.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "blimp/client/core/compositor/blimp_compositor_dependencies.h"
 #include "blimp/client/core/compositor/blimp_compositor_frame_sink.h"
 #include "blimp/client/public/compositor/compositor_dependencies.h"
 #include "blimp/net/blimp_stats.h"
 #include "cc/animation/animation_host.h"
 #include "cc/blimp/client_picture_cache.h"
 #include "cc/blimp/compositor_state_deserializer.h"
 #include "cc/blimp/image_serialization_processor.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/surface_layer.h"
 #include "cc/output/compositor_frame_sink.h"
 #include "cc/proto/compositor_message.pb.h"
+#include "cc/surfaces/direct_surface_embedding.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_host_in_process.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "net/base/net_errors.h"
 #include "ui/gl/gl_surface.h"
 
 namespace blimp {
 namespace client {
 
-namespace {
-
-void SatisfyCallback(cc::SurfaceManager* manager,
-                     const cc::SurfaceSequence& sequence) {
-  std::vector<uint32_t> sequences;
-  sequences.push_back(sequence.sequence);
-  manager->DidSatisfySequences(sequence.frame_sink_id, &sequences);
-}
-
-void RequireCallback(cc::SurfaceManager* manager,
-                     const cc::SurfaceId& id,
-                     const cc::SurfaceSequence& sequence) {
-  cc::Surface* surface = manager->GetSurfaceForId(id);
-  if (!surface) {
-    LOG(ERROR) << "Attempting to require callback on nonexistent surface";
-    return;
-  }
-  surface->AddDestructionDependency(sequence);
-}
-
-}  // namespace
-
 class BlimpCompositor::FrameTrackingSwapPromise : public cc::SwapPromise {
  public:
   FrameTrackingSwapPromise(
       std::unique_ptr<cc::CopyOutputRequest> copy_request,
       base::WeakPtr<BlimpCompositor> compositor,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
       : copy_request_(std::move(copy_request)),
         compositor_weak_ptr_(compositor),
         main_task_runner_(std::move(main_task_runner)) {}
   ~FrameTrackingSwapPromise() override = default;
@@ skipping 247 matching lines @@
   gfx::Size surface_size = root_pass->output_rect.size();
 
   if (!local_frame_id_.is_valid() || current_surface_size_ != surface_size) {
     DestroyDelegatedContent();
     DCHECK(layer_->children().empty());
 
     local_frame_id_ = surface_id_allocator_->GenerateId();
     current_surface_size_ = surface_size;
 
     // manager must outlive compositors using it.
+    cc::SurfaceId surface_id(surface_factory_->frame_sink_id(),
+                             local_frame_id_);
     cc::SurfaceManager* surface_manager =
         GetEmbedderDeps()->GetSurfaceManager();
-    scoped_refptr<cc::SurfaceLayer> content_layer = cc::SurfaceLayer::Create(
-        base::Bind(&SatisfyCallback, base::Unretained(surface_manager)),
-        base::Bind(&RequireCallback, base::Unretained(surface_manager)));
-    content_layer->SetSurfaceId(
-        cc::SurfaceId(surface_factory_->frame_sink_id(), local_frame_id_), 1.f,
-        surface_size);
+    auto surface_embedding = base::MakeUnique<cc::DirectSurfaceEmbedding>(
+        cc::SurfaceInfo(surface_id, 1.f, surface_size), surface_manager);
+    scoped_refptr<cc::SurfaceLayer> content_layer = cc::SurfaceLayer::Create();
+    content_layer->SetSurfaceEmbedding(std::move(surface_embedding));
     content_layer->SetBounds(current_surface_size_);
     content_layer->SetIsDrawable(true);
     content_layer->SetContentsOpaque(true);
 
     layer_->AddChild(content_layer);
   }
 
   surface_factory_->SubmitCompositorFrame(
       local_frame_id_, std::move(frame),
       base::Bind(&BlimpCompositor::SubmitCompositorFrameAck,
@@ skipping 112 matching lines @@
   // Destroy the old LayerTreeHost state.
   host_.reset();
 
   // Cancel any outstanding CompositorFrameSink requests.  That way if we get an
   // async callback related to the old request we know to drop it.
   compositor_frame_sink_request_pending_ = false;
 }
 
 }  // namespace client
 }  // namespace blimp