Use a separate NSView to draw browser composited content

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 <QuartzCore/QuartzCore.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #import "content/browser/accessibility/browser_accessibility_cocoa.h"
 #include "content/browser/accessibility/browser_accessibility_manager_mac.h"
+#include "content/browser/compositor/browser_compositor_view_mac.h"
 #include "content/browser/compositor/resize_lock.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/compositing_iosurface_context_mac.h"
 #include "content/browser/renderer_host/compositing_iosurface_layer_mac.h"
 #include "content/browser/renderer_host/compositing_iosurface_mac.h"
 #include "content/browser/renderer_host/render_widget_helper.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #import "content/browser/renderer_host/render_widget_host_view_mac_dictionary_helper.h"
 #import "content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper.h"
+#import "content/browser/renderer_host/software_layer_mac.h"
 #import "content/browser/renderer_host/text_input_client_mac.h"
 #include "content/common/accessibility_messages.h"
 #include "content/common/edit_command.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/common/webplugin_geometry.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 352 matching lines @@
 }
 
 }  // namespace
 
 namespace content {
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, public:
 
 ui::Compositor* RenderWidgetHostViewMac::GetCompositor() const {
-  return compositor_.get();
+  return [browser_compositor_view_ compositor];
 }
 
 ui::Layer* RenderWidgetHostViewMac::GetLayer() {
   return root_layer_.get();
 }
 
 RenderWidgetHostImpl* RenderWidgetHostViewMac::GetHost() {
   return render_widget_host_;
 }
 
 void RenderWidgetHostViewMac::SchedulePaintInRect(
     const gfx::Rect& damage_rect_in_dip) {
-  compositor_->ScheduleFullRedraw();
+  [browser_compositor_view_ compositor]->ScheduleFullRedraw();
 }
 
 bool RenderWidgetHostViewMac::IsVisible() {
   return !render_widget_host_->is_hidden();
 }
 
 gfx::Size RenderWidgetHostViewMac::DesiredFrameSize() {
   return GetViewBounds().size();
 }
 
@@ skipping 28 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, public:
 
 RenderWidgetHostViewMac::RenderWidgetHostViewMac(RenderWidgetHost* widget)
     : render_widget_host_(RenderWidgetHostImpl::From(widget)),
       last_frame_was_accelerated_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
-      compositing_iosurface_layer_async_timer_(
-            FROM_HERE, base::TimeDelta::FromMilliseconds(250),
-            this, &RenderWidgetHostViewMac::TimerSinceGotAcceleratedFrameFired),
       allow_overlapping_views_(false),
       use_core_animation_(false),
       pending_latency_info_delay_(0),
       pending_latency_info_delay_weak_ptr_factory_(this),
       backing_store_scale_factor_(1),
       is_loading_(false),
       weak_factory_(this),
       fullscreen_parent_host_view_(NULL),
       underlay_view_has_drawn_(false),
       overlay_view_weak_factory_(this),
@@ skipping 18 matching lines @@
   render_widget_host_->SetView(this);
 }
 
 RenderWidgetHostViewMac::~RenderWidgetHostViewMac() {
   // This is being called from |cocoa_view_|'s destructor, so invalidate the
   // pointer.
   cocoa_view_ = nil;
 
   // Delete the delegated frame state.
   delegated_frame_host_.reset();
-  compositor_.reset();
   root_layer_.reset();
 
   UnlockMouse();
 
   // Make sure that the layer doesn't reach into the now-invalid object.
   DestroyCompositedIOSurfaceAndLayer(kDestroyContext);
   DestroySoftwareLayer();
 
   // We are owned by RenderWidgetHostViewCocoa, so if we go away before the
   // RenderWidgetHost does we need to tell it not to hold a stale pointer to
@@ skipping 58 matching lines @@
     ClearBoundContextDrawable();
     if (!new_context) {
       LOG(ERROR) << "Failed to create CompositingIOSurfaceContext";
       return false;
     }
     compositing_iosurface_context_ = new_context;
   }
 
   // Create the IOSurface texture.
   if (new_surface_needed) {
-    compositing_iosurface_.reset(CompositingIOSurfaceMac::Create());
+    compositing_iosurface_ = CompositingIOSurfaceMac::Create();
     if (!compositing_iosurface_) {
       LOG(ERROR) << "Failed to create CompositingIOSurface";
       return false;
     }
   }
 
   return true;
 }
 
 void RenderWidgetHostViewMac::EnsureSoftwareLayer() {
   TRACE_EVENT0("browser", "RenderWidgetHostViewMac::EnsureSoftwareLayer");
   if (software_layer_ || !use_core_animation_)
     return;
 
   software_layer_.reset([[SoftwareLayer alloc] init]);
   DCHECK(software_layer_);
 
   // Disable the fade-in animation as the layer is added.
   ScopedCAActionDisabler disabler;
   [background_layer_ addSublayer:software_layer_];
 }
 
 void RenderWidgetHostViewMac::DestroySoftwareLayer() {
   if (!software_layer_)
     return;
 
   // Disable the fade-out animation as the layer is removed.
   ScopedCAActionDisabler disabler;
   [software_layer_ removeFromSuperlayer];
-  [software_layer_ disableRendering];
   software_layer_.reset();
 }
 
 void RenderWidgetHostViewMac::EnsureCompositedIOSurfaceLayer() {
   TRACE_EVENT0("browser",
                "RenderWidgetHostViewMac::EnsureCompositedIOSurfaceLayer");
   DCHECK(compositing_iosurface_context_);
   if (compositing_iosurface_layer_ || !use_core_animation_)
     return;
 
   compositing_iosurface_layer_.reset([[CompositingIOSurfaceLayer alloc]
-      initWithRenderWidgetHostViewMac:this]);
+      initWithIOSurface:compositing_iosurface_
+             withClient:this]);
   DCHECK(compositing_iosurface_layer_);
 
   // Disable the fade-in animation as the layer is added.
   ScopedCAActionDisabler disabler;
   [background_layer_ addSublayer:compositing_iosurface_layer_];
 }
 
 void RenderWidgetHostViewMac::DestroyCompositedIOSurfaceLayer(
     DestroyCompositedIOSurfaceLayerBehavior destroy_layer_behavior) {
   if (!compositing_iosurface_layer_)
     return;
 
   if (destroy_layer_behavior == kRemoveLayerFromHierarchy) {
     // Disable the fade-out animation as the layer is removed.
     ScopedCAActionDisabler disabler;
     [compositing_iosurface_layer_ removeFromSuperlayer];
   }
-  [compositing_iosurface_layer_ disableCompositing];
+  [compositing_iosurface_layer_ resetClient];
   compositing_iosurface_layer_.reset();
 }
 
 void RenderWidgetHostViewMac::DestroyCompositedIOSurfaceAndLayer(
     DestroyContextBehavior destroy_context_behavior) {
   // Any pending frames will not be displayed, so ack them now.
   SendPendingSwapAck();
 
   DestroyCompositedIOSurfaceLayer(kRemoveLayerFromHierarchy);
-  compositing_iosurface_.reset();
+  compositing_iosurface_ = NULL;
 
   switch (destroy_context_behavior) {
     case kLeaveContextBoundToView:
       break;
     case kDestroyContext:
       ClearBoundContextDrawable();
       compositing_iosurface_context_ = NULL;
       break;
     default:
       NOTREACHED();
@@ skipping 868 matching lines @@
     // captured.
     if (window_is_occluded && frame_subscriber_)
       scoped_ack.Reset();
   }
 
   // If we reach here, then the frame will be displayed by a future draw
   // call, so don't make the callback.
   ignore_result(scoped_ack.Release());
   if (use_core_animation_) {
     DCHECK(compositing_iosurface_layer_);
-    compositing_iosurface_layer_async_timer_.Reset();
     [compositing_iosurface_layer_ gotNewFrame];
   } else {
     gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
         compositing_iosurface_context_->cgl_context());
     DrawIOSurfaceWithoutCoreAnimation();
   }
 
   // Try to finish previous copy requests after draw to get better pipelining.
   if (compositing_iosurface_)
     compositing_iosurface_->CheckIfAllCopiesAreFinished(false);
 
   // The IOSurface's size may have changed, so re-layout the layers to take
   // this into account. This may force an immediate draw.
   LayoutLayers();
 }
 
