Retain references to surfaces from both active AND pending CompositorFrames

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 45 matching lines @@
   base::Optional<CompositorFrame> previous_pending_frame =
       std::move(pending_frame_);
   pending_frame_.reset();
 
   UpdateBlockingSurfaces(previous_pending_frame, frame);
 
   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);
     }
   } else {
     // If there are no blockers, then immediately activate the frame.
     ActivateFrame(std::move(frame));
   }
 
   // Returns resources for the previous pending frame.
@@ skipping 66 matching lines @@
   // If a frame is being activated because of a deadline, then clear its set
   // 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);
 
   referenced_surfaces_ = active_frame_->metadata.referenced_surfaces;

[vmpstr, 2017/02/10 00:24:40]

out of curiosity, why is this a member variable? If active_frame_ is already a
member, then we should just be returning
active_frame_->metadata.referenced_surfaces when requested? (I haven't searched
for all uses, I'm hoping you just know the answer)

[Fady Samuel, 2017/02/10 00:55:30]

It isn't really. I can return a pointer to
active_frame_->metadata.referenced_surfaces if active_frame_ is available for
example, or a nullptr, but all callsites need to check for nullptr. I added a
TODO on the member variables to do that.

 
   for (auto& observer : observers_)
     observer.OnSurfaceActivated(this);
 }
 
 void Surface::UpdateBlockingSurfaces(
     const base::Optional<CompositorFrame>& previous_pending_frame,
     const CompositorFrame& current_frame) {
   // If there is no SurfaceDependencyTracker installed then the |current_frame|
   // does not block on anything.
@@ skipping 116 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