Refactor device scale factor on Mac and fix CoreAnimation bug

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 111 matching lines @@
           windowDelegateProtocol,
           @selector(windowDidChangeBackingProperties:),
           NO,
           YES);
 
   // If the protocol does not contain the method, the returned method
   // description is {NULL, NULL}
   return methodDescription.name != NULL || methodDescription.types != NULL;
 }
 
-static float ScaleFactor(NSView* view) {
+static float ScaleFactorForView(NSView* view) {
   return ui::GetImageScale(ui::GetScaleFactorForNativeView(view));
 }
 
 // Private methods:
 @interface RenderWidgetHostViewCocoa ()
 @property(nonatomic, assign) NSRange selectedRange;
 @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)drawBackingStore:(BackingStoreMac*)backingStore
                dirtyRect:(CGRect)dirtyRect
                inContext:(CGContextRef)context;
-- (void)updateSoftwareLayerScaleFactor;
 - (void)checkForPluginImeCancellation;
 - (void)updateTabBackingStoreScaleFactor;
 - (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 245 matching lines @@
       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),
       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
@@ skipping 56 matching lines @@
   // not use explicit setView and clearDrawable calls.
   ClearBoundContextDrawable();
 
   software_layer_.reset([[CALayer alloc] init]);
   if (!software_layer_)
     LOG(ERROR) << "Failed to create CALayer for software rendering";
   [software_layer_ setBackgroundColor:CGColorGetConstantColor(kCGColorWhite)];
   [software_layer_ setDelegate:cocoa_view_];
   [software_layer_ setContentsGravity:kCAGravityTopLeft];
   [software_layer_ setFrame:NSRectToCGRect([cocoa_view_ bounds])];
+  if ([software_layer_ respondsToSelector:@selector(setContentsScale:)])
+    [software_layer_ setContentsScale:backing_store_scale_factor_];
   [software_layer_ setNeedsDisplay];
-  [cocoa_view_ updateSoftwareLayerScaleFactor];
 
   [cocoa_view_ setLayer:software_layer_];
   [cocoa_view_ setWantsLayer:YES];