-void RenderWidgetHostViewMac::GotBrowserCompositorSoftwareFrame(
-    cc::SoftwareFrameData* frame_data,
-    float scale_factor,
-    SkCanvas* canvas) {
-  if (!frame_data || !canvas)
-    return;
-
-  SkImageInfo info;
-  size_t row_bytes;
-  const void* pixels = canvas->peekPixels(&info, &row_bytes);
-
-  EnsureSoftwareLayer();
-  [software_layer_ setContentsToData:pixels
-                        withRowBytes:row_bytes
-                       withPixelSize:gfx::Size(info.fWidth, info.fHeight)
-                     withScaleFactor:scale_factor];
-
-  LayoutLayers();
-  DestroyCompositedIOSurfaceAndLayer(kDestroyContext);
-}
-
 void RenderWidgetHostViewMac::DrawIOSurfaceWithoutCoreAnimation() {
   CHECK(!use_core_animation_);
   CHECK(compositing_iosurface_);
 
   // If there is a pending frame, it should be acked by the end of this
   // function. Note that the ack should happen only after all drawing is
   // complete, so that the ack happens after any blocking due to vsync.
   base::ScopedClosureRunner scoped_ack(
       base::Bind(&RenderWidgetHostViewMac::SendPendingSwapAck,
                  weak_factory_.GetWeakPtr()));
@@ skipping 306 matching lines @@
                    desired_size));
   }
   return false;
 }
 
 void RenderWidgetHostViewMac::OnSwapCompositorFrame(
     uint32 output_surface_id, scoped_ptr<cc::CompositorFrame> frame) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewMac::OnSwapCompositorFrame");
 
   if (frame->delegated_frame_data) {
-    if (!compositor_) {
-      compositor_.reset(new ui::Compositor(cocoa_view_));
+    if (!browser_compositor_view_) {
+      browser_compositor_view_.reset(
+          [[BrowserCompositorViewMac alloc] initWithSuperview:cocoa_view_]);
       root_layer_.reset(new ui::Layer(ui::LAYER_TEXTURED));
       delegated_frame_host_.reset(new DelegatedFrameHost(this));
     }
 
     // TODO(ccameron): Having the root layer set while swapping the frame will
     // result in frames not appearing. Fix this.
-    compositor_->SetRootLayer(NULL);
+    [browser_compositor_view_ compositor]->SetRootLayer(NULL);
     delegated_frame_host_->SwapDelegatedFrame(
         output_surface_id,
         frame->delegated_frame_data.Pass(),
         frame->metadata.device_scale_factor,
         frame->metadata.latency_info);
-    compositor_->SetRootLayer(root_layer_.get());
+    [browser_compositor_view_ compositor]->SetRootLayer(root_layer_.get());
 
     // Update the compositor and root layer size and scale factor to match
     // the frame just received.
     float scale_factor = frame->metadata.device_scale_factor;
     gfx::Size dip_size = ToCeiledSize(frame->metadata.viewport_size);
     gfx::Size pixel_size = ConvertSizeToPixel(
         scale_factor, dip_size);
-    compositor_->SetScaleAndSize(scale_factor, pixel_size);
+    [browser_compositor_view_ compositor]->SetScaleAndSize(
+        scale_factor, pixel_size);
     root_layer_->SetBounds(gfx::Rect(dip_size));
   } else if (frame->software_frame_data) {
     if (!software_frame_manager_->SwapToNewFrame(
             output_surface_id,
             frame->software_frame_data.get(),
             frame->metadata.device_scale_factor,
             render_widget_host_->GetProcess()->GetHandle())) {
       render_widget_host_->GetProcess()->ReceivedBadMessage();
       return;
     }
@@ skipping 195 matching lines @@
     // http://crbug.com/279472
     if (!use_core_animation_)
       [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
     if (allow_overlapping_views_)
       DestroyCompositedIOSurfaceAndLayer(kLeaveContextBoundToView);
     else
       DestroyCompositedIOSurfaceAndLayer(kDestroyContext);
   }
 }
 
-void RenderWidgetHostViewMac::TimerSinceGotAcceleratedFrameFired() {
-  [compositing_iosurface_layer_ timerSinceGotNewFrameFired];
-}
-
 void RenderWidgetHostViewMac::SetActive(bool active) {
   if (render_widget_host_) {
     render_widget_host_->SetActive(active);
     if (active) {
       if (HasFocus())
         render_widget_host_->Focus();
     } else {
       render_widget_host_->Blur();
     }
   }
@@ skipping 211 matching lines @@
 
 void RenderWidgetHostViewMac::AddPendingSwapAck(
     int32 route_id, int gpu_host_id, int32 renderer_id) {
   // Note that multiple un-acked swaps can come in the event of a GPU process
   // loss. Drop the old acks.
   pending_swap_ack_.reset(new PendingSwapAck(
       route_id, gpu_host_id, renderer_id));
 
   // A trace value of 2 indicates that there is a pending swap ack. See
   // CompositingIOSurfaceLayer's canDrawInCGLContext for other value meanings.
-  TRACE_COUNTER_ID1("browser", "PendingSwapAck", this, 2);
+  TRACE_COUNTER_ID1("browser", "PendingSwapAck",
+                    compositing_iosurface_layer_.get(), 2);
 }
 
 void RenderWidgetHostViewMac::SendPendingSwapAck() {
   if (!pending_swap_ack_)
     return;
 
   AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
   ack_params.sync_point = 0;
   ack_params.renderer_id = pending_swap_ack_->renderer_id;
   RenderWidgetHostImpl::AcknowledgeBufferPresent(pending_swap_ack_->route_id,
@@ skipping 25 matching lines @@
   // to keep the window and the window's contents in sync.
   [cocoa_view_ displayIfNeeded];
   [software_layer_ displayIfNeeded];
   [compositing_iosurface_layer_ displayIfNeeded];
 }
 
 void RenderWidgetHostViewMac::LayoutLayers() {
   if (!use_core_animation_)
     return;
 
+  if (browser_compositor_view_) {
+    [browser_compositor_view_ layoutLayers];
+    return;
+  }
+
   // Disable animation of the layer's resizing or change in contents scale.
   ScopedCAActionDisabler disabler;
 
   CGRect new_background_frame = NSRectToCGRect([cocoa_view() bounds]);
 
   // Dynamically calling setContentsScale on a CAOpenGLLayer for which
   // setAsynchronous is dynamically toggled can result in flashes of corrupt
   // content. Work around this by replacing the entire layer when the scale
   // factor changes.
   if (compositing_iosurface_ &&
@@ skipping 43 matching lines @@
     if (frame_changed) {
       [software_layer_ setFrame:new_background_frame];
     }
   }
 }
 
 SkBitmap::Config RenderWidgetHostViewMac::PreferredReadbackFormat() {
   return SkBitmap::kARGB_8888_Config;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// CompositingIOSurfaceLayerClient, public:
+
+void RenderWidgetHostViewMac::AcceleratedLayerDidDrawFrame(bool succeeded) {
+  SendPendingLatencyInfoToHost();
+  SendPendingSwapAck();
+  if (!succeeded)
+    GotAcceleratedCompositingError();
+}
+
+bool RenderWidgetHostViewMac::AcceleratedLayerHasNotAckedPendingFrame() const {
+  return pending_swap_ack_;
+}
+
 }  // namespace content
 
 // RenderWidgetHostViewCocoa ---------------------------------------------------
 
 @implementation RenderWidgetHostViewCocoa
 @synthesize selectedRange = selectedRange_;
 @synthesize suppressNextEscapeKeyUp = suppressNextEscapeKeyUp_;
 @synthesize markedRange = markedRange_;
 
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r {
@@ skipping 814 matching lines @@
       height = -height;
     }
 
     NSRect r = [self flipRectToNSRect:gfx::Rect(x, y, width, height)];
     CGContextSetFillColorWithColor(context,
                                    CGColorGetConstantColor(kCGColorWhite));
     CGContextFillRect(context, NSRectToCGRect(r));
   }
 }
 
-- (void)onNativeSurfaceBuffersSwappedWithParams:
-      (GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params)params {
-
-  renderWidgetHostView_->CompositorSwapBuffers(
-      params.surface_handle,
-      params.size,
-      params.scale_factor,
-      params.latency_info);
-}
-
-- (void)gotSoftwareFrame:(cc::SoftwareFrameData*)frame_data
-         withScaleFactor:(float)scale_factor
-              withCanvas:(SkCanvas*)canvas {
-  renderWidgetHostView_->GotBrowserCompositorSoftwareFrame(
-      frame_data, scale_factor, canvas);
-}
-
 - (void)drawRect:(NSRect)dirtyRect {
   TRACE_EVENT0("browser", "RenderWidgetHostViewCocoa::drawRect");
   DCHECK(!renderWidgetHostView_->use_core_animation_);
 
   if (!renderWidgetHostView_->render_widget_host_) {
     // When using CoreAnimation, this path is used to paint the contents area
     // white before any frames come in. When layers to draw frames exist, this
     // is not hit.
     [[NSColor whiteColor] set];
     NSRectFill(dirtyRect);
@@ skipping 1047 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
-
-@implementation SoftwareLayer
-
-- (id)init {
-  if (self = [super init]) {
-    [self setBackgroundColor:CGColorGetConstantColor(kCGColorWhite)];
-    [self setAnchorPoint:CGPointMake(0, 0)];
-    // Setting contents gravity is necessary to prevent the layer from being
-    // scaled during dyanmic resizes (especially with devtools open).
-    [self setContentsGravity:kCAGravityTopLeft];
-  }
-  return self;
-}
-
-- (void)setContentsToData:(const void *)data
-             withRowBytes:(size_t)rowBytes
-            withPixelSize:(gfx::Size)pixelSize
-          withScaleFactor:(float)scaleFactor {
-  TRACE_EVENT0("browser", "-[SoftwareLayer setContentsToData]");
-
-  // Disable animating the contents change or the scale factor change.
-  ScopedCAActionDisabler disabler;
-
-  // Set the contents of the software CALayer to be a CGImage with the provided
-  // pixel data. Make a copy of the data before backing the image with them,
-  // because the same buffer will be reused for the next frame.
-  base::ScopedCFTypeRef<CFDataRef> dataCopy(
-      CFDataCreate(NULL,
-                   static_cast<const UInt8 *>(data),
-                   rowBytes * pixelSize.height()));
-  base::ScopedCFTypeRef<CGDataProviderRef> dataProvider(
-      CGDataProviderCreateWithCFData(dataCopy));
-  base::ScopedCFTypeRef<CGImageRef> image(
-      CGImageCreate(pixelSize.width(),
-                    pixelSize.height(),
-                    8,
-                    32,
-                    rowBytes,
-                    base::mac::GetSystemColorSpace(),
-                    kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,
-                    dataProvider,
-                    NULL,
-                    false,
-                    kCGRenderingIntentDefault));
-  [self setContents:(id)image.get()];
-
-  // Set the contents scale of the software CALayer.
-  if ([self respondsToSelector:(@selector(contentsScale))] &&
-      [self respondsToSelector:(@selector(setContentsScale:))] &&
-      [self contentsScale] != scaleFactor) {
-    [self setContentsScale:scaleFactor];
-  }
-}
-
-- (void)disableRendering {
-  // Disable the fade-out animation as the layer is removed.
-  ScopedCAActionDisabler disabler;
-  [self removeFromSuperlayer];
-}
-
-@end  // implementation SoftwareLayer