Hide compositor_frame_sink_id from RenderWidgetHostView*

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>
@@ skipping 30 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost
 
 DelegatedFrameHost::DelegatedFrameHost(const cc::FrameSinkId& frame_sink_id,
                                        DelegatedFrameHostClient* client)
     : frame_sink_id_(frame_sink_id),
       client_(client),
       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);
   factory->GetContextFactoryPrivate()->GetSurfaceManager()->RegisterFrameSinkId(
       frame_sink_id_);
   CreateCompositorFrameSinkSupport();
@@ skipping 321 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,
+void DelegatedFrameHost::DidCreateNewRendererCompositorFrameSink() {
+  ResetCompositorFrameSinkSupport();
+  CreateCompositorFrameSinkSupport();
+  has_frame_ = false;
+}
+
+void DelegatedFrameHost::SubmitCompositorFrame(
     const cc::LocalSurfaceId& local_surface_id,
     cc::CompositorFrame frame) {
 #if defined(OS_CHROMEOS)
   DCHECK(!resize_lock_ || !client_->IsAutoResizeEnabled());
 #endif
   float frame_device_scale_factor = frame.metadata.device_scale_factor;
   cc::BeginFrameAck ack(frame.metadata.begin_frame_ack);
 
   DCHECK(!frame.render_pass_list.empty());
 
@@ skipping 10 matching lines @@
 
   if (ShouldSkipFrame(frame_size_in_dip)) {
     cc::ReturnedResourceArray resources;
     cc::TransferableResource::ReturnResources(frame.resource_list, &resources);
 
     skipped_latency_info_list_.insert(skipped_latency_info_list_.end(),
                                       frame.metadata.latency_info.begin(),
                                       frame.metadata.latency_info.end());
 
     client_->DelegatedFrameHostSendReclaimCompositorResources(
-        compositor_frame_sink_id, true /* is_swap_ack*/, resources);
+        true /* is_swap_ack*/, resources);
     skipped_frames_ = true;
     BeginFrameDidNotSwap(ack);
     return;
   }
 
   if (skipped_frames_) {
     skipped_frames_ = false;
     damage_rect = gfx::Rect(frame_size);
     damage_rect_in_dip = gfx::Rect(frame_size_in_dip);
 
     // Give the same damage rect to the compositor.
     cc::RenderPass* root_pass = frame.render_pass_list.back().get();
     root_pass->damage_rect = damage_rect;
   }
 
-  if (compositor_frame_sink_id != last_compositor_frame_sink_id_) {
-    // Resource ids are scoped by the output surface.
-    // If the originating output surface doesn't match the last one, it
-    // indicates the renderer's output surface may have been recreated, in which
-    // case we should recreate the DelegatedRendererLayer, to avoid matching
-    // resources from the old one with resources from the new one which would
-    // have the same id. Changing the layer to showing painted content destroys
-    // the DelegatedRendererLayer.
-    local_surface_id_ = cc::LocalSurfaceId();
-    ResetCompositorFrameSinkSupport();
-    CreateCompositorFrameSinkSupport();
-    last_compositor_frame_sink_id_ = compositor_frame_sink_id;
-  }
-
   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();
 
@@ skipping 41 matching lines @@
 
   DidFinishFrame(ack);
 }
 
 void DelegatedFrameHost::ClearDelegatedFrame() {
   EvictDelegatedFrame();
 }
 
 void DelegatedFrameHost::DidReceiveCompositorFrameAck() {
   client_->DelegatedFrameHostSendReclaimCompositorResources(
-      last_compositor_frame_sink_id_, true /* is_swap_ack */,
-      cc::ReturnedResourceArray());
+      true /* is_swap_ack */, cc::ReturnedResourceArray());
 }
 
 void DelegatedFrameHost::ReclaimResources(
     const cc::ReturnedResourceArray& resources) {
   client_->DelegatedFrameHostSendReclaimCompositorResources(
-      last_compositor_frame_sink_id_, false /* is_swap_ack */, resources);
+      false /* is_swap_ack */, resources);
 }
 
 void DelegatedFrameHost::WillDrawSurface(const cc::LocalSurfaceId& id,
                                          const gfx::Rect& damage_rect) {
   // Frame subscribers are only interested in changes to the target surface, so
   // do not attempt capture if |damage_rect| is empty.  This prevents the draws
   // of parent surfaces from triggering extra frame captures, which can affect
   // smoothness.
   if (id != local_surface_id_ || damage_rect.IsEmpty())
     return;
@@ skipping 340 matching lines @@
   }
 
   if (!skipped_frames_) {
     latest_confirmed_begin_frame_source_id_ = ack.source_id;
     latest_confirmed_begin_frame_sequence_number_ =
         ack.latest_confirmed_sequence_number;
   }
 }
 
 }  // namespace content