Avoid unnecessary LocalSurfaceId allocation in RenderWidgetHostViewChildFrame/Guest

content/browser/frame_host/render_widget_host_view_child_frame.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/frame_host/render_widget_host_view_child_frame.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 117 matching lines @@
 void RenderWidgetHostViewChildFrame::Focus() {
 }
 
 bool RenderWidgetHostViewChildFrame::HasFocus() const {
   if (frame_connector_)
     return frame_connector_->HasFocus();
   return false;
 }
 
 bool RenderWidgetHostViewChildFrame::IsSurfaceAvailableForCopy() const {
-  return local_surface_id_.is_valid();
+  return has_frame_;
 }
 
 void RenderWidgetHostViewChildFrame::Show() {
   if (!host_->is_hidden())
     return;
   host_->WasShown(ui::LatencyInfo());
 }
 
 void RenderWidgetHostViewChildFrame::Hide() {
   if (host_->is_hidden())
@@ skipping 193 matching lines @@
 }
 
 void RenderWidgetHostViewChildFrame::DidReceiveCompositorFrameAck() {
   if (!host_)
     return;
   host_->Send(new ViewMsg_ReclaimCompositorResources(
       host_->GetRoutingID(), last_compositor_frame_sink_id_,
       true /* is_swap_ack */, cc::ReturnedResourceArray()));
 }
 
-bool RenderWidgetHostViewChildFrame::ShouldCreateNewSurfaceId(
-    uint32_t compositor_frame_sink_id,
-    const cc::CompositorFrame& frame) {
-  gfx::Size new_frame_size = frame.render_pass_list.back()->output_rect.size();
-  float new_scale_factor = frame.metadata.device_scale_factor;
-
-  return compositor_frame_sink_id != last_compositor_frame_sink_id_ ||
-         new_frame_size != current_surface_size_ ||
-         new_scale_factor != current_surface_scale_factor_;
-}
-
 void RenderWidgetHostViewChildFrame::ProcessCompositorFrame(
     uint32_t compositor_frame_sink_id,
     cc::CompositorFrame frame) {
-  if (ShouldCreateNewSurfaceId(compositor_frame_sink_id, frame)) {
-    ClearCompositorSurfaceIfNecessary();
-    // If the renderer changed its frame sink, reset the
-    // CompositorFrameSinkSupport to avoid returning stale resources.
-    if (compositor_frame_sink_id != last_compositor_frame_sink_id_) {
-      ResetCompositorFrameSinkSupport();
-      CreateCompositorFrameSinkSupport();
-    }
+  // If the renderer changed its frame sink, reset the
+  // CompositorFrameSinkSupport to avoid returning stale resources.
+  if (compositor_frame_sink_id != last_compositor_frame_sink_id_) {
+    ResetCompositorFrameSinkSupport();
+    CreateCompositorFrameSinkSupport();
     last_compositor_frame_sink_id_ = compositor_frame_sink_id;
+    local_surface_id_ = cc::LocalSurfaceId();
+  }
+
+  gfx::Size new_frame_size = frame.render_pass_list.back()->output_rect.size();
+  float new_scale_factor = frame.metadata.device_scale_factor;
+  bool allocated_new_local_surface_id = false;
+  if (!local_surface_id_.is_valid() ||
+      new_frame_size != current_surface_size_ ||
+      new_scale_factor != current_surface_scale_factor_) {
+    local_surface_id_ = id_allocator_->GenerateId();
     current_surface_size_ = frame.render_pass_list.back()->output_rect.size();
     current_surface_scale_factor_ = frame.metadata.device_scale_factor;
-  }
-
-  bool allocated_new_local_surface_id = false;
-  if (!local_surface_id_.is_valid()) {
-    local_surface_id_ = id_allocator_->GenerateId();
     allocated_new_local_surface_id = true;
   }
 
   support_->SubmitCompositorFrame(local_surface_id_, std::move(frame));
-  if (allocated_new_local_surface_id)
+  has_frame_ = true;
+
+  if (allocated_new_local_surface_id || HasEmbedderChanged())
     SendSurfaceInfoToEmbedder();
   ProcessFrameSwappedCallbacks();
 }
 
 void RenderWidgetHostViewChildFrame::SendSurfaceInfoToEmbedder() {
   cc::SurfaceSequence sequence =
       cc::SurfaceSequence(frame_sink_id_, next_surface_sequence_++);
   cc::SurfaceManager* manager = GetSurfaceManager();
   cc::SurfaceId surface_id(frame_sink_id_, local_surface_id_);
   // The renderer process will satisfy this dependency when it creates a
   // SurfaceLayer.
-  manager->GetSurfaceForId(surface_id)->AddDestructionDependency(sequence);
+  manager->RequireSequence(surface_id, sequence);
   cc::SurfaceInfo surface_info(surface_id, current_surface_scale_factor_,
                                current_surface_size_);
   SendSurfaceInfoToEmbedderImpl(surface_info, sequence);
 }
 
 void RenderWidgetHostViewChildFrame::SendSurfaceInfoToEmbedderImpl(
     const cc::SurfaceInfo& surface_info,
     const cc::SurfaceSequence& sequence) {
   frame_connector_->SetChildFrameSurface(surface_info, sequence);
 }
@@ skipping 259 matching lines @@
 }
 
 BrowserAccessibilityManager*
 RenderWidgetHostViewChildFrame::CreateBrowserAccessibilityManager(
     BrowserAccessibilityDelegate* delegate, bool for_root_frame) {
   return BrowserAccessibilityManager::Create(
       BrowserAccessibilityManager::GetEmptyDocument(), delegate);
 }
 
 void RenderWidgetHostViewChildFrame::ClearCompositorSurfaceIfNecessary() {
-  if (support_)
-    support_->EvictFrame();
-  local_surface_id_ = cc::LocalSurfaceId();
+  if (!support_)
+    return;
+  support_->EvictFrame();
+  has_frame_ = false;
 }
 
 bool RenderWidgetHostViewChildFrame::IsChildFrameForTesting() const {
   return true;
 }
 
 cc::SurfaceId RenderWidgetHostViewChildFrame::SurfaceIdForTesting() const {
   return cc::SurfaceId(frame_sink_id_, local_surface_id_);
 };
 
@@ skipping 14 matching lines @@
 void RenderWidgetHostViewChildFrame::ResetCompositorFrameSinkSupport() {
   if (!support_)
     return;
   if (parent_frame_sink_id_.is_valid()) {
     GetSurfaceManager()->UnregisterFrameSinkHierarchy(parent_frame_sink_id_,
                                                       frame_sink_id_);
   }
   support_.reset();
 }
 
+bool RenderWidgetHostViewChildFrame::HasEmbedderChanged() {
+  return false;
+}
+
 }  // namespace content