Use surface copy requests for layout tests.

cc/test/test_delegating_output_surface.cc

 // Copyright 2016 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/test/test_delegating_output_surface.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "cc/output/begin_frame_args.h"
+#include "cc/output/copy_output_request.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/test/begin_frame_args_test.h"
 
 static constexpr uint32_t kCompositorClientId = 1;
 
 namespace cc {
 
 TestDelegatingOutputSurface::TestDelegatingOutputSurface(
     scoped_refptr<ContextProvider> compositor_context_provider,
     scoped_refptr<ContextProvider> worker_context_provider,
@@ skipping 29 matching lines @@
 
   capabilities_.delegated_rendering = true;
   // Since this OutputSurface and the Display are tightly coupled and in the
   // same process/thread, the LayerTreeHostImpl can reclaim resources from
   // the Display.
   capabilities_.can_force_reclaim_resources = true;
   capabilities_.delegated_sync_points_required =
       !context_shared_with_compositor;
 }
 
-TestDelegatingOutputSurface::~TestDelegatingOutputSurface() {}
+TestDelegatingOutputSurface::~TestDelegatingOutputSurface() {
+  DCHECK(copy_requests_.empty());
+}
+
+void TestDelegatingOutputSurface::RequestCopyOfOutput(
+    std::unique_ptr<CopyOutputRequest> request) {
+  copy_requests_.push_back(std::move(request));
+}
 
 bool TestDelegatingOutputSurface::BindToClient(OutputSurfaceClient* client) {
   if (!OutputSurface::BindToClient(client))
     return false;
 
   // We want the Display's output surface to hear about lost context, and since
   // this shares a context with it (when delegated_sync_points_required is
   // false), we should not be listening for lost context callbacks on the
   // context here.
   if (!capabilities_.delegated_sync_points_required && context_provider())
@@ skipping 37 matching lines @@
 
   gfx::Size frame_size =
       frame.delegated_frame_data->render_pass_list.back()->output_rect.size();
   display_->Resize(frame_size);
 
   surface_factory_->SubmitCompositorFrame(
       delegated_surface_id_, std::move(frame),
       base::Bind(&TestDelegatingOutputSurface::DrawCallback,
                  weak_ptrs_.GetWeakPtr()));
 
+  for (std::unique_ptr<CopyOutputRequest>& copy_request : copy_requests_)
+    surface_factory_->RequestCopyOfSurface(delegated_surface_id_,
+                                           std::move(copy_request));
+  copy_requests_.clear();
+
   if (!display_->has_scheduler())
     display_->DrawAndSwap();
 }
 
 void TestDelegatingOutputSurface::DrawCallback() {
   client_->DidSwapBuffersComplete();
 }
 
 void TestDelegatingOutputSurface::ForceReclaimResources() {
   if (capabilities_.can_force_reclaim_resources &&
@@ skipping 28 matching lines @@
 void TestDelegatingOutputSurface::DisplayOutputSurfaceLost() {
   DidLoseOutputSurface();
 }
 
 void TestDelegatingOutputSurface::DisplaySetMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
   SetMemoryPolicy(policy);
 }
 
 }  // namespace cc