De-dupe copy requests for tab capture in DelegatedFrameHost.

content/browser/compositor/delegated_frame_host.h

 // 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.
 
 #ifndef CONTENT_BROWSER_COMPOSITOR_DELEGATED_FRAME_HOST_H_
 #define CONTENT_BROWSER_COMPOSITOR_DELEGATED_FRAME_HOST_H_
 
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/output/copy_output_result.h"
@@ skipping 119 matching lines @@
     request_copy_of_output_callback_for_testing_ = callback;
   }
 
  private:
   friend class DelegatedFrameHostClient;
   FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
                            SkippedDelegatedFrames);
   FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
                            DiscardDelegatedFramesWithLocking);
   FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraCopyRequestTest,
+                           DedupeFrameSubscriberRequests);
+  FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraCopyRequestTest,
                            DestroyedAfterCopyRequest);
 
   RenderWidgetHostViewFrameSubscriber* frame_subscriber() const {
     return frame_subscriber_.get();
   }
   bool ShouldCreateResizeLock();
   void LockResources();
   void UnlockResources();
   void RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request);
 
@@ skipping 71 matching lines @@
 
   // DelegatedFrameEvictorClient implementation.
   void EvictDelegatedFrame() override;
 
   // cc::DelegatedFrameProviderClient implementation.
   void UnusedResourcesAreAvailable() override;
 
   // cc::SurfaceFactoryClient implementation.
   void ReturnResources(const cc::ReturnedResourceArray& resources) override;
 
+  // Called to consult the current |frame_subscriber_|, to determine and maybe
+  // initiate a copy-into-video-frame request.
   void DidReceiveFrameFromRenderer(const gfx::Rect& damage_rect);
 
+  // Called when the next copy has completed for the |frame_subscriber_|, to run
+  // the next callback in the |frame_subscriber_callbacks_| queue.
+  void DeliverResultForFrameSubscriber(bool success);
+
   DelegatedFrameHostClient* const client_;
   ui::Compositor* compositor_;
 
   // True if this renders into a Surface, false if it renders into a delegated
   // layer.
   bool use_surfaces_;
 
   std::vector<base::Closure> on_compositing_did_commit_callbacks_;
 
   // The vsync manager we are observing for changes, if any.
@@ skipping 58 matching lines @@
     NO_PENDING_COMMIT,
   };
   CanLockCompositorState can_lock_compositor_;
 
   base::TimeTicks last_draw_ended_;
 
   // Subscriber that listens to frame presentation events.
   scoped_ptr<RenderWidgetHostViewFrameSubscriber> frame_subscriber_;
   std::vector<scoped_refptr<OwnedMailbox> > idle_frame_subscriber_textures_;
 
+  // Set to true if a frame was received from the renderer and a copy request
+  // was made for the frame subscriber, but drawing has not yet started.  This
+  // is used to prevent more than one copy request being executed per draw.
+  bool frame_subscriber_copy_request_pending_;
+
+  // Stores the delivery callbacks, in order, that will be executed as each of
+  // the frame subscriber's copy-into-video-frame requests completes.  The size
+  // of this queue is always equal to the number of oustanding, de-duped copy
+  // requests.
+  std::deque<base::Callback<void(bool)>> frame_subscriber_callbacks_;
+
   // Callback used to pass the output request to the layer or to a function
   // specified by a test.
   base::Callback<void(scoped_ptr<cc::CopyOutputRequest>)>
       request_copy_of_output_callback_for_testing_;
 
   // YUV readback pipeline.
   scoped_ptr<content::ReadbackYUVInterface>
       yuv_readback_pipeline_;
 
   scoped_ptr<DelegatedFrameEvictor> delegated_frame_evictor_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_COMPOSITOR_DELEGATED_FRAME_HOST_H_