Add a path to use CALayers to display content

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/CGLRenderers.h>
 #include <OpenGL/OpenGL.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/message_loop.h"
 #include "base/threading/platform_thread.h"
 #include "content/browser/renderer_host/compositing_iosurface_context_mac.h"
 #include "content/browser/renderer_host/compositing_iosurface_shader_programs_mac.h"
 #include "content/browser/renderer_host/compositing_iosurface_transformer_mac.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/browser/renderer_host/render_widget_host_view_mac.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 "third_party/skia/include/core/SkBitmap.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/gfx/size_conversions.h"
 #include "ui/surface/io_surface_support_mac.h"
@@ skipping 200 matching lines @@
     if (!pixel_buffers[i]) {
       glGenBuffersARB(1, &pixel_buffers[i]); CHECK_GL_ERROR();
     }
   }
 }
 
 
 // static
 CompositingIOSurfaceMac* CompositingIOSurfaceMac::Create(int window_number) {
   TRACE_EVENT0("browser", "CompositingIOSurfaceMac::Create");
+
+  scoped_refptr<CompositingIOSurfaceContext> context =
+      CompositingIOSurfaceContext::Get(window_number);
+  if (!context) {
+    LOG(WARNING) << "Failed to create context for IOSurface";
+    return NULL;
+  }
+
+  return Create(context);
+}
+
+CompositingIOSurfaceMac* CompositingIOSurfaceMac::Create(
+    const scoped_refptr<CompositingIOSurfaceContext>& context) {
   IOSurfaceSupport* io_surface_support = IOSurfaceSupport::Initialize();
   if (!io_surface_support) {
     LOG(WARNING) << "No IOSurface support";
     return NULL;
   }
 
-  scoped_refptr<CompositingIOSurfaceContext> context =
-      CompositingIOSurfaceContext::Get(window_number);
-
   return new CompositingIOSurfaceMac(io_surface_support,
                                      context);
 }
 
 CompositingIOSurfaceMac::CompositingIOSurfaceMac(
     IOSurfaceSupport* io_surface_support,
-    scoped_refptr<CompositingIOSurfaceContext> context)
+    const scoped_refptr<CompositingIOSurfaceContext>& context)
     : io_surface_support_(io_surface_support),
       context_(context),
       io_surface_handle_(0),
+      scale_factor_(1.f),
       texture_(0),
       finish_copy_timer_(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kFinishCopyPollingPeriodMs),
           base::Bind(&CompositingIOSurfaceMac::FinishAllCopies,
                      base::Unretained(this)),
           true),
       display_link_(0),
       display_link_stop_timer_(FROM_HERE, base::TimeDelta::FromSeconds(1),
                                this, &CompositingIOSurfaceMac::StopDisplayLink),
