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

webkit/glue/webcursor_mac.mm

 // Copyright (c) 2008 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 "webkit/glue/webcursor.h"
 
 #import <AppKit/AppKit.h>
 #include <Carbon/Carbon.h>
 
 #include "base/logging.h"
 #include "base/nsimage_cache_mac.h"
-#include "base/scoped_cftyperef.h"
+#include "base/mac/scoped_cftyperef.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebImage.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebSize.h"
 
 using WebKit::WebCursorInfo;
 using WebKit::WebImage;
 using WebKit::WebSize;
 
 namespace {
 
 // TODO: This image fetch can (and probably should) be serviced by the resource
 // resource bundle instead of going through nsimage_cache.
 NSCursor* LoadCursor(const char* name, int x, int y) {
   NSString* file_name = [NSString stringWithUTF8String:name];
   DCHECK(file_name);
   NSImage* cursor_image = nsimage_cache::ImageNamed(file_name);
   DCHECK(cursor_image);
   return [[[NSCursor alloc] initWithImage:cursor_image
                                   hotSpot:NSMakePoint(x, y)] autorelease];
 }
 
 CGImageRef CreateCGImageFromCustomData(const std::vector<char>& custom_data,
                                        const gfx::Size& custom_size) {
-  scoped_cftyperef<CGColorSpaceRef> cg_color(CGColorSpaceCreateDeviceRGB());
+  base::mac::ScopedCFTypeRef<CGColorSpaceRef> cg_color(
+      CGColorSpaceCreateDeviceRGB());
   // This is safe since we're not going to draw into the context we're creating.
   void* data = const_cast<char*>(&custom_data[0]);
   // The settings here match SetCustomData() below; keep in sync.
-  scoped_cftyperef<CGContextRef> context(
+  base::mac::ScopedCFTypeRef<CGContextRef> context(
       CGBitmapContextCreate(data,
                             custom_size.width(),
                             custom_size.height(),
                             8,
                             custom_size.width()*4,
                             cg_color.get(),
                             kCGImageAlphaPremultipliedLast |
                             kCGBitmapByteOrder32Big));
   return CGBitmapContextCreateImage(context.get());
 }
 
 NSCursor* CreateCustomCursor(const std::vector<char>& custom_data,
                              const gfx::Size& custom_size,
                              const gfx::Point& hotspot) {
   // CG throws a cocoa exception if we try to create an empty image, which
   // results in an infinite loop.  This CHECK ensures that we crash instead.
   CHECK(!custom_data.empty());
 
-  scoped_cftyperef<CGImageRef> cg_image(
+  base::mac::ScopedCFTypeRef<CGImageRef> cg_image(
       CreateCGImageFromCustomData(custom_data, custom_size));
 
   NSBitmapImageRep* ns_bitmap =
       [[NSBitmapImageRep alloc] initWithCGImage:cg_image.get()];
   NSImage* cursor_image = [[NSImage alloc] init];
   DCHECK(cursor_image);
   [cursor_image addRepresentation:ns_bitmap];
   [ns_bitmap release];
 
   NSCursor* cursor = [[NSCursor alloc] initWithImage:cursor_image
@@ skipping 181 matching lines @@
       }
       if (mask & 0x8000)
         raw_data.push_back(0xFF);
       else
         raw_data.push_back(0x00);
       data <<= 1;
       mask <<= 1;
     }
   }
 
-  scoped_cftyperef<CGImageRef> cg_image(
+  base::mac::ScopedCFTypeRef<CGImageRef> cg_image(
       CreateCGImageFromCustomData(raw_data, custom_size));
 
   WebKit::WebCursorInfo cursor_info;
   cursor_info.type = WebCursorInfo::TypeCustom;
   cursor_info.hotSpot = WebKit::WebPoint(cursor->hotSpot.h, cursor->hotSpot.v);
   cursor_info.customImage = cg_image.get();
 
   InitFromCursorInfo(cursor_info);
 }
 
@@ skipping 43 matching lines @@
     }
   }
 
   InitFromCursorInfo(cursor_info);
 }
 
 void WebCursor::SetCustomData(const WebImage& image) {
   if (image.isNull())
     return;
 
-  scoped_cftyperef<CGColorSpaceRef> cg_color(
+  base::mac::ScopedCFTypeRef<CGColorSpaceRef> cg_color(
       CGColorSpaceCreateDeviceRGB());
 
   const WebSize& image_dimensions = image.size();
   int image_width = image_dimensions.width;
   int image_height = image_dimensions.height;
 
   size_t size = image_height * image_width * 4;
   custom_data_.resize(size);
   custom_size_.set_width(image_width);
   custom_size_.set_height(image_height);
 
   // These settings match up with the code in CreateCustomCursor() above; keep
   // them in sync.
   // TODO(avi): test to ensure that the flags here are correct for RGBA
-  scoped_cftyperef<CGContextRef> context(
+  base::mac::ScopedCFTypeRef<CGContextRef> context(
       CGBitmapContextCreate(&custom_data_[0],
                             image_width,
                             image_height,
                             8,
                             image_width * 4,
                             cg_color.get(),
                             kCGImageAlphaPremultipliedLast |
                             kCGBitmapByteOrder32Big));
   CGRect rect = CGRectMake(0, 0, image_width, image_height);
   CGContextDrawImage(context.get(), rect, image.getCGImageRef());
 }
 
 void WebCursor::ImageFromCustomData(WebImage* image) const {
   if (custom_data_.empty())
     return;
 
-  scoped_cftyperef<CGImageRef> cg_image(
+  base::mac::ScopedCFTypeRef<CGImageRef> cg_image(
       CreateCGImageFromCustomData(custom_data_, custom_size_));
   *image = cg_image.get();
 }
 
 void WebCursor::InitPlatformData() {
   return;
 }
 
 bool WebCursor::SerializePlatformData(Pickle* pickle) const {
   return true;
 }
 
 bool WebCursor::DeserializePlatformData(const Pickle* pickle, void** iter) {
   return true;
 }
 
 bool WebCursor::IsPlatformDataEqual(const WebCursor& other) const {
   return true;
 }
 
 void WebCursor::CleanupPlatformData() {
   return;
 }
 
 void WebCursor::CopyPlatformData(const WebCursor& other) {
   return;
 }