Surfaces: Receive resources only once

cc/surfaces/surface.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 "cc/surfaces/surface.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 41 matching lines @@
   previous_frame_surface_id_ = surface->surface_id();
 }
 
 void Surface::QueueFrame(CompositorFrame frame, const DrawCallback& callback) {
   base::Optional<CompositorFrame> previous_pending_frame =
       std::move(pending_frame_);
   pending_frame_.reset();
 
   UpdateBlockingSurfaces(previous_pending_frame, frame);
 
+  // Receive and track the resources referenced from the CompositorFrame
+  // regardless of whether it's pending or active.
+  factory_->ReceiveFromChild(frame.resource_list);
+
   if (!blocking_surfaces_.empty()) {
     pending_frame_ = std::move(frame);
-    if (pending_frame_) {
-      factory_->ReceiveFromChild(pending_frame_->resource_list);
-      pending_referenced_surfaces_ =
-          pending_frame_->metadata.referenced_surfaces;
-      // Ask the surface manager to inform |this| when its dependencies are
-      // resolved.
-      factory_->manager()->RequestSurfaceResolution(this);
-    }
+    pending_referenced_surfaces_ = pending_frame_->metadata.referenced_surfaces;
+    // Ask the surface manager to inform |this| when its dependencies are
+    // resolved.
+    factory_->manager()->RequestSurfaceResolution(this);
   } else {
     // If there are no blockers, then immediately activate the frame.
     ActivateFrame(std::move(frame));
   }
 
   // Returns resources for the previous pending frame.
   if (previous_pending_frame)
     UnrefFrameResources(*previous_pending_frame);
 
   if (!draw_callback_.is_null())
@@ skipping 63 matching lines @@
   // of blockers.
   blocking_surfaces_.clear();
   ActivatePendingFrame();
 }
 
 void Surface::ActivatePendingFrame() {
   DCHECK(pending_frame_);
   ActivateFrame(std::move(pending_frame_.value()));
   pending_frame_.reset();
   pending_referenced_surfaces_.clear();
-  // ActiveFrame resources are now double ref-ed. Unref.
-  UnrefFrameResources(*active_frame_);
 }
 
 // A frame is activated if all its Surface ID dependences are active or a
 // deadline has hit and the frame was forcibly activated by the display
 // compositor.
 void Surface::ActivateFrame(CompositorFrame frame) {
   DCHECK(factory_);
   ClearCopyRequests();
 
   TakeLatencyInfo(&frame.metadata.latency_info);
 
   base::Optional<CompositorFrame> previous_frame = std::move(active_frame_);
   active_frame_ = std::move(frame);
 
-  factory_->ReceiveFromChild(active_frame_->resource_list);
-
   // Empty frames shouldn't be drawn and shouldn't contribute damage, so don't
   // increment frame index for them.
   if (!active_frame_->render_pass_list.empty())
     ++frame_index_;
 
   previous_frame_surface_id_ = surface_id();
 
   if (previous_frame)
     UnrefFrameResources(*previous_frame);
 
@@ skipping 127 matching lines @@
 void Surface::ClearCopyRequests() {
   if (active_frame_) {
     for (const auto& render_pass : active_frame_->render_pass_list) {
       for (const auto& copy_request : render_pass->copy_requests)
         copy_request->SendEmptyResult();
     }
   }
 }
 
 }  // namespace cc