Move scoped_cftyperef from base to base/mac, use the new namespace, and name ...

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/mac/scoped_cftyperef.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 "gfx/rect.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:
@@ skipping 38 matching lines @@
   // Our paints are always synchronous and the caller can free the TransportDIB,
   // even on failure.
   *painted_synchronously = true;
 
   DCHECK_NE(static_cast<bool>(cg_layer()), static_cast<bool>(cg_bitmap()));
 
   TransportDIB* dib = process->GetTransportDIB(bitmap);
   if (!dib)
     return;
 
-  scoped_cftyperef<CGDataProviderRef> data_provider(
+  base::mac::ScopedCFTypeRef<CGDataProviderRef> data_provider(
       CGDataProviderCreateWithData(NULL, dib->memory(),
       bitmap_rect.width() * bitmap_rect.height() * 4, NULL));
 
-  scoped_cftyperef<CGImageRef> bitmap_image(
+  base::mac::ScopedCFTypeRef<CGImageRef> bitmap_image(
       CGImageCreate(bitmap_rect.width(), bitmap_rect.height(), 8, 32,
           4 * bitmap_rect.width(), mac_util::GetSystemColorSpace(),
           kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,
           data_provider, NULL, false, kCGRenderingIntentDefault));
 
   for (size_t i = 0; i < copy_rects.size(); i++) {
     const gfx::Rect& copy_rect = copy_rects[i];
 
     // Only the subpixels given by copy_rect have pixels to copy.
-    scoped_cftyperef<CGImageRef> image(
+    base::mac::ScopedCFTypeRef<CGImageRef> image(
         CGImageCreateWithImageInRect(bitmap_image, CGRectMake(
             copy_rect.x() - bitmap_rect.x(),
             copy_rect.y() - bitmap_rect.y(),
             copy_rect.width(),
             copy_rect.height())));
 
     if (!cg_layer()) {
       // The view may have moved to a window.  Try to get a CGLayer.
       cg_layer_.reset(CreateCGLayer());
       if (cg_layer()) {
         // now that we have a layer, copy the cached image into it
-        scoped_cftyperef<CGImageRef> bitmap_image(
+        base::mac::ScopedCFTypeRef<CGImageRef> bitmap_image(
             CGBitmapContextCreateImage(cg_bitmap_));
         CGContextDrawImage(CGLayerGetContext(cg_layer()),
                            CGRectMake(0, 0, size().width(), size().height()),
                            bitmap_image);
         // Discard the cache bitmap, since we no longer need it.
         cg_bitmap_.reset(NULL);
       }
     }
 
     DCHECK_NE(static_cast<bool>(cg_layer()), static_cast<bool>(cg_bitmap()));
@@ skipping 48 matching lines @@
 
   // 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()) {
       // See http://crbug.com/45553 , comments 5 and 6.
       static bool needs_layer_workaround = NeedsLayerWorkaround();
 
-      scoped_cftyperef<CGLayerRef> new_layer;
+      base::mac::ScopedCFTypeRef<CGLayerRef> new_layer;
       CGContextRef 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);
 
       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<CGImageRef> bitmap_image(
+      base::mac::ScopedCFTypeRef<CGImageRef> bitmap_image(
           CGBitmapContextCreateImage(cg_bitmap_));
       CGContextSaveGState(cg_bitmap_);
       CGContextClipToRect(cg_bitmap_,
                           CGRectMake(clip_rect.x(),
                                      size().height() - clip_rect.bottom(),
                                      clip_rect.width(),
                                      clip_rect.height()));
       CGContextDrawImage(cg_bitmap_,
                          CGRectMake(dx, -dy, size().width(), size().height()),
                          bitmap_image);
@@ skipping 34 matching lines @@
   CGContextRef context = CGBitmapContextCreate(NULL,
                                                size().width(), size().height(),
                                                8, size().width() * 4,
                                                mac_util::GetSystemColorSpace(),
                                                kCGImageAlphaPremultipliedFirst |
                                                    kCGBitmapByteOrder32Host);
   DCHECK(context);
 
   return context;
 }