Mac: Faster scrolling on 10.6.

chrome/browser/renderer_host/backing_store_mac.mm

 // Copyright (c) 2010 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.
 
 #import <Cocoa/Cocoa.h>
 
 #include "chrome/browser/renderer_host/backing_store_mac.h"
 
 #include "app/surface/transport_dib.h"
 #include "base/logging.h"
 #include "base/mac_util.h"
+#include "base/sys_info.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_widget_host.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 
 // Mac Backing Stores:
 //
 // Since backing stores are only ever written to or drawn into windows, we keep
 // our backing store in a CGLayer that can get cached in GPU memory.  This
 // allows acclerated drawing into the layer and lets scrolling and such happen
 // all or mostly on the GPU, which is good for performance.
 
+namespace {
+
+// Returns if this version of OS X has broken CGLayers, see

[Mark Mentovai, 2010/06/10 20:05:51]

“Returns if” implies that this function doesn’t return if CGLayers aren’t
broken. You should say “Returns whether”.

[Nico, 2010/06/10 20:10:30]

Done.

+// http://crbug.com/45553 , comments 5 and 6.
+bool NeedsLayerWorkaround() {
+  int32 os_major, os_minor, os_bugfix;
+  base::SysInfo::OperatingSystemVersionNumbers(
+      &os_major, &os_minor, &os_bugfix);
+  return os_major == 10 && os_minor == 5;

[Mark Mentovai, 2010/06/10 20:05:51]

For paranoia’s sake:

  return os_major < 10 || (os_major == 10 && os_minor <= 5);

[Nico, 2010/06/10 20:10:30]

Uh, no :-)

[rohitrao (ping after 24h), 2010/06/10 20:55:08]

Why not?  The specificity of checking for 10.5 scares me a bit.  Actually, I
would rather we (semantically) defaulted to the full copy and only implemented
the fast path for >= 10.6.

[Nico, 2010/06/10 21:08:04]

'cause Chrome won't run on 10.4 (or OS 9 for that matter). Hence, this is
functionally equivalent, but without the cargoculting.

+}
+
+}  // namespace
+
 BackingStoreMac::BackingStoreMac(RenderWidgetHost* widget,
                                  const gfx::Size& size)
     : BackingStore(widget, size) {
   cg_layer_.reset(CreateCGLayer());
   if (!cg_layer_) {
     // The view isn't in a window yet.  Use a CGBitmapContext for now.
     cg_bitmap_.reset(CreateCGBitmapContext());
   }
 }
 
@@ skipping 101 matching lines @@
   // scroll. Thus, we only have to worry about pixels which will end up inside
   // the clipping rectangle. (Note that the clipping rectangle is not
   // translated by the scroll.)
 
   // We assume |clip_rect| is contained within the backing store.
   DCHECK(clip_rect.bottom() <= size().height());
   DCHECK(clip_rect.right() <= size().width());
 
   if ((dx || dy) && abs(dx) < size().width() && abs(dy) < size().height()) {
     if (cg_layer()) {
-      scoped_cftyperef<CGLayerRef> new_layer(CreateCGLayer());
+      // See http://crbug.com/45553 , comments 5 and 6.
+      static bool needs_layer_workaround = NeedsLayerWorkaround();
 
-      // If the current view is in a window, the replacement must be too.
-      DCHECK(new_layer);
+      scoped_cftyperef<CGLayerRef> new_layer;
+      CGContextRef layer;
 
-      CGContextRef layer = CGLayerGetContext(new_layer);
-      CGContextDrawLayerAtPoint(layer, CGPointMake(0, 0), cg_layer());
+      if (needs_layer_workaround) {
+        new_layer.reset(CreateCGLayer());
+        // If the current view is in a window, the replacement must be too.
+        DCHECK(new_layer);
+
+        layer = CGLayerGetContext(new_layer);
+        CGContextDrawLayerAtPoint(layer, CGPointMake(0, 0), cg_layer());
+      } else {
+        layer = CGLayerGetContext(cg_layer());
+      }
+
       CGContextSaveGState(layer);
       CGContextClipToRect(layer,
                           CGRectMake(clip_rect.x(),
                                      size().height() - clip_rect.bottom(),
                                      clip_rect.width(),
                                      clip_rect.height()));
       CGContextDrawLayerAtPoint(layer, CGPointMake(dx, -dy), cg_layer());
       CGContextRestoreGState(layer);
-      cg_layer_.swap(new_layer);
+
+      if (needs_layer_workaround)
+        cg_layer_.swap(new_layer);
     } else {
       // We don't have a layer, so scroll the contents of the CGBitmapContext.
-      scoped_cftyperef<CGContextRef> new_bitmap(CreateCGBitmapContext());
       scoped_cftyperef<CGImageRef> bitmap_image(
           CGBitmapContextCreateImage(cg_bitmap_));
-      CGContextDrawImage(new_bitmap,
-                         CGRectMake(0, 0, size().width(), size().height()),
-                         bitmap_image);
-      CGContextSaveGState(new_bitmap);
-      CGContextClipToRect(new_bitmap,
+      CGContextSaveGState(cg_bitmap_);
+      CGContextClipToRect(cg_bitmap_,
                           CGRectMake(clip_rect.x(),
                                      size().height() - clip_rect.bottom(),
                                      clip_rect.width(),
                                      clip_rect.height()));
-      CGContextDrawImage(new_bitmap,
+      CGContextDrawImage(cg_bitmap_,
                          CGRectMake(dx, -dy, size().width(), size().height()),
                          bitmap_image);
-      CGContextRestoreGState(new_bitmap);
-      cg_bitmap_.swap(new_bitmap);
+      CGContextRestoreGState(cg_bitmap_);
     }
   }
 }
 
 CGLayerRef BackingStoreMac::CreateCGLayer() {
   // The CGLayer should be optimized for drawing into the containing window,
   // so extract a CGContext corresponding to the window to be passed to
   // CGLayerCreateWithContext.
   NSWindow* window = [render_widget_host()->view()->GetNativeView() window];
   if ([window windowNumber] <= 0) {
@@ skipping 23 matching lines @@
   CGContextRef context = CGBitmapContextCreate(NULL,
                                                size().width(), size().height(),
                                                8, size().width() * 4,
                                                mac_util::GetSystemColorSpace(),
                                                kCGImageAlphaPremultipliedFirst |
                                                    kCGBitmapByteOrder32Host);
   DCHECK(context);
 
   return context;
 }