Add a path to use CALayers to display 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"
 
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/bind.h"
 #include "base/bind_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"
+#include "base/mac/sdk_forward_declarations.h"
 #import "base/memory/scoped_nsobject.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/utf_string_conversions.h"
 #import "content/browser/accessibility/browser_accessibility_cocoa.h"
 #include "content/browser/accessibility/browser_accessibility_manager_mac.h"
 #include "content/browser/renderer_host/backing_store_mac.h"
 #include "content/browser/renderer_host/backing_store_manager.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_view_host_impl.h"
 #import "content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper.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/port/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #import "content/public/browser/render_widget_host_view_mac_delegate.h"
+#include "content/public/common/content_switches.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/mac/WebInputEventFactory.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/mac/WebScreenInfoFactory.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/base/keycodes/keyboard_codes.h"
 #include "ui/base/layout.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/size_conversions.h"
 #include "ui/surface/io_surface_support_mac.h"
 #include "webkit/plugins/npapi/webplugin.h"
@@ skipping 16 matching lines @@
 // These are not documented, so use only after checking -respondsToSelector:.
 @interface NSApplication (UndocumentedSpeechMethods)
 - (void)speakString:(NSString*)string;
 - (void)stopSpeaking:(id)sender;
 - (BOOL)isSpeaking;
 @end
 
 // Declare things that are part of the 10.7 SDK.
 #if !defined(MAC_OS_X_VERSION_10_7) || \
     MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
-enum {
-  NSEventPhaseNone        = 0, // event not associated with a phase.
-  NSEventPhaseBegan       = 0x1 << 0,
-  NSEventPhaseStationary  = 0x1 << 1,
-  NSEventPhaseChanged     = 0x1 << 2,
-  NSEventPhaseEnded       = 0x1 << 3,
-  NSEventPhaseCancelled   = 0x1 << 4,
-};
-typedef NSUInteger NSEventPhase;
 
 @interface NSEvent (LionAPI)
 - (NSEventPhase)phase;
 @end
 
 @interface NSWindow (LionAPI)
 - (CGFloat)backingScaleFactor;
 @end
 
 @interface NSView (NSOpenGLSurfaceResolutionLionAPI)
 - (void)setWantsBestResolutionOpenGLSurface:(BOOL)flag;
 @end
 
 static NSString* const NSWindowDidChangeBackingPropertiesNotification =
     @"NSWindowDidChangeBackingPropertiesNotification";
 static NSString* const NSBackingPropertyOldScaleFactorKey =
     @"NSBackingPropertyOldScaleFactorKey";
 // Note: Apple's example code (linked from the comment above
 // -windowDidChangeBackingProperties:) uses
 // @"NSWindowBackingPropertiesChangeOldBackingScaleFactorKey", but that always
 // returns an old scale of 0. @"NSBackingPropertyOldScaleFactorKey" seems to
 // work in practice, and it's what's used in Apple's WebKit port
 // (WebKit/mac/WebView/WebView.mm).
 
 #endif  // 10.7
 
-
 static inline int ToWebKitModifiers(NSUInteger flags) {
   int modifiers = 0;
   if (flags & NSControlKeyMask) modifiers |= WebInputEvent::ControlKey;
   if (flags & NSShiftKeyMask) modifiers |= WebInputEvent::ShiftKey;
   if (flags & NSAlternateKeyMask) modifiers |= WebInputEvent::AltKey;
   if (flags & NSCommandKeyMask) modifiers |= WebInputEvent::MetaKey;
   return modifiers;
 }
 
 static float ScaleFactor(NSView* view) {
   return ui::GetScaleFactorScale(ui::GetScaleFactorForNativeView(view));
 }
 
 // Private methods:
 @interface RenderWidgetHostViewCocoa ()
 @property(nonatomic, assign) NSRange selectedRange;
 @property(nonatomic, assign) NSRange markedRange;
 @property(nonatomic, assign)
     NSObject<RenderWidgetHostViewMacDelegate>* delegate;
 
 + (BOOL)shouldAutohideCursorForEvent:(NSEvent*)event;
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r;
 - (void)gotUnhandledWheelEvent;
 - (void)scrollOffsetPinnedToLeft:(BOOL)left toRight:(BOOL)right;
 - (void)setHasHorizontalScrollbar:(BOOL)has_horizontal_scrollbar;
 - (void)keyEvent:(NSEvent*)theEvent wasKeyEquivalent:(BOOL)equiv;
 - (void)windowDidChangeBackingProperties:(NSNotification*)notification;
 - (void)windowChangedGlobalFrame:(NSNotification*)notification;
