De-dupe copy requests for tab capture in DelegatedFrameHost.

content/browser/compositor/delegated_frame_host.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 "content/browser/compositor/delegated_frame_host.h"
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
@@ skipping 46 matching lines @@
 
 DelegatedFrameHost::DelegatedFrameHost(DelegatedFrameHostClient* client)
     : client_(client),
       compositor_(nullptr),
       use_surfaces_(UseSurfacesEnabled()),
       last_output_surface_id_(0),
       pending_delegated_ack_count_(0),
       skipped_frames_(false),
       current_scale_factor_(1.f),
       can_lock_compositor_(YES_CAN_LOCK),
+      frame_subscriber_copy_request_pending_(false),
       delegated_frame_evictor_(new DelegatedFrameEvictor(this)) {
   ImageTransportFactory::GetInstance()->AddObserver(this);
 }
 
 void DelegatedFrameHost::WasShown(const ui::LatencyInfo& latency_info) {
   delegated_frame_evictor_->SetVisible(true);
 
   if (surface_id_.is_null() && !frame_provider_.get() &&
       !released_front_lock_.get()) {
     if (compositor_)
@@ skipping 183 matching lines @@
   base::TimeTicks present_time;
   if (vsync_timebase_.is_null() || vsync_interval_ <= base::TimeDelta()) {
     present_time = now;
   } else {
     const int64 intervals_elapsed = (now - vsync_timebase_) / vsync_interval_;
     present_time = vsync_timebase_ + (intervals_elapsed + 1) * vsync_interval_;
   }
 
   scoped_refptr<media::VideoFrame> frame;
   RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
-  if (frame_subscriber()->ShouldCaptureFrame(damage_rect, present_time,
-                                             &frame, &callback)) {
-    CopyFromCompositingSurfaceToVideoFrame(
-        gfx::Rect(current_frame_size_in_dip_),
-        frame,
-        base::Bind(callback, present_time));
+  if (!frame_subscriber()->ShouldCaptureFrame(damage_rect, present_time,
+                                              &frame, &callback))
+    return;
+
+  if (frame_subscriber_copy_request_pending_) {
+    // A copy request was made for the previous frame from the renderer, but
+    // drawing never started (which executes the request).  Therefore, the
+    // prior request is to be aborted.  This de-duping check must be done after
+    // the call to ShouldCaptureFrame() above, since the frame subscriber makes
+    // decisions based on the renderer's intentions, and not the performance of
+    // the browser compositor.
+    DCHECK(!frame_subscriber_callbacks_.empty());
+    frame_subscriber_callbacks_.back().Run(false);
+    frame_subscriber_callbacks_.back() = base::Bind(callback, present_time);
+    return;
   }
+
+  // Start a new copy request.
+  frame_subscriber_copy_request_pending_ = true;
+  frame_subscriber_callbacks_.push_back(base::Bind(callback, present_time));
+  CopyFromCompositingSurfaceToVideoFrame(
+      gfx::Rect(current_frame_size_in_dip_),
+      frame,
+      base::Bind(&DelegatedFrameHost::DeliverResultForFrameSubscriber,
+                 AsWeakPtr()));
+}
+
+void DelegatedFrameHost::DeliverResultForFrameSubscriber(bool success) {
+  DCHECK(!frame_subscriber_callbacks_.empty());
+  frame_subscriber_callbacks_.front().Run(success);
+  frame_subscriber_callbacks_.pop_front();
 }
 
 void DelegatedFrameHost::SwapDelegatedFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::DelegatedFrameData> frame_data,
     float frame_device_scale_factor,
     const std::vector<ui::LatencyInfo>& latency_info) {
   DCHECK(!frame_data->render_pass_list.empty());
 
   cc::RenderPass* root_pass = frame_data->render_pass_list.back();
@@ skipping 560 matching lines @@
     // We may have had a resize while we had the lock (e.g. if the lock expired,
     // or if the UI still gave us some resizes), so make sure we grab a new lock
     // if necessary.
     MaybeCreateResizeLock();
   }
 }
 
 void DelegatedFrameHost::OnCompositingStarted(
     ui::Compositor* compositor, base::TimeTicks start_time) {
   last_draw_ended_ = start_time;
+  frame_subscriber_copy_request_pending_ = false;
 }
 
 void DelegatedFrameHost::OnCompositingEnded(
     ui::Compositor* compositor) {
 }
 
 void DelegatedFrameHost::OnCompositingAborted(ui::Compositor* compositor) {
 }
 
 void DelegatedFrameHost::OnCompositingLockStateChanged(
@@ skipping 29 matching lines @@
   idle_frame_subscriber_textures_.clear();
   yuv_readback_pipeline_.reset();
 
   client_->DelegatedFrameHostOnLostCompositorResources();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, private:
 
 DelegatedFrameHost::~DelegatedFrameHost() {
+  while (!frame_subscriber_callbacks_.empty()) {
+    frame_subscriber_callbacks_.front().Run(false);
+    frame_subscriber_callbacks_.pop_front();
+  }
+
   DCHECK(!compositor_);
   ImageTransportFactory::GetInstance()->RemoveObserver(this);
 
   if (!surface_id_.is_null())
     surface_factory_->Destroy(surface_id_);
   if (resource_collection_.get())
     resource_collection_->SetClient(NULL);
 
   DCHECK(!vsync_manager_.get());
 }
@@ skipping 79 matching lines @@
     cc::SurfaceManager* manager = factory->GetSurfaceManager();
     new_layer->SetShowSurface(
         surface_id_, base::Bind(&SatisfyCallback, base::Unretained(manager)),
         base::Bind(&RequireCallback, base::Unretained(manager)),
         current_surface_size_, current_scale_factor_,
         current_frame_size_in_dip_);
   }
 }
 
 }  // namespace content