Introduce cc::LocalFrameId and use in SurfaceFactory

content/renderer/android/synchronous_compositor_frame_sink.cc

 // Copyright 2013 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 "content/renderer/android/synchronous_compositor_frame_sink.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
@@ skipping 100 matching lines @@
     scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue)
     : cc::CompositorFrameSink(std::move(context_provider),
                               std::move(worker_context_provider)),
       routing_id_(routing_id),
       compositor_frame_sink_id_(compositor_frame_sink_id),
       registry_(registry),
       sender_(RenderThreadImpl::current()->sync_compositor_message_filter()),
       memory_policy_(0u),
       frame_swap_message_queue_(frame_swap_message_queue),
       surface_manager_(new cc::SurfaceManager),
-      surface_id_allocator_(new cc::SurfaceIdAllocator(kFrameSinkId)),
+      surface_id_allocator_(new cc::SurfaceIdAllocator()),
       surface_factory_(
           new cc::SurfaceFactory(kFrameSinkId, surface_manager_.get(), this)),
       begin_frame_source_(std::move(begin_frame_source)) {
   DCHECK(registry_);
   DCHECK(sender_);
   DCHECK(begin_frame_source_);
   thread_checker_.DetachFromThread();
   memory_policy_.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 }
@@ skipping 58 matching lines @@
 }
 
 void SynchronousCompositorFrameSink::DetachFromClient() {
   DCHECK(CalledOnValidThread());
   client_->SetBeginFrameSource(nullptr);
   // Destroy the begin frame source on the same thread it was bound on.
   begin_frame_source_ = nullptr;
   if (registered_)
     registry_->UnregisterCompositorFrameSink(routing_id_, this);
   client_->SetTreeActivationCallback(base::Closure());
-  if (!root_surface_id_.is_null()) {
-    surface_factory_->Destroy(root_surface_id_);
-    surface_factory_->Destroy(child_surface_id_);
+  if (!root_local_frame_id_.is_null()) {
+    surface_factory_->Destroy(root_local_frame_id_);
+    surface_factory_->Destroy(child_local_frame_id_);
   }
   surface_manager_->UnregisterSurfaceFactoryClient(kFrameSinkId);
   surface_manager_->InvalidateFrameSinkId(kFrameSinkId);
   software_output_surface_ = nullptr;
   display_ = nullptr;
   surface_factory_ = nullptr;
   surface_id_allocator_ = nullptr;
   surface_manager_ = nullptr;
   cc::CompositorFrameSink::DetachFromClient();
   CancelFallbackTick();
@@ skipping 13 matching lines @@
     return;
   }
 
   cc::CompositorFrame swap_frame;
 
   if (in_software_draw_) {
     // The frame we send to the client is actually just the metadata. Preserve
     // the |frame| for the software path below.
     swap_frame.metadata = frame.metadata.Clone();
 
-    if (root_surface_id_.is_null()) {
-      root_surface_id_ = surface_id_allocator_->GenerateId();
-      surface_factory_->Create(root_surface_id_);
-      child_surface_id_ = surface_id_allocator_->GenerateId();
-      surface_factory_->Create(child_surface_id_);
+    if (root_local_frame_id_.is_null()) {
+      root_local_frame_id_ = surface_id_allocator_->GenerateId();
+      surface_factory_->Create(root_local_frame_id_);
+      child_local_frame_id_ = surface_id_allocator_->GenerateId();
+      surface_factory_->Create(child_local_frame_id_);
     }
 
-    display_->SetSurfaceId(root_surface_id_,
+    display_->SetSurfaceId(cc::SurfaceId(kFrameSinkId, root_local_frame_id_),
                            frame.metadata.device_scale_factor);
 
     // The layer compositor should be giving a frame that covers the
     // |sw_viewport_for_current_draw_| but at 0,0.
     gfx::Size child_size = sw_viewport_for_current_draw_.size();
     DCHECK(gfx::Rect(child_size) ==
            frame.delegated_frame_data->render_pass_list.back()->output_rect);
 
     // Make a size that covers from 0,0 and includes the area coming from the
     // layer compositor.
@@ skipping 27 matching lines @@
     // The RenderPass has a single SurfaceDrawQuad (and SharedQuadState for it).
     auto* shared_quad_state =
         embed_render_pass->CreateAndAppendSharedQuadState();
     auto* surface_quad =
         embed_render_pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
     shared_quad_state->SetAll(
         child_transform, child_size, gfx::Rect(child_size),
         gfx::Rect() /* clip_rect */, false /* is_clipped */, 1.f /* opacity */,
         SkXfermode::kSrcOver_Mode, 0 /* sorting_context_id */);
     surface_quad->SetNew(shared_quad_state, gfx::Rect(child_size),
-                         gfx::Rect(child_size), child_surface_id_);
+                         gfx::Rect(child_size),
+                         cc::SurfaceId(kFrameSinkId, child_local_frame_id_));
 
-    surface_factory_->SubmitCompositorFrame(child_surface_id_, std::move(frame),
-                                            base::Bind(&NoOpDrawCallback));
-    surface_factory_->SubmitCompositorFrame(root_surface_id_,
+    surface_factory_->SubmitCompositorFrame(
+        child_local_frame_id_, std::move(frame), base::Bind(&NoOpDrawCallback));
+    surface_factory_->SubmitCompositorFrame(root_local_frame_id_,
                                             std::move(embed_frame),
                                             base::Bind(&NoOpDrawCallback));
     display_->DrawAndSwap();
   } else {
     // For hardware draws we send the whole frame to the client so it can draw
     // the content in it.
     swap_frame = std::move(frame);
   }
 
   sync_client_->SwapBuffers(compositor_frame_sink_id_, std::move(swap_frame));
@@ skipping 157 matching lines @@
   client_->ReclaimResources(resources);
 }
 
 void SynchronousCompositorFrameSink::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
   // Software output is synchronous and doesn't use a BeginFrameSource.
   NOTREACHED();
 }
 
 }  // namespace content