Don't delete CopyOutputRequests when queueing a new Surface frame.

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 13 matching lines @@
 static const int kFrameIndexStart = 2;
 
 Surface::Surface(const SurfaceId& id, base::WeakPtr<SurfaceFactory> factory)
     : surface_id_(id),
       previous_frame_surface_id_(id),
       factory_(factory),
       frame_index_(kFrameIndexStart),
       destroyed_(false) {}
 
 Surface::~Surface() {
   ClearCopyRequests();

[danakj, 2017/02/23 22:52:28]

Can you change this things name maybe so it doesn't look as redundant with the
new code below?

+  for (auto& request : copy_requests_)
+    request->SendEmptyResult();
   if (factory_) {
     if (pending_frame_)
       UnrefFrameResources(*pending_frame_);
     if (active_frame_)
       UnrefFrameResources(*active_frame_);
   }
   if (!draw_callback_.is_null())
     draw_callback_.Run();
 
   for (auto& observer : observers_)
@@ skipping 49 matching lines @@
   active_frame_.reset();
 }
 
 void Surface::RequestCopyOfOutput(
     std::unique_ptr<CopyOutputRequest> copy_request) {
   if (!active_frame_ || active_frame_->render_pass_list.empty()) {
     copy_request->SendEmptyResult();
     return;
   }
 
-  std::vector<std::unique_ptr<CopyOutputRequest>>& copy_requests =
-      active_frame_->render_pass_list.back()->copy_requests;
-
   if (copy_request->has_source()) {
     const base::UnguessableToken& source = copy_request->source();
     // Remove existing CopyOutputRequests made on the Surface by the same
     // source.
     auto to_remove =
-        std::remove_if(copy_requests.begin(), copy_requests.end(),
+        std::remove_if(copy_requests_.begin(), copy_requests_.end(),
                        [&source](const std::unique_ptr<CopyOutputRequest>& x) {
                          return x->has_source() && x->source() == source;
                        });
-    copy_requests.erase(to_remove, copy_requests.end());
+    copy_requests_.erase(to_remove, copy_requests_.end());
   }
-  copy_requests.push_back(std::move(copy_request));
+  copy_requests_.push_back(std::move(copy_request));
 }
 
 void Surface::NotifySurfaceIdAvailable(const SurfaceId& surface_id) {
   auto it = blocking_surfaces_.find(surface_id);
   // This surface may no longer have blockers if the deadline has passed.
   if (it == blocking_surfaces_.end())
     return;
 
   blocking_surfaces_.erase(it);
 
@@ skipping 116 matching lines @@
   if (!active_frame_)
     return;
 
   for (const auto& render_pass : active_frame_->render_pass_list) {
     for (auto& request : render_pass->copy_requests) {
       copy_requests->insert(
           std::make_pair(render_pass->id, std::move(request)));
     }
     render_pass->copy_requests.clear();
   }
+
+  if (active_frame_->render_pass_list.size() > 0) {
+    int root_pass_id = active_frame_->render_pass_list.back()->id;
+    for (auto& request : copy_requests_) {
+      copy_requests->insert(std::make_pair(root_pass_id, std::move(request)));
+    }
+    copy_requests_.clear();
+  } else {
+    for (auto& request : copy_requests_)
+      request->SendEmptyResult();
+    copy_requests_.clear();
+  }
 }
 
 const CompositorFrame& Surface::GetActiveFrame() const {
   DCHECK(active_frame_);
   return active_frame_.value();
 }
 
 const CompositorFrame& Surface::GetPendingFrame() {
   DCHECK(pending_frame_);
   return pending_frame_.value();
@@ skipping 49 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