-
-  if (compositing_iosurface_) {

[ccameron, 2014/02/19 00:52:05]

This block was a remnant from when dynamically enabling CoreAnimation was a
thing -- this is only called during init when there is no IOSurface yet now.

-    if (!CreateCompositedIOSurfaceLayer()) {
-      LOG(ERROR) << "Failed to create CALayer for existing IOSurface";
-      GotAcceleratedCompositingError();
-      return;
-    }
-  }
 }
 
 bool RenderWidgetHostViewMac::CreateCompositedIOSurface() {
   int current_window_number = use_core_animation_ ?
       CompositingIOSurfaceContext::kOffscreenContextWindowNumber :
       window_number();
   bool new_surface_needed = !compositing_iosurface_;
   bool new_context_needed =
     !compositing_iosurface_context_ ||
         (compositing_iosurface_context_ &&
@@ skipping 27 matching lines @@
     if (!compositing_iosurface_) {
       LOG(ERROR) << "Failed to create CompositingIOSurface";
       return false;
     }
   }
 
   return true;
 }
 
 bool RenderWidgetHostViewMac::CreateCompositedIOSurfaceLayer() {
-  CHECK(compositing_iosurface_context_ && compositing_iosurface_);
   if (compositing_iosurface_layer_ || !use_core_animation_)
     return true;
 
   ScopedCAActionDisabler disabler;
 
   // Create the GL CoreAnimation layer.
   if (!compositing_iosurface_layer_) {
     compositing_iosurface_layer_.reset([[CompositingIOSurfaceLayer alloc]
         initWithRenderWidgetHostViewMac:this]);
     if (!compositing_iosurface_layer_) {
       LOG(ERROR) << "Failed to create CALayer for IOSurface";
       return false;
     }
     [software_layer_ addSublayer:compositing_iosurface_layer_];
   }
 
   // Creating the CompositingIOSurfaceLayer may attempt to draw in setLayer,
   // which, if it fails, will promptly tear down everything that was just
   // created. If that happened, return failure.
-  return compositing_iosurface_context_ &&
-         compositing_iosurface_ &&
-         (compositing_iosurface_layer_ || !use_core_animation_);
+  return compositing_iosurface_layer_;
 }
 
 void RenderWidgetHostViewMac::DestroyCompositedIOSurfaceAndLayer(
     DestroyContextBehavior destroy_context_behavior) {
   // Any pending frames will not be displayed, so ack them now.
   SendPendingSwapAck();
 
   ScopedCAActionDisabler disabler;
 
   compositing_iosurface_.reset();
@@ skipping 133 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_);
+float RenderWidgetHostViewMac::ViewScaleFactor() const {
+  return ScaleFactorForView(cocoa_view_);
+}
+
+void RenderWidgetHostViewMac::UpdateBackingStoreScaleFactor() {
+  if (!render_widget_host_)
+    return;
+
+  float new_scale_factor = ScaleFactorForView(cocoa_view_);
+  if (new_scale_factor == backing_store_scale_factor_)
+    return;
+  backing_store_scale_factor_ = new_scale_factor;
+
+  BackingStoreMac* backing_store = static_cast<BackingStoreMac*>(
+      render_widget_host_->GetBackingStore(false));
+  if (backing_store)
+    backing_store->ScaleFactorChanged(backing_store_scale_factor_);
+
+  ScopedCAActionDisabler disabler;
+
+  if ([software_layer_ respondsToSelector:@selector(setContentsScale:)])
+    [software_layer_ setContentsScale:backing_store_scale_factor_];
+
+  // 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_layer_) {
+    [compositing_iosurface_layer_ disableCompositing];
+    compositing_iosurface_layer_.reset();
+    CreateCompositedIOSurfaceLayer();
+  }
+
+  render_widget_host_->NotifyScreenInfoChanged();
 }
 
 RenderWidgetHost* RenderWidgetHostViewMac::GetRenderWidgetHost() const {
   return render_widget_host_;
 }
 
 void RenderWidgetHostViewMac::WasShown() {
   if (!render_widget_host_->is_hidden())
     return;
 
@@ skipping 396 matching lines @@
     web_event.type = WebInputEvent::MouseLeave;
   ForwardMouseEvent(web_event);
 }
 
 bool RenderWidgetHostViewMac::IsPopup() const {
   return popup_type_ != blink::WebPopupTypeNone;
 }
 
 BackingStore* RenderWidgetHostViewMac::AllocBackingStore(
     const gfx::Size& size) {
-  float scale = ScaleFactor(cocoa_view_);
+  float scale = ScaleFactorForView(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,
     const SkBitmap::Config config) {
   if (config != SkBitmap::kARGB_8888_Config) {
     NOTIMPLEMENTED();
     callback.Run(false, SkBitmap());
   }
   base::ScopedClosureRunner scoped_callback_runner(
       base::Bind(callback, false, SkBitmap()));
-  float scale = ScaleFactor(cocoa_view_);
+  float scale = ScaleFactorForView(cocoa_view_);
   gfx::Size dst_pixel_size = gfx::ToFlooredSize(
       gfx::ScaleSize(dst_size, scale));
   if (compositing_iosurface_ && compositing_iosurface_->HasIOSurface()) {
     ignore_result(scoped_callback_runner.Release());
     compositing_iosurface_->CopyTo(GetScaledOpenGLPixelRect(src_subrect),
                                    dst_pixel_size,
                                    callback);
   } else if (software_frame_manager_->HasCurrentFrame()) {
     gfx::Rect src_pixel_rect = gfx::ToEnclosingRect(gfx::ScaleRect(
         src_subrect,
@@ skipping 287 matching lines @@
     // 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,
-          scale_factor(), !has_overlay)) {
+          ViewScaleFactor(), !has_overlay)) {
     return false;
   }
 
   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_->scale_factor(), true)) {
+            overlay_view_->ViewScaleFactor(), true)) {
       return false;
     }
   }
 
   SendPendingLatencyInfoToHost();
   SendPendingSwapAck();
   return true;
 }
 
 void RenderWidgetHostViewMac::GotAcceleratedCompositingError() {
@@ skipping 365 matching lines @@
 void RenderWidgetHostViewMac::GotAcceleratedFrame() {
   // Update the host with VSync parametrs.
   base::TimeTicks timebase;
   base::TimeDelta interval;
   if (compositing_iosurface_context_ &&
       compositing_iosurface_context_->display_link()->GetVSyncParameters(
           &timebase, &interval)) {
     render_widget_host_->UpdateVSyncParameters(timebase, interval);
   }
 
-  // Update the scale factor of the layer to match the scale factor of the
-  // IOSurface.
-  [compositing_iosurface_layer_ updateScaleFactor];
-
   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.
@@ skipping 110 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,
-                                             scale_factor()));
+                                             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++) {
@@ skipping 86 matching lines @@
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r {
   self = [super initWithFrame:NSZeroRect];
   if (self) {
     self.acceptsTouchEvents = YES;
     editCommand_helper_.reset(new RenderWidgetHostViewMacEditCommandHelper);
     editCommand_helper_->AddEditingSelectorsToClass([self class]);
 
     renderWidgetHostView_.reset(r);
     canBeKeyView_ = YES;
     focusedPluginIdentifier_ = -1;
-    deviceScaleFactor_ = ScaleFactor(self);
+    renderWidgetHostView_->backing_store_scale_factor_ =
+        ScaleFactorForView(self);
 
     // OpenGL support:
     if ([self respondsToSelector:
         @selector(setWantsBestResolutionOpenGLSurface:)]) {
       [self setWantsBestResolutionOpenGLSurface:YES];
     }
     handlingGlobalFrameDidChange_ = NO;
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(globalFrameDidChange:)
@@ skipping 641 matching lines @@
              object:newWindow];
     [notificationCenter
         addObserver:self
            selector:@selector(windowChangedGlobalFrame:)
                name:NSWindowDidEndLiveResizeNotification
              object:newWindow];
   }
 }
 
 - (void)updateTabBackingStoreScaleFactor {
-  if (!renderWidgetHostView_->render_widget_host_)
-    return;
-
-  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();
+  renderWidgetHostView_->UpdateBackingStoreScaleFactor();
 }
 
 // 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])
       doubleValue];
@@ skipping 1247 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 {
   TRACE_EVENT0("browser", "CompositingIOSurfaceLayer::drawLayer");
 
   DCHECK(renderWidgetHostView_->use_core_animation_);
   DCHECK([layer isEqual:renderWidgetHostView_->software_layer_]);
 
   CGRect clipRect = CGContextGetClipBoundingBox(context);
 
@@ skipping 56 matching lines @@
   return YES;
 }
 
 - (BOOL)isOpaque {
   if (renderWidgetHostView_->use_core_animation_)
     return YES;
   return [super isOpaque];
 }
 
 @end