@@ skipping 95 matching lines @@
   CGLSetCurrentContext(0);
   context_ = nil;
 }
 
 void CompositingIOSurfaceMac::SetIOSurface(
     uint64 io_surface_handle,
     const gfx::Size& size,
     float scale_factor,
     const ui::LatencyInfo& latency_info) {
   pixel_io_surface_size_ = size;
+  scale_factor_ = scale_factor;
   dip_io_surface_size_ = gfx::ToFlooredSize(
-      gfx::ScaleSize(pixel_io_surface_size_, 1.0 / scale_factor));
+      gfx::ScaleSize(pixel_io_surface_size_, 1.0 / scale_factor_));
   CGLSetCurrentContext(context_->cgl_context());
   MapIOSurfaceToTexture(io_surface_handle);
   CGLSetCurrentContext(0);
   latency_info_.MergeWith(latency_info);
 }
 
 int CompositingIOSurfaceMac::GetRendererID() {
   GLint current_renderer_id = -1;
   if (CGLGetParameter(context_->cgl_context(),
                       kCGLCPCurrentRendererID,
                       &current_renderer_id) == kCGLNoError)
     return current_renderer_id & kCGLRendererIDMatchingMask;
   return -1;
 }
 
 void CompositingIOSurfaceMac::DrawIOSurface(
-    NSView* view,
-    float scale_factor,
-    int window_number,
-    SurfaceOrder surface_order,
-    RenderWidgetHostViewFrameSubscriber* frame_subscriber) {
+    RenderWidgetHostViewMac* render_widget_host_view) {
+  DCHECK(!render_widget_host_view->use_core_animation_);
 
+  NSView* view = render_widget_host_view->cocoa_view();
+  content::CompositingIOSurfaceMac::SurfaceOrder surface_order =
+     render_widget_host_view->allow_overlapping_views_
+     ? content::CompositingIOSurfaceMac::SURFACE_ORDER_BELOW_WINDOW
+     : content::CompositingIOSurfaceMac::SURFACE_ORDER_ABOVE_WINDOW;
+
+  SwitchToContextOnNewWindow(view, render_widget_host_view->window_number());
+  SetSurfaceOrder(context_->nsgl_context(), surface_order);
+
+  CGLSetCurrentContext(context_->cgl_context());
+  [context_->nsgl_context() setView:view];
+
+  gfx::Size window_size(NSSizeToCGSize([view frame].size));
+
+  DrawIOSurface(
+      window_size,
+      render_widget_host_view->scale_factor(),
+      render_widget_host_view->frame_subscriber(),
+      false);
+}
+
+void CompositingIOSurfaceMac::DrawIOSurface(
+    const gfx::Size& window_size,
+    float window_scale_factor,
+    RenderWidgetHostViewFrameSubscriber* frame_subscriber,
+    bool using_core_animation) {
   if (display_link_ == NULL)
     SetupCVDisplayLink();
 
-  SwitchToContextOnNewWindow(view, window_number);
-  SetSurfaceOrder(context_->nsgl_context(), surface_order);
-
-  CGLSetCurrentContext(context_->cgl_context());
-
   bool has_io_surface = MapIOSurfaceToTexture(io_surface_handle_);
-
   TRACE_EVENT1("browser", "CompositingIOSurfaceMac::DrawIOSurface",
                "has_io_surface", has_io_surface);
 
-  [context_->nsgl_context() setView:view];
-  gfx::Size window_size(NSSizeToCGSize([view frame].size));
   gfx::Size pixel_window_size = gfx::ToFlooredSize(
-      gfx::ScaleSize(window_size, scale_factor));
+      gfx::ScaleSize(window_size, window_scale_factor));
   glViewport(0, 0, pixel_window_size.width(), pixel_window_size.height());
 
   SurfaceQuad quad;
   quad.set_size(dip_io_surface_size_, pixel_io_surface_size_);
 
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
 
   // Note that the projection keeps things in view units, so the use of
   // window_size / dip_io_surface_size_ (as opposed to the pixel_ variants)
@@ skipping 79 matching lines @@
     const base::Time present_time = base::Time::Now();
     scoped_refptr<media::VideoFrame> frame;
     RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
     if (frame_subscriber->ShouldCaptureFrame(present_time, &frame, &callback)) {
       copy_done_callback = CopyToVideoFrameWithinContext(
           gfx::Rect(pixel_io_surface_size_), true, frame,
           base::Bind(callback, present_time));
     }
   }
 
-  CGLFlushDrawable(context_->cgl_context());
+  if (!using_core_animation)
+    CGLFlushDrawable(context_->cgl_context());
 
   latency_info_.swap_timestamp = base::TimeTicks::HighResNow();
   RenderWidgetHostImpl::CompositorFrameDrawn(latency_info_);
   latency_info_.Clear();
 
   // For latency_tests.cc:
   UNSHIPPED_TRACE_EVENT_INSTANT0("test_gpu", "CompositorSwapBuffersComplete",
                                  TRACE_EVENT_SCOPE_THREAD);
 
   // Try to finish previous copy requests after flush to get better pipelining.
   std::vector<base::Closure> copy_done_callbacks;
   FinishAllCopiesWithinContext(&copy_done_callbacks);
 
-  CGLSetCurrentContext(0);
+  if (!using_core_animation)
+    CGLSetCurrentContext(0);
 
   if (!copy_done_callback.is_null())
     copy_done_callbacks.push_back(copy_done_callback);
   for (size_t i = 0; i < copy_done_callbacks.size(); ++i)
     copy_done_callbacks[i].Run();
 
   StartOrContinueDisplayLink();
 
   if (!is_vsync_disabled())
     RateLimitDraws();
@@ skipping 535 matching lines @@
   }
 }
 
 gfx::Rect CompositingIOSurfaceMac::IntersectWithIOSurface(
     const gfx::Rect& rect) const {
   return gfx::IntersectRects(rect,
       gfx::ToEnclosingRect(gfx::Rect(pixel_io_surface_size_)));
 }
 
 }  // namespace content