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 185 matching lines @@
     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)) {
+    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, that
+      // request is still alive; and this request should be immediately aborted.
+      // Note that 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.
+      callback.Run(present_time, false);
+      return;
+    }
+    frame_subscriber_copy_request_pending_ = true;
     CopyFromCompositingSurfaceToVideoFrame(
         gfx::Rect(current_frame_size_in_dip_),
         frame,
         base::Bind(callback, present_time));
   }
 }
 
 void DelegatedFrameHost::SwapDelegatedFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::DelegatedFrameData> frame_data,
@@ skipping 565 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 128 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