"Buttery Smooth" Tab Capture.

content/browser/renderer_host/render_widget_host_view_mac.mm

 // Copyright (c) 2012 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/renderer_host/render_widget_host_view_mac.h"
 
 #import <objc/runtime.h>
 #include <OpenGL/gl.h>
 #include <QuartzCore/QuartzCore.h>
 
@@ skipping 52 matching lines @@
 #include "third_party/WebKit/public/web/mac/WebInputEventFactory.h"
 #import "third_party/mozilla/ComplexTextInputPanel.h"
 #include "ui/base/cocoa/animation_utils.h"
 #import "ui/base/cocoa/fullscreen_window_manager.h"
 #import "ui/base/cocoa/underlay_opengl_hosting_window.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/base/layout.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/display.h"
+#include "ui/gfx/frame_time.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gl/gl_switches.h"
 
 using content::BrowserAccessibility;
 using content::BrowserAccessibilityManager;
 using content::EditCommand;
@@ skipping 761 matching lines @@
     // Note that on some headless systems, the display link will fail to be
     // created, so this should not be a fatal error.
     LOG(ERROR) << "Failed to create display link.";
   }
 }
 
 void RenderWidgetHostViewMac::SendVSyncParametersToRenderer() {
   if (!render_widget_host_ || !display_link_)
     return;
 
-  base::TimeTicks timebase;
-  base::TimeDelta interval;
-  if (!display_link_->GetVSyncParameters(&timebase, &interval))
+  if (!display_link_->GetVSyncParameters(&vsync_timebase_, &vsync_interval_)) {
+    vsync_timebase_ = base::TimeTicks();
+    vsync_interval_ = base::TimeDelta();
     return;
+  }
 
-  render_widget_host_->UpdateVSyncParameters(timebase, interval);
+  render_widget_host_->UpdateVSyncParameters(vsync_timebase_, vsync_interval_);
 }
 
 void RenderWidgetHostViewMac::UpdateBackingStoreScaleFactor() {
   if (!render_widget_host_)
     return;
 
   float new_scale_factor = ui::GetScaleFactorForNativeView(cocoa_view_);
   if (new_scale_factor == backing_store_scale_factor_)
     return;
   backing_store_scale_factor_ = new_scale_factor;
@@ skipping 533 matching lines @@
 void RenderWidgetHostViewMac::PluginImeCompositionCompleted(
     const base::string16& text, int plugin_id) {
   if (render_widget_host_) {
     render_widget_host_->Send(new ViewMsg_PluginImeCompositionCompleted(
         render_widget_host_->GetRoutingID(), text, plugin_id));
   }
 }
 
 void RenderWidgetHostViewMac::CompositorSwapBuffers(
     IOSurfaceID surface_handle,
+    const gfx::Rect& damage_rect,
     const gfx::Size& size,
     float surface_scale_factor,
     const std::vector<ui::LatencyInfo>& latency_info) {
   // Ensure that the frame be acked unless it is explicitly passed to a
   // display function.
   base::ScopedClosureRunner scoped_ack(
       base::Bind(&RenderWidgetHostViewMac::SendPendingSwapAck,
                  weak_factory_.GetWeakPtr()));
 
   if (render_widget_host_->is_hidden())
@@ skipping 38 matching lines @@
       LOG(ERROR) << "Failed SetIOSurface on CompositingIOSurfaceMac";
       return;
     }
   }
 
   // Grab video frames now that the IOSurface has been set up. Note that this
   // will be done in an offscreen context, so it is necessary to re-set the
   // current context afterward.
   bool frame_was_captured = false;
   if (frame_subscriber_) {
-    const base::TimeTicks present_time = base::TimeTicks::Now();
+    const base::TimeTicks now = gfx::FrameTime::Now();
+    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(present_time,
-                                              &frame, &callback)) {
+    if (frame_subscriber_->ShouldCaptureFrame(
+            damage_rect, present_time, &frame, &callback)) {
       // Flush the context that updated the IOSurface, to ensure that the
       // context that does the copy picks up the correct version.
       {
         gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
             compositing_iosurface_context_->cgl_context());
         glFlush();
       }
       compositing_iosurface_->CopyToVideoFrame(
           gfx::Rect(size), frame,
           base::Bind(callback, present_time));
@@ skipping 235 matching lines @@
                     gpu_host_id,
                     compositing_iosurface_ ?
                         compositing_iosurface_->GetRendererID() : 0);
 
   switch (GetSurfaceHandleType(params.surface_handle)) {
     case kSurfaceHandleTypeIOSurface: {
       IOSurfaceID io_surface_id = IOSurfaceIDFromSurfaceHandle(
           params.surface_handle);
 
       CompositorSwapBuffers(io_surface_id,
+                            gfx::Rect(),
                             params.size,
                             params.scale_factor,
                             params.latency_info);
     } break;
     case kSurfaceHandleTypeCAContext: {
       // Disable the fade-out animation as the layer is added.
       ScopedCAActionDisabler disabler;
 
       CAContextID context_id = CAContextIDFromSurfaceHandle(
           params.surface_handle);
@@ skipping 24 matching lines @@
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer");
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   AddPendingSwapAck(params.route_id,
                     gpu_host_id,
                     compositing_iosurface_ ?
                         compositing_iosurface_->GetRendererID() : 0);
-  CompositorSwapBuffers(IOSurfaceIDFromSurfaceHandle(params.surface_handle),
-                        params.surface_size,
-                        params.surface_scale_factor,
-                        params.latency_info);
+  CompositorSwapBuffers(
+      IOSurfaceIDFromSurfaceHandle(params.surface_handle),
+      gfx::Rect(params.x, params.y, params.width, params.height),
+      params.surface_size,
+      params.surface_scale_factor,
+      params.latency_info);
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSuspend() {
   if (render_widget_host_->is_hidden())
     DestroyCompositedIOSurfaceAndLayer();
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceRelease() {
   DestroyCompositedIOSurfaceAndLayer();
 }
@@ skipping 2221 matching lines @@
 
 // "-webkit-app-region: drag | no-drag" is implemented on Mac by excluding
 // regions that are not draggable. (See ControlRegionView in
 // native_app_window_cocoa.mm). This requires the render host view to be
 // draggable by default.
 - (BOOL)mouseDownCanMoveWindow {
   return YES;
 }
 
 @end