RendererCompositorFrameSink should handle local surface id allocation

content/browser/renderer_host/delegated_frame_host.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 "content/browser/renderer_host/delegated_frame_host.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/default_tick_clock.h"
 #include "cc/base/switches.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/surfaces/compositor_frame_sink_support.h"
-#include "cc/surfaces/local_surface_id_allocator.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_hittest.h"
 #include "cc/surfaces/surface_manager.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/compositor/surface_utils.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/renderer_host/render_widget_host_view_frame_subscriber.h"
 #include "content/browser/renderer_host/resize_lock.h"
 #include "content/public/common/content_switches.h"
@@ skipping 17 matching lines @@
       compositor_(nullptr),
       tick_clock_(new base::DefaultTickClock()),
       last_compositor_frame_sink_id_(0),
       skipped_frames_(false),
       background_color_(SK_ColorRED),
       current_scale_factor_(1.f),
       can_lock_compositor_(YES_CAN_LOCK),
       delegated_frame_evictor_(new DelegatedFrameEvictor(this)) {
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   factory->GetContextFactory()->AddObserver(this);
-  id_allocator_.reset(new cc::LocalSurfaceIdAllocator());
   factory->GetContextFactoryPrivate()->GetSurfaceManager()->RegisterFrameSinkId(
       frame_sink_id_);
   CreateCompositorFrameSinkSupport();
   begin_frame_source_ = base::MakeUnique<cc::ExternalBeginFrameSource>(this);
   client_->SetBeginFrameSource(begin_frame_source_.get());
 }
 
 void DelegatedFrameHost::WasShown(const ui::LatencyInfo& latency_info) {
   delegated_frame_evictor_->SetVisible(true);
 
@@ skipping 296 matching lines @@
   // To avoid unnecessary browser composites, try to go directly to the Surface
   // rather than through the Layer (which goes through the browser compositor).
   if (has_frame_ && request_copy_of_output_callback_for_testing_.is_null()) {
     support_->RequestCopyOfSurface(std::move(request));
   } else {
     RequestCopyOfOutput(std::move(request));
   }
 }
 
 void DelegatedFrameHost::SwapDelegatedFrame(uint32_t compositor_frame_sink_id,
+                                            cc::LocalSurfaceId local_surface_id,

[Fady Samuel, 2017/03/15 12:05:48]

const cc::LocalSurfaceId&

[Saman Sami, 2017/03/16 18:33:07]

Done.

                                             cc::CompositorFrame frame) {
 #if defined(OS_CHROMEOS)
   DCHECK(!resize_lock_ || !client_->IsAutoResizeEnabled());
 #endif
   float frame_device_scale_factor = frame.metadata.device_scale_factor;
 
   DCHECK(!frame.render_pass_list.empty());
 
   cc::RenderPass* root_pass = frame.render_pass_list.back().get();
 
@@ skipping 46 matching lines @@
 
   background_color_ = frame.metadata.root_background_color;
 
   if (frame_size.IsEmpty()) {
     DCHECK(frame.resource_list.empty());
     EvictDelegatedFrame();
   } else {
     ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
     cc::SurfaceManager* manager =
         factory->GetContextFactoryPrivate()->GetSurfaceManager();
-    bool allocated_new_local_surface_id = false;
-    if (!local_surface_id_.is_valid() || frame_size != current_surface_size_ ||
-        frame_size_in_dip != current_frame_size_in_dip_) {
-      local_surface_id_ = id_allocator_->GenerateId();
-      allocated_new_local_surface_id = true;
-    }
 
     frame.metadata.latency_info.insert(frame.metadata.latency_info.end(),
                                        skipped_latency_info_list_.begin(),
                                        skipped_latency_info_list_.end());
     skipped_latency_info_list_.clear();
 
-    support_->SubmitCompositorFrame(local_surface_id_, std::move(frame));
+    support_->SubmitCompositorFrame(local_surface_id, std::move(frame));
 
-    if (allocated_new_local_surface_id || !has_frame_) {
+    if (local_surface_id != local_surface_id_ || !has_frame_) {
       // manager must outlive compositors using it.
-      cc::SurfaceId surface_id(frame_sink_id_, local_surface_id_);
+      cc::SurfaceId surface_id(frame_sink_id_, local_surface_id);
       cc::SurfaceInfo surface_info(surface_id, frame_device_scale_factor,
                                    frame_size);
       client_->DelegatedFrameHostGetLayer()->SetShowPrimarySurface(
           surface_info, manager->reference_factory());
       current_surface_size_ = frame_size;
       current_scale_factor_ = frame_device_scale_factor;
     }
 
     has_frame_ = true;
   }
+  local_surface_id_ = local_surface_id;
+
   released_front_lock_ = NULL;
   current_frame_size_in_dip_ = frame_size_in_dip;
   CheckResizeLock();
 
   UpdateGutters();
 
   if (!damage_rect_in_dip.IsEmpty()) {
     client_->DelegatedFrameHostGetLayer()->OnDelegatedFrameDamage(
         damage_rect_in_dip);
   }
@@ skipping 369 matching lines @@
 
 void DelegatedFrameHost::ResetCompositorFrameSinkSupport() {
   if (!support_)
     return;
   if (compositor_)
     compositor_->RemoveFrameSink(frame_sink_id_);
   support_.reset();
 }
 
 }  // namespace content