Define frame subscription interface and implementation on Mac

content/browser/renderer_host/compositing_iosurface_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/compositing_iosurface_mac.h"
 
 #include <OpenGL/OpenGL.h>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/mac/mac_util.h"
 #include "base/message_loop.h"
 #include "base/threading/platform_thread.h"
 #include "content/common/content_constants_internal.h"
+#include "content/port/browser/render_widget_host_view_frame_subscriber.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "media/base/video_util.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/gpu_switching_manager.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/surface/io_surface_support_mac.h"
 
@@ skipping 315 matching lines @@
 }
 
 void CompositingIOSurfaceMac::SetIOSurface(uint64 io_surface_handle,
                                            const gfx::Size& size) {
   pixel_io_surface_size_ = size;
   CGLSetCurrentContext(cglContext_);
   MapIOSurfaceToTexture(io_surface_handle);
   CGLSetCurrentContext(0);
 }
 
-void CompositingIOSurfaceMac::DrawIOSurface(NSView* view, float scale_factor) {
+void CompositingIOSurfaceMac::DrawIOSurface(
+    NSView* view, float scale_factor,
+    RenderWidgetHostViewFrameSubscriber* frame_subscriber) {
   CGLSetCurrentContext(cglContext_);
 
   bool has_io_surface = MapIOSurfaceToTexture(io_surface_handle_);
 
   TRACE_EVENT1("browser", "CompositingIOSurfaceMac::DrawIOSurface",
                "has_io_surface", has_io_surface);
 
   [glContext_ setView:view];
   gfx::Size window_size(NSSizeToCGSize([view frame].size));
   gfx::Size pixel_window_size = gfx::ToFlooredSize(
@@ skipping 80 matching lines @@
 
   if (use_glfinish_workaround) {
     TRACE_EVENT0("gpu", "glFinish");
     // http://crbug.com/123409 : work around bugs in graphics driver on
     // MacBook Air with Intel HD graphics, and possibly on other models,
     // by forcing the graphics pipeline to be completely drained at this
     // point.
     glFinish();
   }
 
+  base::Closure copy_done_callback;
+  if (frame_subscriber) {
+    scoped_refptr<media::VideoFrame> frame;
+    RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
+    bool should_copy = frame_subscriber->ShouldCaptureFrame(&frame, &callback);
+
+    if (should_copy) {
+      copy_done_callback = CopyToVideoFrameInternal(
+          gfx::Rect(io_surface_size_), scale_factor, frame,
+          base::Bind(callback, base::Time::Now()));
+    }
+  }
+
   CGLFlushDrawable(cglContext_);
 
   // For latency_tests.cc:
   UNSHIPPED_TRACE_EVENT_INSTANT0("test_gpu", "CompositorSwapBuffersComplete");
 
   CGLSetCurrentContext(0);
 
+  if (!copy_done_callback.is_null())
+    copy_done_callback.Run();
+
   StartOrContinueDisplayLink();
 
   if (!is_vsync_disabled_)
     RateLimitDraws();
 }
 
 void CompositingIOSurfaceMac::CopyTo(
       const gfx::Rect& src_pixel_subrect,
       float src_scale_factor,
       const gfx::Size& dst_pixel_size,
@@ skipping 28 matching lines @@
     callback.Run(ret, out);
   }
 }
 
 void CompositingIOSurfaceMac::CopyToVideoFrame(
     const gfx::Rect& requested_src_subrect,
     float src_scale_factor,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(bool)>& callback) {
   CGLSetCurrentContext(cglContext_);
+  base::Closure done_callback = CopyToVideoFrameInternal(requested_src_subrect,
+                                                         src_scale_factor,
+                                                         target, callback);
+  CGLSetCurrentContext(0);
 
+  if (done_callback.is_null())
+    return;
+  done_callback.Run();
+}
+
+base::Closure CompositingIOSurfaceMac::CopyToVideoFrameInternal(
+    const gfx::Rect& requested_src_subrect,
+    float src_scale_factor,
+    const scoped_refptr<media::VideoFrame>& target,
+    const base::Callback<void(bool)>& callback) {
   // Using PBO crashes on Intel drivers but not on newer Mountain Lion
   // systems. See bug http://crbug.com/152225.
   const bool async_copy = HasPixelBufferObjectExtension() &&
       (base::mac::IsOSMountainLionOrLater() || !IsVendorIntel());
 
   gfx::Rect region_in_frame =
       media::ComputeLetterboxRegion(gfx::Rect(target->coded_size()),
                                     requested_src_subrect.size());
   // Make coordinates and sizes even because we letterbox in YUV space right
   // now (see CopyRGBToVideoFrame). They need to be even for the UV samples to
@@ skipping 21 matching lines @@
       SkAutoLockPixels bitmap_lock(out);
       media::CopyRGBToVideoFrame(
           reinterpret_cast<const uint8*>(out.getPixels()),
           region_in_frame.width() * 4,
           region_in_frame,
           target.get());
       ret = true;
     }
   }
 
-  CGLSetCurrentContext(0);
-
   if (!ret) {
     VLOG(1) << "Failed to copy IOSurface to video frame, asynchronous mode: "
             << async_copy;
   }
 
   if (async_copy) {
+    // Asynchronous copy failed, return a callback to be executed now.
     if (!ret)
-      callback.Run(false);
+      return base::Bind(callback, false);
+
+    // Asynchronous copy started, return a null closure.
+    return base::Closure();
   } else {
-    callback.Run(ret);
+    // Synchronous copy, return a callback to be executed now.
+    return base::Bind(callback, ret);
   }
 }
 
 bool CompositingIOSurfaceMac::MapIOSurfaceToTexture(
     uint64 io_surface_handle) {
   if (io_surface_.get() && io_surface_handle == io_surface_handle_)
     return true;
 
   TRACE_EVENT0("browser", "CompositingIOSurfaceMac::MapIOSurfaceToTexture");
   UnrefIOSurfaceWithContextCurrent();
@@ skipping 416 matching lines @@
 }
 
 gfx::Rect CompositingIOSurfaceMac::IntersectWithIOSurface(
     const gfx::Rect& rect, float scale_factor) const {
   return gfx::IntersectRects(rect,
       gfx::ToEnclosingRect(gfx::ScaleRect(gfx::Rect(io_surface_size_),
                                           scale_factor)));
 }
 
 }  // namespace content