Delete non-CoreAnimation code in RWHVMac

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"
@@ skipping 144 matching lines @@
 @property(nonatomic, assign) NSRange markedRange;
 
 + (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)drawWithDirtyRect:(CGRect)dirtyRect
-                inContext:(CGContextRef)context;
 - (void)checkForPluginImeCancellation;
 - (void)updateScreenProperties;
 - (void)setResponderDelegate:
         (NSObject<RenderWidgetHostViewMacDelegate>*)delegate;
 @end
 
 // A window subclass that allows the fullscreen window to become main and gain
 // keyboard focus. This is only used for pepper flash. Normal fullscreen is
 // handled by the browser.
 @interface PepperFlashFullscreenWindow : UnderlayOpenGLHostingWindow
@@ skipping 21 matching lines @@
 @implementation RenderWidgetPopupWindow
 
 - (id)initWithContentRect:(NSRect)contentRect
                 styleMask:(NSUInteger)windowStyle
                   backing:(NSBackingStoreType)bufferingType
                     defer:(BOOL)deferCreation {
   if (self = [super initWithContentRect:contentRect
                               styleMask:windowStyle
                                 backing:bufferingType
                                   defer:deferCreation]) {
-    DCHECK_EQ(content::CORE_ANIMATION_DISABLED,
-              content::GetCoreAnimationStatus());

[ccameron, 2014/06/05 03:05:14]

I think this DCHECK_EQ was added by accident.

[Ken Russell (switch to Gerrit), 2014/06/05 17:49:44]

I wonder why it wasn't noticed earlier.

     [self setOpaque:NO];
     [self setBackgroundColor:[NSColor clearColor]];
     [self startObservingClicks];
   }
   return self;
 }
 
 - (void)close {
   [self stopObservingClicks];
   [super close];
@@ skipping 265 matching lines @@
 void RenderWidgetHostViewBase::GetDefaultScreenInfo(
     blink::WebScreenInfo* results) {
   *results = GetWebScreenInfo(NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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),
-      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),
       software_frame_weak_ptr_factory_(this) {
   software_frame_manager_.reset(new SoftwareFrameManager(
       software_frame_weak_ptr_factory_.GetWeakPtr()));
   // |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 (GetCoreAnimationStatus() == CORE_ANIMATION_ENABLED) {
-    use_core_animation_ = true;
-    background_layer_.reset([[CALayer alloc] init]);
-    [background_layer_
-        setBackgroundColor:CGColorGetConstantColor(kCGColorWhite)];
-    [cocoa_view_ setLayer:background_layer_];
-    [cocoa_view_ setWantsLayer:YES];
-  }
+  background_layer_.reset([[CALayer alloc] init]);
+  [background_layer_
+      setBackgroundColor:CGColorGetConstantColor(kCGColorWhite)];
+  [cocoa_view_ setLayer:background_layer_];
+  [cocoa_view_ setWantsLayer:YES];
 
   render_widget_host_->SetView(this);
 }
 
 RenderWidgetHostViewMac::~RenderWidgetHostViewMac() {
   // This is being called from |cocoa_view_|'s destructor, so invalidate the
   // pointer.
   cocoa_view_ = nil;
 
   UnlockMouse();
 
   // Make sure that the layer doesn't reach into the now-invalid object.
-  DestroyCompositedIOSurfaceAndLayer(kDestroyContext);
+  DestroyCompositedIOSurfaceAndLayer();
   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
   // us.
   if (render_widget_host_)
     render_widget_host_->SetView(NULL);
 }
 
 void RenderWidgetHostViewMac::SetDelegate(
     NSObject<RenderWidgetHostViewMacDelegate>* delegate) {
   [cocoa_view_ setResponderDelegate:delegate];
 }
 
 void RenderWidgetHostViewMac::SetAllowOverlappingViews(bool overlapping) {
-  if (allow_overlapping_views_ == overlapping)
-    return;
-  allow_overlapping_views_ = overlapping;
-  [cocoa_view_ setNeedsDisplay:YES];
-  [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
+  // TODO(ccameron): Remove callers of this function.
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, RenderWidgetHostView implementation:
 
 bool RenderWidgetHostViewMac::EnsureCompositedIOSurface() {
   // If the context or the IOSurface's context has had an error, re-build
   // everything from scratch.
   if (compositing_iosurface_context_ &&
       compositing_iosurface_context_->HasBeenPoisoned()) {
     LOG(ERROR) << "Failing EnsureCompositedIOSurface because "
                << "context was poisoned";
     return false;
   }
   if (compositing_iosurface_ &&
       compositing_iosurface_->HasBeenPoisoned()) {
     LOG(ERROR) << "Failing EnsureCompositedIOSurface because "
                << "surface was poisoned";
     return false;
   }
 
-  int current_window_number = use_core_animation_ ?
-      CompositingIOSurfaceContext::kOffscreenContextWindowNumber :
-      window_number();
+  int current_window_number =
+      CompositingIOSurfaceContext::kOffscreenContextWindowNumber;
   bool new_surface_needed = !compositing_iosurface_;
   bool new_context_needed =
     !compositing_iosurface_context_ ||
         (compositing_iosurface_context_ &&
             compositing_iosurface_context_->window_number() !=
                 current_window_number);
 
   if (!new_surface_needed && !new_context_needed)
     return true;
 
   // Create the GL context and shaders.
   if (new_context_needed) {
     scoped_refptr<CompositingIOSurfaceContext> new_context =
         CompositingIOSurfaceContext::Get(current_window_number);
     // Un-bind the GL context from this view before binding the new GL
     // context. Having two GL contexts bound to a view will result in
     // crashes and corruption.
     // http://crbug.com/230883
-    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_ = 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_)
+  if (software_layer_)
     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_.reset();
 }
 
 void RenderWidgetHostViewMac::EnsureCompositedIOSurfaceLayer() {
   TRACE_EVENT0("browser",
                "RenderWidgetHostViewMac::EnsureCompositedIOSurfaceLayer");
   DCHECK(compositing_iosurface_context_);
-  if (compositing_iosurface_layer_ || !use_core_animation_)
+  if (compositing_iosurface_layer_)
     return;
 
   compositing_iosurface_layer_.reset([[CompositingIOSurfaceLayer alloc]
       initWithIOSurface:compositing_iosurface_
         withScaleFactor:compositing_iosurface_->scale_factor()
              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_ resetClient];
   compositing_iosurface_layer_.reset();
 }
 
-void RenderWidgetHostViewMac::DestroyCompositedIOSurfaceAndLayer(
-    DestroyContextBehavior destroy_context_behavior) {
+void RenderWidgetHostViewMac::DestroyCompositedIOSurfaceAndLayer() {
   // Any pending frames will not be displayed, so ack them now.
   SendPendingSwapAck();
 
   DestroyCompositedIOSurfaceLayer(kRemoveLayerFromHierarchy);
   compositing_iosurface_ = NULL;
-
-  switch (destroy_context_behavior) {
-    case kLeaveContextBoundToView:
-      break;
-    case kDestroyContext:
-      ClearBoundContextDrawable();
-      compositing_iosurface_context_ = NULL;
-      break;
-    default:
-      NOTREACHED();
-      break;
-  }
-}
-
-void RenderWidgetHostViewMac::ClearBoundContextDrawable() {
-  if (use_core_animation_)
-    return;
-
-  if (compositing_iosurface_context_ &&
-      cocoa_view_ &&
-      [[compositing_iosurface_context_->nsgl_context() view]
-          isEqual:cocoa_view_]) {
-    // Disable screen updates because removing the GL context from below can
-    // cause flashes.
-    [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
-    [compositing_iosurface_context_->nsgl_context() clearDrawable];
-  }
+  compositing_iosurface_context_ = NULL;
 }
 
 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_HANDLER(ViewHostMsg_DidChangeScrollbarsForMainFrame,
                         OnDidChangeScrollbarsForMainFrame)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ skipping 165 matching lines @@
 }
 
 RenderWidgetHost* RenderWidgetHostViewMac::GetRenderWidgetHost() const {
   return render_widget_host_;
 }
 
 void RenderWidgetHostViewMac::WasShown() {
   if (!render_widget_host_->is_hidden())
     return;
 
-  if (web_contents_switch_paint_time_.is_null())
-    web_contents_switch_paint_time_ = base::TimeTicks::Now();
   render_widget_host_->WasShown();
   software_frame_manager_->SetVisibility(true);
   if (delegated_frame_host_)
     delegated_frame_host_->WasShown();
 
   // Call setNeedsDisplay before pausing for new frames to come in -- if any
   // do, and are drawn, then the needsDisplay bit will be cleared.
   [compositing_iosurface_layer_ setNeedsDisplay];
   PauseForPendingResizeOrRepaintsAndDraw();
-
-  // We're messing with the window, so do this to ensure no flashes.
-  if (!use_core_animation_)
-    [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
 }
 
 void RenderWidgetHostViewMac::WasHidden() {
   if (render_widget_host_->is_hidden())
     return;
 
   // Any pending frames will not be displayed until this is shown again. Ack
   // them now.
   SendPendingSwapAck();
   PostReleaseBrowserCompositorLock();
 
   // If we have a renderer, then inform it that we are being hidden so it can
   // reduce its resource utilization.
   render_widget_host_->WasHidden();
   software_frame_manager_->SetVisibility(false);
   if (delegated_frame_host_)
     delegated_frame_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.
-  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);
 }
 
 void RenderWidgetHostViewMac::SetBounds(const gfx::Rect& rect) {
   // |rect.size()| is view coordinates, |rect.origin| is screen coordinates,
@@ skipping 85 matching lines @@
          (compositing_iosurface_ && compositing_iosurface_->HasIOSurface());
 }
 
 void RenderWidgetHostViewMac::Show() {
   [cocoa_view_ setHidden:NO];
 
   WasShown();
 }
 
 void RenderWidgetHostViewMac::Hide() {
-  // We're messing with the window, so do this to ensure no flashes.
-  if (!use_core_animation_)
-    [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
-
   [cocoa_view_ setHidden:YES];
 
   WasHidden();
 }
 
 bool RenderWidgetHostViewMac::IsShowing() {
   return ![cocoa_view_ isHidden];
 }
 
 gfx::Rect RenderWidgetHostViewMac::GetViewBounds() const {
@@ skipping 419 matching lines @@
   // If compositing_iosurface_ exists and has been poisoned, destroy it
   // and allow EnsureCompositedIOSurface to recreate it below. Keep a
   // reference to the destroyed layer around until after the below call
   // to LayoutLayers, to avoid flickers.
   base::ScopedClosureRunner scoped_layer_remover;
   if (compositing_iosurface_context_ &&
       compositing_iosurface_context_->HasBeenPoisoned()) {
     scoped_layer_remover.Reset(
         base::Bind(RemoveLayerFromSuperlayer, compositing_iosurface_layer_));
     DestroyCompositedIOSurfaceLayer(kLeaveLayerInHierarchy);
-    DestroyCompositedIOSurfaceAndLayer(kDestroyContext);
+    DestroyCompositedIOSurfaceAndLayer();
   }
 
   // Ensure compositing_iosurface_ and compositing_iosurface_context_ be
   // allocated.
   if (!EnsureCompositedIOSurface()) {
     LOG(ERROR) << "Failed EnsureCompositingIOSurface";
     return;
   }
 
   // Make the context current and update the IOSurface with the handle
@@ skipping 88 matching lines @@
         !([window occlusionState] & NSWindowOcclusionStateVisible);
     // Note that we aggressively ack even if this particular frame is not being
     // 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_ gotNewFrame];
-  } else {
-    gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
-        compositing_iosurface_context_->cgl_context());
-    DrawIOSurfaceWithoutCoreAnimation();
-  }
+  DCHECK(compositing_iosurface_layer_);
+  [compositing_iosurface_layer_ gotNewFrame];
 
   // 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::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()));
-
-  GLint old_gl_surface_order = 0;
-  GLint new_gl_surface_order = allow_overlapping_views_ ? -1 : 1;
-  [compositing_iosurface_context_->nsgl_context()
-      getValues:&old_gl_surface_order
-      forParameter:NSOpenGLCPSurfaceOrder];
-  if (old_gl_surface_order != new_gl_surface_order) {
-    [compositing_iosurface_context_->nsgl_context()
-        setValues:&new_gl_surface_order
-        forParameter:NSOpenGLCPSurfaceOrder];
-  }
-
-  // Instead of drawing, request that underlay view redraws.
-  if (underlay_view_ &&
-      underlay_view_->compositing_iosurface_ &&
-      underlay_view_has_drawn_) {
-    [underlay_view_->cocoa_view() setNeedsDisplayInRect:NSMakeRect(0, 0, 1, 1)];
-    return;
-  }
-
-  bool has_overlay = overlay_view_ && overlay_view_->compositing_iosurface_;
-  if (has_overlay) {
-    // Un-bind the overlay view's OpenGL context, since its content will be
-    // drawn by this context. Not doing this can result in corruption.
-    // http://crbug.com/330701
-    overlay_view_->ClearBoundContextDrawable();
-  }
-  [compositing_iosurface_context_->nsgl_context() setView:cocoa_view_];
-
-  gfx::Rect view_rect(NSRectToCGRect([cocoa_view_ frame]));
-  if (!compositing_iosurface_->DrawIOSurface(
-          compositing_iosurface_context_, view_rect,
-          ViewScaleFactor(), !has_overlay)) {
-    GotAcceleratedCompositingError();
-    return;
-  }
-
-  if (has_overlay) {
-    overlay_view_->underlay_view_has_drawn_ = true;
-    gfx::Rect overlay_view_rect(
-        NSRectToCGRect([overlay_view_->cocoa_view() frame]));
-    overlay_view_rect.set_x(overlay_view_offset_.x());
-    overlay_view_rect.set_y(view_rect.height() -
-                            overlay_view_rect.height() -
-                            overlay_view_offset_.y());
-    if (!overlay_view_->compositing_iosurface_->DrawIOSurface(
-            compositing_iosurface_context_, overlay_view_rect,
-            overlay_view_->ViewScaleFactor(), true)) {
-      GotAcceleratedCompositingError();
-      return;
-    }
-  }
-
-  SendPendingLatencyInfoToHost();
-}
-
 void RenderWidgetHostViewMac::GotAcceleratedCompositingError() {
   LOG(ERROR) << "Encountered accelerated compositing error";
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&RenderWidgetHostViewMac::DestroyCompositingStateOnError,
                  weak_factory_.GetWeakPtr()));
 }
 
 void RenderWidgetHostViewMac::DestroyCompositingStateOnError() {
   // This should be called with a clean stack. Make sure that no context is
   // current.
   DCHECK(!CGLGetCurrentContext());
 
   // The existing GL contexts may be in a bad state, so don't re-use any of the
   // existing ones anymore, rather, allocate new ones.
   if (compositing_iosurface_context_)
     compositing_iosurface_context_->PoisonContextAndSharegroup();
 
-  DestroyCompositedIOSurfaceAndLayer(kDestroyContext);
+  DestroyCompositedIOSurfaceAndLayer();
 
   // Request that a new frame be generated and dirty the view.
   if (render_widget_host_)
     render_widget_host_->ScheduleComposite();
   [cocoa_view_ setNeedsDisplay:YES];
 
-  // Mark the last frame as not accelerated (so that the window is prepared for
-  // an underlay next time an accelerated frame comes in).
-  last_frame_was_accelerated_ = false;
-
   // TODO(ccameron): It may be a good idea to request that the renderer recreate
   // its GL context as well, and fall back to software if this happens
   // repeatedly.
 }
 
 void RenderWidgetHostViewMac::SetOverlayView(
     RenderWidgetHostViewMac* overlay, const gfx::Point& offset) {
   if (overlay_view_)
     overlay_view_->underlay_view_.reset();
 
   overlay_view_ = overlay->overlay_view_weak_factory_.GetWeakPtr();
   overlay_view_->underlay_view_ = overlay_view_weak_factory_.GetWeakPtr();
-  if (use_core_animation_)
-    return;
-
-  overlay_view_offset_ = offset;
-  overlay_view_->underlay_view_has_drawn_ = false;
-
-  [cocoa_view_ setNeedsDisplay:YES];
-  [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
 }
 
 void RenderWidgetHostViewMac::RemoveOverlayView() {
   if (overlay_view_) {
     overlay_view_->underlay_view_.reset();
     overlay_view_.reset();
   }
-  if (use_core_animation_)
-    return;
-
-  [cocoa_view_ setNeedsDisplay:YES];
-  [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
 }
 
 bool RenderWidgetHostViewMac::GetLineBreakIndex(
     const std::vector<gfx::Rect>& bounds,
     const gfx::Range& range,
     size_t* line_break_point) {
   DCHECK(line_break_point);
   if (range.start() >= bounds.size() || range.is_reversed() || range.is_empty())
     return false;
 
@@ skipping 155 matching lines @@
                         params.surface_scale_factor,
                         params.latency_info);
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSuspend() {
   if (compositing_iosurface_)
     compositing_iosurface_->UnrefIOSurface();
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceRelease() {
-  DestroyCompositedIOSurfaceAndLayer(kDestroyContext);
+  DestroyCompositedIOSurfaceAndLayer();
 }
 
 bool RenderWidgetHostViewMac::HasAcceleratedSurface(
       const gfx::Size& desired_size) {
-  if (last_frame_was_accelerated_) {
-    return compositing_iosurface_ &&
-           compositing_iosurface_->HasIOSurface() &&
+  if (compositing_iosurface_) {
+    return compositing_iosurface_->HasIOSurface() &&
            (desired_size.IsEmpty() ||
                compositing_iosurface_->dip_io_surface_size() == desired_size);
-  } else {
-    return (software_frame_manager_->HasCurrentFrame() &&
-           (desired_size.IsEmpty() ||
+  }
+  if (software_frame_manager_->HasCurrentFrame()) {
+    return (desired_size.IsEmpty() ||
                software_frame_manager_->GetCurrentFrameSizeInDIP() ==
-                   desired_size));
+                   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 (!browser_compositor_view_) {
@@ skipping 23 matching lines @@
             frame->software_frame_data.get(),
             frame->metadata.device_scale_factor,
             render_widget_host_->GetProcess()->GetHandle())) {
       render_widget_host_->GetProcess()->ReceivedBadMessage();
       return;
     }
 
     // Add latency info to report when the frame finishes drawing.
     AddPendingLatencyInfo(frame->metadata.latency_info);
 
-    if (use_core_animation_) {
-      const void* pixels = software_frame_manager_->GetCurrentFramePixels();
-      gfx::Size size_in_pixels =
-          software_frame_manager_->GetCurrentFrameSizeInPixels();
+    const void* pixels = software_frame_manager_->GetCurrentFramePixels();
+    gfx::Size size_in_pixels =
+        software_frame_manager_->GetCurrentFrameSizeInPixels();
 
-      EnsureSoftwareLayer();
-      [software_layer_ setContentsToData:pixels
-                            withRowBytes:4 * size_in_pixels.width()
-                           withPixelSize:size_in_pixels
-                         withScaleFactor:frame->metadata.device_scale_factor];
+    EnsureSoftwareLayer();
+    [software_layer_ setContentsToData:pixels
+                          withRowBytes:4 * size_in_pixels.width()
+                         withPixelSize:size_in_pixels
+                       withScaleFactor:frame->metadata.device_scale_factor];
 
-      // Send latency information to the host immediately, as there will be no
-      // subsequent draw call in which to do so.
-      SendPendingLatencyInfoToHost();
-    }
+    // Send latency information to the host immediately, as there will be no
+    // subsequent draw call in which to do so.
+    SendPendingLatencyInfoToHost();
 
     GotSoftwareFrame();
 
     cc::CompositorFrameAck ack;
     RenderWidgetHostImpl::SendSwapCompositorFrameAck(
         render_widget_host_->GetRoutingID(),
         software_frame_manager_->GetCurrentFrameOutputSurfaceId(),
         render_widget_host_->GetProcess()->GetID(),
         ack);
     software_frame_manager_->SwapToNewFrameComplete(
@@ skipping 112 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() {
   EnsureCompositedIOSurfaceLayer();
   SendVSyncParametersToRenderer();
-  if (!last_frame_was_accelerated_) {
-    last_frame_was_accelerated_ = true;
 
-    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 and layer.
-    software_frame_manager_->DiscardCurrentFrame();
-    DestroySoftwareLayer();
-  }
+  // Delete software backingstore and layer.
+  software_frame_manager_->DiscardCurrentFrame();
+  DestroySoftwareLayer();
 }
 
 void RenderWidgetHostViewMac::GotSoftwareFrame() {
   TRACE_EVENT0("browser", "RenderWidgetHostViewMac::GotSoftwareFrame");
 
   if (!render_widget_host_)
     return;
 
   EnsureSoftwareLayer();
   LayoutLayers();
   SendVSyncParametersToRenderer();
 
   // Draw the contents of the frame immediately. It is critical that this
   // happen before the frame be acked, otherwise the new frame will likely be
   // ready before the drawing is complete, thrashing the browser main thread.
-  if (use_core_animation_) {
-    [software_layer_ displayIfNeeded];
-  } else {
-    [cocoa_view_ setNeedsDisplay:YES];
-    [cocoa_view_ displayIfNeeded];
-  }
+  [software_layer_ displayIfNeeded];
 
-  if (last_frame_was_accelerated_) {
-    last_frame_was_accelerated_ = false;
-
-    // If overlapping views are allowed, then don't unbind the context
-    // from the view (that is, don't call clearDrawble -- just delete the
-    // texture and IOSurface). Rather, let it sit behind the software frame
-    // that will be put up in front. This will prevent transparent
-    // flashes.
-    // http://crbug.com/154531
-    // Also note that it is necessary that clearDrawable be called if
-    // overlapping views are not allowed, e.g, for content shell.
-    // http://crbug.com/178408
-    // Disable screen updates so that the changes of flashes is minimized.
-    // http://crbug.com/279472
-    if (!use_core_animation_)
-      [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
-    if (allow_overlapping_views_)
-      DestroyCompositedIOSurfaceAndLayer(kLeaveContextBoundToView);
-    else
-      DestroyCompositedIOSurfaceAndLayer(kDestroyContext);
-  }
+  DestroyCompositedIOSurfaceAndLayer();
 }
 
 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 13 matching lines @@
         render_widget_host_->GetRoutingID(), visible));
   }
 }
 
 void RenderWidgetHostViewMac::WindowFrameChanged() {
   if (render_widget_host_) {
     render_widget_host_->Send(new ViewMsg_WindowFrameChanged(
         render_widget_host_->GetRoutingID(), GetBoundsInRootWindow(),
         GetViewBounds()));
   }
-
-  if (compositing_iosurface_ && !use_core_animation_) {
-    // This will migrate the context to the appropriate window.
-    if (!EnsureCompositedIOSurface())
-      GotAcceleratedCompositingError();
-  }
 }
 
 void RenderWidgetHostViewMac::ShowDefinitionForSelection() {
   RenderWidgetHostViewMacDictionaryHelper helper(this);
   helper.ShowDefinitionForSelection();
 }
 
 void RenderWidgetHostViewMac::SetBackgroundOpaque(bool opaque) {
   RenderWidgetHostViewBase::SetBackgroundOpaque(opaque);
   if (render_widget_host_)
@@ skipping 98 matching lines @@
 
   return gfx::ToEnclosingRect(gfx::ScaleRect(src_gl_subrect,
                                              ViewScaleFactor()));
 }
 
 void RenderWidgetHostViewMac::AddPendingLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
   // If a screenshot is being taken when using CoreAnimation, send a few extra
   // calls to setNeedsDisplay and wait for their resulting display calls,
   // before reporting that the frame has reached the screen.
-  if (use_core_animation_) {
-    bool should_defer = false;
-    for (size_t i = 0; i < latency_info.size(); i++) {
-      if (latency_info[i].FindLatency(
-              ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT,
-              render_widget_host_->GetLatencyComponentId(),
-              NULL)) {
-        should_defer = true;
-      }
+  bool should_defer = false;
+  for (size_t i = 0; i < latency_info.size(); i++) {
+    if (latency_info[i].FindLatency(
+            ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT,
+            render_widget_host_->GetLatencyComponentId(),
+            NULL)) {
+      should_defer = true;
     }
-    if (should_defer) {
-      // Multiple pending screenshot requests will work, but if every frame
-      // requests a screenshot, then the delay will never expire. Assert this
-      // here to avoid this.
-      CHECK_EQ(pending_latency_info_delay_, 0u);
-      // Wait a fixed number of frames (calls to CALayer::display) before
-      // claiming that the screenshot has reached the screen. This number
-      // comes from taking the first number where tests didn't fail (six),
-      // and doubling it.
-      const uint32 kScreenshotLatencyDelayInFrames = 12;
-      pending_latency_info_delay_ = kScreenshotLatencyDelayInFrames;
-      TickPendingLatencyInfoDelay();
-    }
+  }
+  if (should_defer) {
+    // Multiple pending screenshot requests will work, but if every frame
+    // requests a screenshot, then the delay will never expire. Assert this
+    // here to avoid this.
+    CHECK_EQ(pending_latency_info_delay_, 0u);
+    // Wait a fixed number of frames (calls to CALayer::display) before
+    // claiming that the screenshot has reached the screen. This number
+    // comes from taking the first number where tests didn't fail (six),
+    // and doubling it.
+    const uint32 kScreenshotLatencyDelayInFrames = 12;
+    pending_latency_info_delay_ = kScreenshotLatencyDelayInFrames;
+    TickPendingLatencyInfoDelay();
   }
 
   for (size_t i = 0; i < latency_info.size(); i++) {
     pending_latency_info_.push_back(latency_info[i]);
   }
 }
 
 void RenderWidgetHostViewMac::SendPendingLatencyInfoToHost() {
   if (pending_latency_info_delay_) {
     pending_latency_info_delay_ -= 1;
@@ skipping 71 matching lines @@
   render_widget_host_->PauseForPendingResizeOrRepaints();
 
   // Immediately draw any frames that haven't been drawn yet. This is necessary
   // 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]);
 
@@ skipping 95 matching lines @@
         ui::GetScaleFactorForNativeView(self);
 
     // OpenGL support:
     if ([self respondsToSelector:
         @selector(setWantsBestResolutionOpenGLSurface:)]) {
       [self setWantsBestResolutionOpenGLSurface:YES];
     }
     handlingGlobalFrameDidChange_ = NO;
     [[NSNotificationCenter defaultCenter]
         addObserver:self
-           selector:@selector(globalFrameDidChange:)
-               name:NSViewGlobalFrameDidChangeNotification
-             object:self];
-    [[NSNotificationCenter defaultCenter]
-        addObserver:self
            selector:@selector(didChangeScreenParameters:)
                name:NSApplicationDidChangeScreenParametersNotification
              object:nil];
   }
   return self;
 }
 
 - (void)dealloc {
   // Unbind the GL context from this view. If this is not done before super's
   // dealloc is called then the GL context will crash when it reaches into
@@ skipping 614 matching lines @@
     // it for anything yet.
     const WebGestureEvent& webEvent =
         WebInputEventFactory::gestureEvent(event, self);
     renderWidgetHostView_->render_widget_host_->ForwardGestureEvent(webEvent);
   }
 }
 
 - (void)viewWillMoveToWindow:(NSWindow*)newWindow {
   NSWindow* oldWindow = [self window];
 
-  // We're messing with the window, so do this to ensure no flashes. This one
-  // prevents a flash when the current tab is closed.
-  if (!renderWidgetHostView_->use_core_animation_)
-    [oldWindow disableScreenUpdatesUntilFlush];
-
   NSNotificationCenter* notificationCenter =
       [NSNotificationCenter defaultCenter];
 
   // Backing property notifications crash on 10.6 when building with the 10.7
   // SDK, see http://crbug.com/260595.
   static BOOL supportsBackingPropertiesNotification =
       SupportsBackingPropertiesChangedNotification();
 
   if (oldWindow) {
     if (supportsBackingPropertiesNotification) {
@@ skipping 44 matching lines @@
 
   // Allocating a CGLayerRef with the current scale factor immediately from
   // this handler doesn't work. Schedule the backing store update on the
   // next runloop cycle, then things are read for CGLayerRef allocations to
   // work.
   [self performSelector:@selector(updateScreenProperties)
              withObject:nil
              afterDelay:0];
 }
 
-- (void)globalFrameDidChange:(NSNotification*)notification {
-  if (handlingGlobalFrameDidChange_)
-    return;
-
-  handlingGlobalFrameDidChange_ = YES;
-  if (!renderWidgetHostView_->use_core_animation_ &&
-      renderWidgetHostView_->compositing_iosurface_context_) {
-    [renderWidgetHostView_->compositing_iosurface_context_->nsgl_context()
-        update];
-  }
-  handlingGlobalFrameDidChange_ = NO;
-}
-
 - (void)windowChangedGlobalFrame:(NSNotification*)notification {
   renderWidgetHostView_->UpdateScreenInfo(
       renderWidgetHostView_->GetNativeView());
 }
 
 - (void)setFrameSize:(NSSize)newSize {
   TRACE_EVENT0("browser", "RenderWidgetHostViewCocoa::setFrameSize");
 
   // NB: -[NSView setFrame:] calls through -setFrameSize:, so overriding
   // -setFrame: isn't neccessary.
@@ skipping 12 matching lines @@
   if (renderWidgetHostView_->delegated_frame_host_)
     renderWidgetHostView_->delegated_frame_host_->WasResized();
 
   // Wait for the frame that WasResize might have requested. If the view is
   // being made visible at a new size, then this call will have no effect
   // because the view widget is still hidden, and the pause call in WasShown
   // will have this effect for us.
   renderWidgetHostView_->PauseForPendingResizeOrRepaintsAndDraw();
 }
 
-// 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
-                             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)];
-    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)];
-    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_) {
-    // 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);
-    return;
-  }
-
-  const gfx::Rect damagedRect([self flipNSRectToRect:dirtyRect]);
-
-  if (renderWidgetHostView_->last_frame_was_accelerated_ &&
-      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);
-    }
-
-    gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
-        renderWidgetHostView_->compositing_iosurface_context_->cgl_context());
-    renderWidgetHostView_->DrawIOSurfaceWithoutCoreAnimation();
-    return;
-  }
-
-  CGContextRef context = static_cast<CGContextRef>(
-      [[NSGraphicsContext currentContext] graphicsPort]);
-  [self drawWithDirtyRect:NSRectToCGRect(dirtyRect)
-                inContext:context];
-}
-
-- (void)drawWithDirtyRect:(CGRect)dirtyRect
-                inContext:(CGContextRef)context {
-  content::SoftwareFrameManager* software_frame_manager =
-      renderWidgetHostView_->software_frame_manager_.get();
-  if (software_frame_manager->HasCurrentFrame()) {
-    // Note: All coordinates are in view units, not pixels.
-    gfx::Rect bitmapRect(
-            software_frame_manager->GetCurrentFrameSizeInDIP());
-
-    // 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]) - bitmapRect.height();
-
-    NSRect nsDirtyRect = NSRectFromCGRect(dirtyRect);
-    const gfx::Rect damagedRect([self flipNSRectToRect:nsDirtyRect]);
-
-    gfx::Rect paintRect = gfx::IntersectRects(bitmapRect, damagedRect);
-    if (!paintRect.IsEmpty()) {
-      gfx::Size sizeInPixels =
-          software_frame_manager->GetCurrentFrameSizeInPixels();
-      base::ScopedCFTypeRef<CGDataProviderRef> dataProvider(
-          CGDataProviderCreateWithData(
-              NULL,
-              software_frame_manager->GetCurrentFramePixels(),
-              4 * sizeInPixels.width() * sizeInPixels.height(),
-              NULL));
-      base::ScopedCFTypeRef<CGImageRef> image(
-          CGImageCreate(
-              sizeInPixels.width(),
-              sizeInPixels.height(),
-              8,
-              32,
-              4 * sizeInPixels.width(),
-              base::mac::GetSystemColorSpace(),
-              kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,
-              dataProvider,
-              NULL,
-              false,
-              kCGRenderingIntentDefault));
-      CGRect imageRect = bitmapRect.ToCGRect();
-      imageRect.origin.y = yOffset;
-      CGContextDrawImage(context, imageRect, image);
-    }
-
-    renderWidgetHostView_->SendPendingLatencyInfoToHost();
-
-    // Fill the remaining portion of the damagedRect with white
-    [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 {
-    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_;
 }
 
 - (BOOL)acceptsFirstResponder {
   if (!renderWidgetHostView_->render_widget_host_)
     return NO;
@@ skipping 909 matching lines @@
   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];
+  return YES;
 }
 
 // "-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