+- (void)drawBackingStore:(BackingStoreMac*)backingStore
+               dirtyRect:(CGRect)dirtyRect
+               inContext:(CGContextRef)context;
+- (void)updateSoftwareLayerScaleFactor;
 - (void)checkForPluginImeCancellation;
 - (void)updateTabBackingStoreScaleFactor;
 - (NSRect)firstViewRectForCharacterRange:(NSRange)theRange
                              actualRange:(NSRangePointer)actualRange;
 @end
 
 // NSEvent subtype for scroll gestures events.
 static const short kIOHIDEventTypeScroll = 6;
 
 // A window subclass that allows the fullscreen window to become main and gain
@@ skipping 202 matching lines @@
 // RenderWidgetHostViewMac, public:
 
 RenderWidgetHostViewMac::RenderWidgetHostViewMac(RenderWidgetHost* widget)
     : render_widget_host_(RenderWidgetHostImpl::From(widget)),
       about_to_validate_and_paint_(false),
       call_set_needs_display_in_rect_pending_(false),
       last_frame_was_accelerated_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
       allow_overlapping_views_(false),
+      use_core_animation_(false),
       is_loading_(false),
       is_hidden_(false),
       weak_factory_(this),
       fullscreen_parent_host_view_(NULL) {
   // |cocoa_view_| owns us and we will be deleted when |cocoa_view_|
   // goes away.  Since we autorelease it, our caller must put
   // |GetNativeView()| into the view hierarchy right after calling us.
   cocoa_view_ = [[[RenderWidgetHostViewCocoa alloc]
                   initWithRenderWidgetHostViewMac:this] autorelease];
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseCoreAnimation))
+    EnableCoreAnimation();
   render_widget_host_->SetView(this);
 }
 
 RenderWidgetHostViewMac::~RenderWidgetHostViewMac() {
   AckPendingSwapBuffers();
   UnlockMouse();
+
+  // Make sure that the layer doesn't reach into the now-invalid object.
+  compositing_iosurface_.reset();
+  if (compositing_iosurface_layer_)
+    [compositing_iosurface_layer_ disableCompositing];
+  compositing_iosurface_layer_.reset();
+
   // 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
   // us.
   if (render_widget_host_)
     render_widget_host_->SetView(NULL);
 }
 
 void RenderWidgetHostViewMac::SetDelegate(
     NSObject<RenderWidgetHostViewMacDelegate>* delegate) {
   [cocoa_view_ setDelegate:delegate];
 }
 
 void RenderWidgetHostViewMac::SetAllowOverlappingViews(bool overlapping) {
+  if (use_core_animation_)
+    return;
   if (allow_overlapping_views_ == overlapping)
     return;
   allow_overlapping_views_ = overlapping;
   [cocoa_view_ setNeedsDisplay:YES];
   [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, RenderWidgetHostView implementation:
 
+void RenderWidgetHostViewMac::EnableCoreAnimation() {
+  if (use_core_animation_)
+    return;
+  use_core_animation_ = true;
+
+  software_layer_.reset([[CALayer alloc] init]);
+  [software_layer_ setDelegate:cocoa_view_];
+  [software_layer_ setAutoresizingMask:kCALayerWidthSizable |
+                                       kCALayerHeightSizable];
+  [software_layer_ setContentsGravity:kCAGravityTopLeft];
+  [cocoa_view_ updateSoftwareLayerScaleFactor];
+  [cocoa_view_ setLayer:software_layer_];
+  [cocoa_view_ setWantsLayer:YES];
+}
+
 bool RenderWidgetHostViewMac::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderWidgetHostViewMac, message)
     IPC_MESSAGE_HANDLER(ViewHostMsg_PluginFocusChanged, OnPluginFocusChanged)
     IPC_MESSAGE_HANDLER(ViewHostMsg_StartPluginIme, OnStartPluginIme)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
@@ skipping 92 matching lines @@
   pepper_fullscreen_window_.reset();
 }
 
 int RenderWidgetHostViewMac::window_number() const {
   NSWindow* window = [cocoa_view_ window];
   if (!window)
     return -1;
   return [window windowNumber];
 }
 
+float RenderWidgetHostViewMac::scale_factor() const {
+  return ScaleFactor(cocoa_view_);
+}
+
 RenderWidgetHost* RenderWidgetHostViewMac::GetRenderWidgetHost() const {
   return render_widget_host_;
 }
 
 void RenderWidgetHostViewMac::WasShown() {
   if (!is_hidden_)
     return;
 
   if (web_contents_switch_paint_time_.is_null())
     web_contents_switch_paint_time_ = base::TimeTicks::Now();
   is_hidden_ = false;
   render_widget_host_->WasShown();
 
   // We're messing with the window, so do this to ensure no flashes.
-  [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
+  if (!use_core_animation_)
+    [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
+
+  if (compositing_iosurface_layer_)
+    [compositing_iosurface_layer_ setNeedsDisplay];
 }
 
 void RenderWidgetHostViewMac::WasHidden() {
   if (is_hidden_)
     return;
 
   // Send ACKs for any pending SwapBuffers (if any) since we won't be displaying
   // them and the GPU process is waiting.
   AckPendingSwapBuffers();
 
   // If we receive any more paint messages while we are hidden, we want to
   // ignore them so we don't re-allocate the backing store.  We will paint
   // everything again when we become selected again.
   is_hidden_ = true;
 
   // If we have a renderer, then inform it that we are being hidden so it can
   // reduce its resource utilization.
   render_widget_host_->WasHidden();
 
   // There can be a transparent flash as this view is removed and the next is
   // added, because of OSX windowing races between displaying the contents of
   // the NSView and its corresponding OpenGL context.
   // disableScreenUpdatesUntilFlush prevents the transparent flash by avoiding
   // screen updates until the next tab draws.
-  [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
+  if (!use_core_animation_)
+    [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
 
   web_contents_switch_paint_time_ = base::TimeTicks();
 }
 
 void RenderWidgetHostViewMac::SetSize(const gfx::Size& size) {
   gfx::Rect rect = GetViewBounds();
   rect.set_size(size);
   SetBounds(rect);
 }
 
@@ skipping 71 matching lines @@
   UnlockMouse();
   [[cocoa_view_ window] makeFirstResponder:nil];
 }
 
 bool RenderWidgetHostViewMac::HasFocus() const {
   return [[cocoa_view_ window] firstResponder] == cocoa_view_;
 }
 
 bool RenderWidgetHostViewMac::IsSurfaceAvailableForCopy() const {
   return !!render_widget_host_->GetBackingStore(false) ||
-      (compositing_iosurface_.get() && compositing_iosurface_->HasIOSurface());
+      (compositing_iosurface_ && compositing_iosurface_->HasIOSurface());
 }
 
 void RenderWidgetHostViewMac::Show() {
   [cocoa_view_ setHidden:NO];
 
   WasShown();
 }
 
 void RenderWidgetHostViewMac::Hide() {
   [cocoa_view_ setHidden:YES];
@@ skipping 268 matching lines @@
   float scale = ScaleFactor(cocoa_view_);
   return new BackingStoreMac(render_widget_host_, size, scale);
 }
 
 void RenderWidgetHostViewMac::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     const base::Callback<void(bool, const SkBitmap&)>& callback) {
   base::ScopedClosureRunner scoped_callback_runner(
       base::Bind(callback, false, SkBitmap()));
-  if (!compositing_iosurface_.get() ||
+  if (!compositing_iosurface_ ||
       !compositing_iosurface_->HasIOSurface())
     return;
 
   float scale = ScaleFactor(cocoa_view_);
   gfx::Size dst_pixel_size = gfx::ToFlooredSize(
       gfx::ScaleSize(dst_size, scale));
 
   scoped_callback_runner.Release();
 
   compositing_iosurface_->CopyTo(GetScaledOpenGLPixelRect(src_subrect),
                                  dst_pixel_size,
                                  callback);
 }
 
 void RenderWidgetHostViewMac::CopyFromCompositingSurfaceToVideoFrame(
       const gfx::Rect& src_subrect,
       const scoped_refptr<media::VideoFrame>& target,
       const base::Callback<void(bool)>& callback) {
   base::ScopedClosureRunner scoped_callback_runner(base::Bind(callback, false));
   if (!render_widget_host_->is_accelerated_compositing_active() ||
-      !compositing_iosurface_.get() ||
+      !compositing_iosurface_ ||
       !compositing_iosurface_->HasIOSurface())
     return;
 
   if (!target) {
     NOTREACHED();
     return;
   }
 
   if (target->format() != media::VideoFrame::YV12 &&
       target->format() != media::VideoFrame::I420) {
     NOTREACHED();
     return;
   }
 
   if (src_subrect.IsEmpty())
     return;
 
   scoped_callback_runner.Release();
   compositing_iosurface_->CopyToVideoFrame(
       GetScaledOpenGLPixelRect(src_subrect),
       target,
       callback);
 }
 
 bool RenderWidgetHostViewMac::CanCopyToVideoFrame() const {
   return (!render_widget_host_->GetBackingStore(false) &&
           render_widget_host_->is_accelerated_compositing_active() &&
-          compositing_iosurface_.get() &&
+          compositing_iosurface_ &&
           compositing_iosurface_->HasIOSurface());
 }
 
 bool RenderWidgetHostViewMac::CanSubscribeFrame() const {
   return true;
 }
 
 void RenderWidgetHostViewMac::BeginFrameSubscription(
     scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
   frame_subscriber_ = subscriber.Pass();
@@ skipping 44 matching lines @@
     const string16& text, int plugin_id) {
   if (render_widget_host_) {
     render_widget_host_->Send(new ViewMsg_PluginImeCompositionCompleted(
         render_widget_host_->GetRoutingID(), text, plugin_id));
   }
 }
 
 bool RenderWidgetHostViewMac::CompositorSwapBuffers(
     uint64 surface_handle,
     const gfx::Size& size,
-    float scale_factor,
+    float surface_scale_factor,
     const ui::LatencyInfo& latency_info) {
   if (is_hidden_)
     return true;
 
   NSWindow* window = [cocoa_view_ window];
   if (window_number() <= 0) {
     // There is no window to present so capturing during present won't work.
     // We check if frame subscriber wants this frame and capture manually.
-    if (compositing_iosurface_.get() && frame_subscriber_) {
+    if (compositing_iosurface_ && frame_subscriber_) {
       const base::Time present_time = base::Time::Now();
       scoped_refptr<media::VideoFrame> frame;
       RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
       if (frame_subscriber_->ShouldCaptureFrame(present_time,
                                                 &frame, &callback)) {
         compositing_iosurface_->SetIOSurface(
-            surface_handle, size, scale_factor, latency_info);
+            surface_handle, size, surface_scale_factor, latency_info);
         compositing_iosurface_->CopyToVideoFrame(
             gfx::Rect(size), frame,
             base::Bind(callback, present_time));
         return true;
       }
     }
 
     // TODO(shess) If the view does not have a window, or the window
     // does not have backing, the IOSurface will log "invalid drawable"
     // in -setView:.  It is not clear how this code is reached with such
@@ skipping 10 matching lines @@
               object_getClassName([window delegate]),
               object_getClassName([window windowController]));
       base::debug::SetCrashKeyValue(kCrashKey, value);
     }
 
     return true;
   }
 
   bool should_post_notification = false;
   if (!compositing_iosurface_) {
-    compositing_iosurface_.reset(
-        CompositingIOSurfaceMac::Create(window_number()));
+    if (use_core_animation_) {
+      if (!compositing_iosurface_layer_) {
+        compositing_iosurface_layer_.reset([[CompositingIOSurfaceLayer alloc]
+            initWithRenderWidgetHostViewMac:this]);
+      }
+      if (!compositing_iosurface_layer_) {
+        LOG(WARNING) << "Failed to create CALayer for IOSurface";
+        return true;
+      }
+      if (![compositing_iosurface_layer_ ensureContext]) {
+        LOG(WARNING) << "Failed to create context for IOSurface";
+        return true;
+      }
+      compositing_iosurface_.reset(CompositingIOSurfaceMac::Create(
+          [compositing_iosurface_layer_ context]));
+    } else {
+      compositing_iosurface_.reset(
+          CompositingIOSurfaceMac::Create(window_number()));
+    }
     should_post_notification = true;
   }
 
-  if (!compositing_iosurface_)
+  if (!compositing_iosurface_) {
+    LOG(WARNING) << "Failed to create CompositingIOSurfaceMac";
     return true;
+  }
 
   compositing_iosurface_->SetIOSurface(
-      surface_handle, size, scale_factor, latency_info);
+      surface_handle, size, surface_scale_factor, latency_info);
+
+  // TODO(ccameron): If we've failed to allocate the GL texture for the
+  // IOSurface, or basically anything else along the way, we'll just display
+  // a white out, potentially forever. Instead, kick the renderer back to
+  // software mode (like a context lost or a GPU process death).
 
   GotAcceleratedFrame();
 
   gfx::Size window_size(NSSizeToCGSize([cocoa_view_ frame].size));
   if (window_size.IsEmpty()) {
     // setNeedsDisplay will never display and we'll never ack if the window is
     // empty, so ack now and don't bother calling setNeedsDisplay below.
     return true;
   }
 
   // No need to draw the surface if we are inside a drawRect. It will be done
   // later.
   if (!about_to_validate_and_paint_) {
-    CompositingIOSurfaceMac::SurfaceOrder order = allow_overlapping_views_ ?
-        CompositingIOSurfaceMac::SURFACE_ORDER_BELOW_WINDOW :
-        CompositingIOSurfaceMac::SURFACE_ORDER_ABOVE_WINDOW;
-    compositing_iosurface_->DrawIOSurface(cocoa_view_,
-                                          ScaleFactor(cocoa_view_),
-                                          window_number(),
-                                          order,
-                                          frame_subscriber_.get());
+    if (use_core_animation_) {
+      DCHECK(compositing_iosurface_layer_);
+      [compositing_iosurface_layer_ setNeedsDisplay];
+    } else {
+      compositing_iosurface_->DrawIOSurface(this);
+    }
   }
 
   if (should_post_notification && [[cocoa_view_ delegate]
           respondsToSelector:@selector(compositingIOSurfaceCreated)]) {
     [[cocoa_view_ delegate] compositingIOSurfaceCreated];
   }
 
+  // Don't ack the new frame until it is drawn.
+  if (use_core_animation_)
+    return false;
+
   return true;
 }
 
 void RenderWidgetHostViewMac::AckPendingSwapBuffers() {
   TRACE_EVENT0("browser", "RenderWidgetHostViewMac::AckPendingSwapBuffers");
   while (!pending_swap_buffers_acks_.empty()) {
     if (pending_swap_buffers_acks_.front().first != 0) {
       AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
       ack_params.sync_point = 0;
       if (compositing_iosurface_)
@@ skipping 192 matching lines @@
     AckPendingSwapBuffers();
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSuspend() {
   if (compositing_iosurface_)
     compositing_iosurface_->UnrefIOSurface();
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceRelease() {
   compositing_iosurface_.reset();
+  if (compositing_iosurface_layer_)
+    [compositing_iosurface_layer_ disableCompositing];
+  compositing_iosurface_layer_.reset();
 }
 
 bool RenderWidgetHostViewMac::HasAcceleratedSurface(
       const gfx::Size& desired_size) {
   return last_frame_was_accelerated_ &&
-         compositing_iosurface_.get() &&
+         compositing_iosurface_ &&
          compositing_iosurface_->HasIOSurface() &&
          (desired_size.IsEmpty() ||
           compositing_iosurface_->dip_io_surface_size() == desired_size);
 }
 
 void RenderWidgetHostViewMac::AboutToWaitForBackingStoreMsg() {
   AckPendingSwapBuffers();
 }
 
 void RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange() {
@@ skipping 77 matching lines @@
 }
 
 
 void RenderWidgetHostViewMac::ShutdownHost() {
   weak_factory_.InvalidateWeakPtrs();
   render_widget_host_->Shutdown();
   // Do not touch any members at this point, |this| has been deleted.
 }
 
 void RenderWidgetHostViewMac::GotAcceleratedFrame() {
+  // Update the scale factor of the layer to match the scale factor of the
+  // IOSurface.
+  if (compositing_iosurface_layer_)
+    [compositing_iosurface_layer_ updateScaleFactor];
+
   if (!last_frame_was_accelerated_) {
     last_frame_was_accelerated_ = true;
 
-    // Need to wipe the software view with transparency to expose the GL
-    // underlay. Invalidate the whole window to do that.
-    [cocoa_view_ setNeedsDisplay:YES];
+    if (!use_core_animation_) {
+      // Need to wipe the software view with transparency to expose the GL
+      // underlay. Invalidate the whole window to do that.
+      [cocoa_view_ setNeedsDisplay:YES];
+    }
 
     // Delete software backingstore.
     BackingStoreManager::RemoveBackingStore(render_widget_host_);
   }
 }
 
 void RenderWidgetHostViewMac::GotSoftwareFrame() {
   if (last_frame_was_accelerated_) {
     last_frame_was_accelerated_ = false;
 
     AckPendingSwapBuffers();
 
     // Forget IOSurface since we are drawing a software frame now.
-    if (compositing_iosurface_.get() &&
-        compositing_iosurface_->HasIOSurface()) {
-      compositing_iosurface_->ClearDrawable();
+    if (use_core_animation_) {
+      compositing_iosurface_.reset();
+      if (compositing_iosurface_layer_)
+        [compositing_iosurface_layer_ disableCompositing];
+      compositing_iosurface_layer_.reset();
+    }
+    else {
+      if (compositing_iosurface_ &&
+          compositing_iosurface_->HasIOSurface()) {
+        compositing_iosurface_->ClearDrawable();
+      }
     }
   }
 }
 
 void RenderWidgetHostViewMac::SetActive(bool active) {
   if (render_widget_host_) {
     render_widget_host_->SetActive(active);
     if (active) {
       if (HasFocus())
         render_widget_host_->Focus();
@@ skipping 99 matching lines @@
 void RenderWidgetHostViewMac::OnStartPluginIme() {
   [cocoa_view_ setPluginImeActive:YES];
 }
 
 gfx::Rect RenderWidgetHostViewMac::GetScaledOpenGLPixelRect(
     const gfx::Rect& rect) {
   gfx::Rect src_gl_subrect = rect;
   src_gl_subrect.set_y(GetViewBounds().height() - rect.bottom());
 
   return gfx::ToEnclosingRect(gfx::ScaleRect(src_gl_subrect,
-                                             ScaleFactor(cocoa_view_)));
+                                             scale_factor()));
 }
 
 }  // namespace content
 
 // RenderWidgetHostViewCocoa ---------------------------------------------------
 
 @implementation RenderWidgetHostViewCocoa
 
 @synthesize selectedRange = selectedRange_;
 @synthesize suppressNextEscapeKeyUp = suppressNextEscapeKeyUp_;
@@ skipping 531 matching lines @@
     const WebMouseWheelEvent& webEvent =
         WebInputEventFactory::mouseWheelEvent(event, self);
     renderWidgetHostView_->render_widget_host_->ForwardWheelEvent(webEvent);
   }
 }
 
 - (void)viewWillMoveToWindow:(NSWindow*)newWindow {
   // We're messing with the window, so do this to ensure no flashes. This one
   // prevents a flash when the current tab is closed.
   NSWindow* oldWindow = [self window];
-  [oldWindow disableScreenUpdatesUntilFlush];
+
+  if (!renderWidgetHostView_->use_core_animation_)
+    [oldWindow disableScreenUpdatesUntilFlush];
 
   NSNotificationCenter* notificationCenter =
       [NSNotificationCenter defaultCenter];
   if (oldWindow) {
     [notificationCenter
         removeObserver:self
                   name:NSWindowDidChangeBackingPropertiesNotification
                 object:oldWindow];
     [notificationCenter
         removeObserver:self
@@ skipping 30 matching lines @@
   float scaleFactor = ScaleFactor(self);
   if (scaleFactor == deviceScaleFactor_)
     return;
   deviceScaleFactor_ = scaleFactor;
 
   BackingStoreMac* backingStore = static_cast<BackingStoreMac*>(
       renderWidgetHostView_->render_widget_host_->GetBackingStore(false));
   if (backingStore)  // NULL in hardware path.
     backingStore->ScaleFactorChanged(scaleFactor);
 
+  [self updateSoftwareLayerScaleFactor];
   renderWidgetHostView_->render_widget_host_->NotifyScreenInfoChanged();
 }
 
 // http://developer.apple.com/library/mac/#documentation/GraphicsAnimation/Conceptual/HighResolutionOSX/CapturingScreenContents/CapturingScreenContents.html#//apple_ref/doc/uid/TP40012302-CH10-SW4
 - (void)windowDidChangeBackingProperties:(NSNotification*)notification {
   NSWindow* window = (NSWindow*)[notification object];
 
   CGFloat newBackingScaleFactor = [window backingScaleFactor];
   CGFloat oldBackingScaleFactor = [base::mac::ObjCCast<NSNumber>(
       [[notification userInfo] objectForKey:NSBackingPropertyOldScaleFactorKey])
@@ skipping 36 matching lines @@
     renderWidgetHostView_->render_widget_host_->WasResized();
   }
 }
 
 - (void)callSetNeedsDisplayInRect {
   DCHECK([NSThread isMainThread]);
   DCHECK(renderWidgetHostView_->call_set_needs_display_in_rect_pending_);
   [self setNeedsDisplayInRect:renderWidgetHostView_->invalid_rect_];
   renderWidgetHostView_->call_set_needs_display_in_rect_pending_ = false;
   renderWidgetHostView_->invalid_rect_ = NSZeroRect;
+
+  if (renderWidgetHostView_->compositing_iosurface_layer_)
+    [renderWidgetHostView_->compositing_iosurface_layer_ setNeedsDisplay];
 }
 
 // Fills with white the parts of the area to the right and bottom for |rect|
 // that intersect |damagedRect|.
 - (void)fillBottomRightRemainderOfRect:(gfx::Rect)rect
-                             dirtyRect:(gfx::Rect)damagedRect {
+                             dirtyRect:(gfx::Rect)damagedRect
+                             inContext:(CGContextRef)context {
   if (damagedRect.right() > rect.right()) {
     int x = std::max(rect.right(), damagedRect.x());
     int y = std::min(rect.bottom(), damagedRect.bottom());
     int width = damagedRect.right() - x;
     int height = damagedRect.y() - y;
 
     // Extra fun to get around the fact that gfx::Rects can't have
     // negative sizes.
     if (width < 0) {
       x += width;
       width = -width;
     }
     if (height < 0) {
       y += height;
       height = -height;
     }
 
     NSRect r = [self flipRectToNSRect:gfx::Rect(x, y, width, height)];
-    [[NSColor whiteColor] set];
-    NSRectFill(r);
+    CGContextSetFillColorWithColor(context,
+                                   CGColorGetConstantColor(kCGColorWhite));
+    CGContextFillRect(context, NSRectToCGRect(r));
   }
   if (damagedRect.bottom() > rect.bottom()) {
     int x = damagedRect.x();
     int y = damagedRect.bottom();
     int width = damagedRect.right() - x;
     int height = std::max(rect.bottom(), damagedRect.y()) - y;
 
     // Extra fun to get around the fact that gfx::Rects can't have
     // negative sizes.
     if (width < 0) {
       x += width;
       width = -width;
     }
     if (height < 0) {
       y += height;
       height = -height;
     }
 
     NSRect r = [self flipRectToNSRect:gfx::Rect(x, y, width, height)];
-    [[NSColor whiteColor] set];
-    NSRectFill(r);
+    CGContextSetFillColorWithColor(context,
+                                   CGColorGetConstantColor(kCGColorWhite));
+    CGContextFillRect(context, NSRectToCGRect(r));
   }
 }
 
 - (void)drawRect:(NSRect)dirtyRect {
   TRACE_EVENT0("browser", "RenderWidgetHostViewCocoa::drawRect");
+  DCHECK(!renderWidgetHostView_->use_core_animation_);
+
   if (!renderWidgetHostView_->render_widget_host_) {
     // TODO(shess): Consider using something more noticable?
     [[NSColor whiteColor] set];
     NSRectFill(dirtyRect);
     return;
   }
 
   DCHECK(!renderWidgetHostView_->about_to_validate_and_paint_);
 
   // GetBackingStore works for both software and accelerated frames. If a
   // SwapBuffers occurs while GetBackingStore is blocking, we will continue to
   // blit the IOSurface below.
   renderWidgetHostView_->about_to_validate_and_paint_ = true;
   BackingStoreMac* backingStore = static_cast<BackingStoreMac*>(
       renderWidgetHostView_->render_widget_host_->GetBackingStore(true));
   renderWidgetHostView_->about_to_validate_and_paint_ = false;
 
   const gfx::Rect damagedRect([self flipNSRectToRect:dirtyRect]);
 
   if (renderWidgetHostView_->last_frame_was_accelerated_ &&
-      renderWidgetHostView_->compositing_iosurface_.get()) {
+      renderWidgetHostView_->compositing_iosurface_) {
     if (renderWidgetHostView_->allow_overlapping_views_) {
       // If overlapping views need to be allowed, punch a hole in the window
       // to expose the GL underlay.
       TRACE_EVENT2("gpu", "NSRectFill clear", "w", damagedRect.width(),
                    "h", damagedRect.height());
       // NSRectFill is extremely slow (15ms for a window on a fast MacPro), so
       // this is only done when it's a real invalidation from window damage (not
       // when a BuffersSwapped was received). Note that even a 1x1 NSRectFill
       // can take many milliseconds sometimes (!) so this is skipped completely
       // for drawRects that are triggered by BuffersSwapped messages.
       [[NSColor clearColor] set];
       NSRectFill(dirtyRect);
     }
 
-    content::CompositingIOSurfaceMac::SurfaceOrder order =
-        renderWidgetHostView_->allow_overlapping_views_
-        ? content::CompositingIOSurfaceMac::SURFACE_ORDER_BELOW_WINDOW
-        : content::CompositingIOSurfaceMac::SURFACE_ORDER_ABOVE_WINDOW;
     renderWidgetHostView_->compositing_iosurface_->DrawIOSurface(
-        self,
-        ScaleFactor(self),
-        renderWidgetHostView_->window_number(),
-        order,
-        renderWidgetHostView_->frame_subscriber());
+        renderWidgetHostView_.get());
     return;
   }
 
+  CGContextRef context = static_cast<CGContextRef>(
+      [[NSGraphicsContext currentContext] graphicsPort]);
+  [self drawBackingStore:backingStore
+               dirtyRect:NSRectToCGRect(dirtyRect)
+               inContext:context];
+}
+
+- (void)drawBackingStore:(BackingStoreMac*)backingStore
+               dirtyRect:(CGRect)dirtyRect
+               inContext:(CGContextRef)context {
   if (backingStore) {
     // Note: All coordinates are in view units, not pixels.
     gfx::Rect bitmapRect(0, 0,
                          backingStore->size().width(),
                          backingStore->size().height());
 
     // Specify the proper y offset to ensure that the view is rooted to the
     // upper left corner.  This can be negative, if the window was resized
     // smaller and the renderer hasn't yet repainted.
     int yOffset = NSHeight([self bounds]) - backingStore->size().height();
 
+    NSRect nsDirtyRect = NSRectFromCGRect(dirtyRect);
+    const gfx::Rect damagedRect([self flipNSRectToRect:nsDirtyRect]);
+
     gfx::Rect paintRect = gfx::IntersectRects(bitmapRect, damagedRect);
     if (!paintRect.IsEmpty()) {
       // if we have a CGLayer, draw that into the window
       if (backingStore->cg_layer()) {
-        CGContextRef context = static_cast<CGContextRef>(
-            [[NSGraphicsContext currentContext] graphicsPort]);
-
         // TODO: add clipping to dirtyRect if it improves drawing performance.
         CGContextDrawLayerAtPoint(context, CGPointMake(0.0, yOffset),
                                   backingStore->cg_layer());
       } else {
         // if we haven't created a layer yet, draw the cached bitmap into
         // the window.  The CGLayer will be created the next time the renderer
         // paints.
-        CGContextRef context = static_cast<CGContextRef>(
-            [[NSGraphicsContext currentContext] graphicsPort]);
         base::mac::ScopedCFTypeRef<CGImageRef> image(
             CGBitmapContextCreateImage(backingStore->cg_bitmap()));
         CGRect imageRect = bitmapRect.ToCGRect();
         imageRect.origin.y = yOffset;
         CGContextDrawImage(context, imageRect, image);
       }
     }
 
     // Fill the remaining portion of the damagedRect with white
-    [self fillBottomRightRemainderOfRect:bitmapRect dirtyRect:damagedRect];
+    [self fillBottomRightRemainderOfRect:bitmapRect
+                               dirtyRect:damagedRect
+                               inContext:context];
 
     if (!renderWidgetHostView_->whiteout_start_time_.is_null()) {
       base::TimeDelta whiteout_duration = base::TimeTicks::Now() -
           renderWidgetHostView_->whiteout_start_time_;
       UMA_HISTOGRAM_TIMES("MPArch.RWHH_WhiteoutDuration", whiteout_duration);
 
       // Reset the start time to 0 so that we start recording again the next
       // time the backing store is NULL...
       renderWidgetHostView_->whiteout_start_time_ = base::TimeTicks();
     }
     if (!renderWidgetHostView_->web_contents_switch_paint_time_.is_null()) {
       base::TimeDelta web_contents_switch_paint_duration =
           base::TimeTicks::Now() -
               renderWidgetHostView_->web_contents_switch_paint_time_;
       UMA_HISTOGRAM_TIMES("MPArch.RWH_TabSwitchPaintDuration",
           web_contents_switch_paint_duration);
       // Reset contents_switch_paint_time_ to 0 so future tab selections are
       // recorded.
       renderWidgetHostView_->web_contents_switch_paint_time_ =
           base::TimeTicks();
     }
   } else {
-    [[NSColor whiteColor] set];
-    NSRectFill(dirtyRect);
+    CGContextSetFillColorWithColor(context,
+                                   CGColorGetConstantColor(kCGColorWhite));
+    CGContextFillRect(context, dirtyRect);
     if (renderWidgetHostView_->whiteout_start_time_.is_null())
       renderWidgetHostView_->whiteout_start_time_ = base::TimeTicks::Now();
   }
 }
 
 - (BOOL)canBecomeKeyView {
   if (!renderWidgetHostView_->render_widget_host_)
     return NO;
 
   return canBeKeyView_;
@@ skipping 952 matching lines @@
     return;
 
   currentCursor_.reset([cursor retain]);
   [[self window] invalidateCursorRectsForView:self];
 }
 
 - (void)popupWindowWillClose:(NSNotification *)notification {
   renderWidgetHostView_->KillSelf();
 }
 
+- (void)updateSoftwareLayerScaleFactor {
+  if (![renderWidgetHostView_->software_layer_
+          respondsToSelector:@selector(setContentsScale:)])
+    return;
+
+  ScopedCAActionDisabler disabler;
+  [renderWidgetHostView_->software_layer_ setContentsScale:deviceScaleFactor_];
+}
+
+// Delegate methods for the software CALayer
+- (void)drawLayer:(CALayer*)layer
+        inContext:(CGContextRef)context {
+  DCHECK(renderWidgetHostView_->use_core_animation_);
+  DCHECK([layer isEqual:renderWidgetHostView_->software_layer_]);
+
+  CGRect clipRect = CGContextGetClipBoundingBox(context);
+
+  if (!renderWidgetHostView_->render_widget_host_ ||
+      renderWidgetHostView_->is_hidden()) {
+    CGContextSetFillColorWithColor(context,
+                                   CGColorGetConstantColor(kCGColorWhite));
+    CGContextFillRect(context, clipRect);
+    return;
+  }
+
+  renderWidgetHostView_->about_to_validate_and_paint_ = true;
+  BackingStoreMac* backingStore = static_cast<BackingStoreMac*>(
+      renderWidgetHostView_->render_widget_host_->GetBackingStore(true));
+  renderWidgetHostView_->about_to_validate_and_paint_ = false;
+
+  [self drawBackingStore:backingStore
+               dirtyRect:clipRect
+               inContext:context];
+}
+
+- (void)setNeedsDisplay:(BOOL)flag {
+  [renderWidgetHostView_->software_layer_ setNeedsDisplay];
+  [super setNeedsDisplay:flag];
+}
+
+- (void)setNeedsDisplayInRect:(NSRect)rect {
+  [renderWidgetHostView_->software_layer_
+      setNeedsDisplayInRect:NSRectToCGRect(rect)];
+  [super setNeedsDisplayInRect:rect];
+}
+
 @end
 
 //
 // Supporting application services
 //
 @implementation RenderWidgetHostViewCocoa(NSServicesRequests)
 
 - (BOOL)writeSelectionToPasteboard:(NSPasteboard*)pboard
                              types:(NSArray*)types {
   const std::string& str = renderWidgetHostView_->selected_text();
@@ skipping 10 matching lines @@
   NSString *string = [pboard stringForType:NSStringPboardType];
   if (!string) return NO;
 
   // If the user is currently using an IME, confirm the IME input,
   // and then insert the text from the service, the same as TextEdit and Safari.
   [self confirmComposition];
   [self insertText:string];
   return YES;
 }
 
+- (BOOL)isOpaque {
+  if (renderWidgetHostView_->use_core_animation_)
+    return YES;
+  return [super isOpaque];
+}
+
 @end