Refactor the PlatformContext layer to have only one class.

skia/ext/bitmap_platform_device_mac.cc

 // Copyright (c) 2006-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 "skia/ext/bitmap_platform_device_mac.h"
 
 #include <time.h>
 
 #include "base/ref_counted.h"
 #include "skia/ext/skia_utils_mac.h"
@@ skipping 28 matching lines @@
     }
   } else {
     // Fill up available size.
     *size = available_size - *position;
   }
   return true;
 }
 
 }  // namespace
 
-class BitmapPlatformDeviceMac::BitmapPlatformDeviceMacData : public SkRefCnt {
+class BitmapPlatformDevice::BitmapPlatformDeviceData : public SkRefCnt {
  public:
-  explicit BitmapPlatformDeviceMacData(CGContextRef bitmap);
+  explicit BitmapPlatformDeviceData(CGContextRef bitmap);
 
   // Create/destroy CoreGraphics context for our bitmap data.
   CGContextRef GetBitmapContext() {
     LoadConfig();
     return bitmap_context_;
   }
 
   void ReleaseBitmapContext() {
     SkASSERT(bitmap_context_);
     CGContextRelease(bitmap_context_);
@@ skipping 19 matching lines @@
   bool config_dirty_;
 
   // Translation assigned to the CGContext: we need to keep track of this
   // separately so it can be updated even if the CGContext isn't created yet.
   SkMatrix transform_;
 
   // The current clipping
   SkRegion clip_region_;
 
  private:
-  friend class base::RefCounted<BitmapPlatformDeviceMacData>;
-  ~BitmapPlatformDeviceMacData() {
+  friend class base::RefCounted<BitmapPlatformDeviceData>;
+  ~BitmapPlatformDeviceData() {
     if (bitmap_context_)
       CGContextRelease(bitmap_context_);
   }
 
   // Disallow copy & assign.
-  BitmapPlatformDeviceMacData(const BitmapPlatformDeviceMacData&);
-  BitmapPlatformDeviceMacData& operator=(const BitmapPlatformDeviceMacData&);
+  BitmapPlatformDeviceData(const BitmapPlatformDeviceData&);
+  BitmapPlatformDeviceData& operator=(const BitmapPlatformDeviceData&);
 };
 
-BitmapPlatformDeviceMac::\
-    BitmapPlatformDeviceMacData::BitmapPlatformDeviceMacData(
+BitmapPlatformDevice::BitmapPlatformDeviceData::BitmapPlatformDeviceData(
     CGContextRef bitmap)
     : bitmap_context_(bitmap),
       config_dirty_(true) {  // Want to load the config next time.
   SkASSERT(bitmap_context_);
   // Initialize the clip region to the entire bitmap.
 
   SkIRect rect;
   rect.set(0, 0,
            CGBitmapContextGetWidth(bitmap_context_),
            CGBitmapContextGetHeight(bitmap_context_));
   clip_region_ = SkRegion(rect);
   transform_.reset();
   CGContextRetain(bitmap_context_);
   // We must save the state once so that we can use the restore/save trick
   // in LoadConfig().
   CGContextSaveGState(bitmap_context_);
 }
 
-void BitmapPlatformDeviceMac::BitmapPlatformDeviceMacData::SetMatrixClip(
+void BitmapPlatformDevice::BitmapPlatformDeviceData::SetMatrixClip(
     const SkMatrix& transform,
     const SkRegion& region) {
   transform_ = transform;
   clip_region_ = region;
   config_dirty_ = true;
 }
 
-void BitmapPlatformDeviceMac::BitmapPlatformDeviceMacData::LoadConfig() {
+void BitmapPlatformDevice::BitmapPlatformDeviceData::LoadConfig() {
   if (!config_dirty_ || !bitmap_context_)
     return;  // Nothing to do.
   config_dirty_ = false;
 
   // Transform.
   SkMatrix t(transform_);
 
   // We must restore and then save the state of the graphics context since the
   // calls to Load the clipping region to the context are strictly cummulative,
   // i.e., you can't replace a clip rect, other than with a save/restore.
   // But this implies that no other changes to the state are done elsewhere.
   // If we ever get to need to change this, then we must replace the clip rect
   // calls in LoadClippingRegionToCGContext() with an image mask instead.
   CGContextRestoreGState(bitmap_context_);
   CGContextSaveGState(bitmap_context_);
   LoadTransformToCGContext(bitmap_context_, t);
   t.setTranslateX(-t.getTranslateX());
   t.setTranslateY(-t.getTranslateY());
   LoadClippingRegionToCGContext(bitmap_context_, clip_region_, t);
 }
 
 
 // We use this static factory function instead of the regular constructor so
 // that we can create the pixel data before calling the constructor. This is
 // required so that we can call the base class' constructor with the pixel
 // data.
-BitmapPlatformDeviceMac* BitmapPlatformDeviceMac::Create(CGContextRef context,
-                                                         int width,
-                                                         int height,
-                                                         bool is_opaque) {
+BitmapPlatformDevice* BitmapPlatformDevice::Create(CGContextRef context,
+                                                   int width,
+                                                   int height,
+                                                   bool is_opaque) {
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
   if (bitmap.allocPixels() != true)
     return NULL;
   void* data = bitmap.getPixels();
 
   // Note: The Windows implementation clears the Bitmap later on.
   // This bears mentioning since removal of this line makes the
   // unit tests only fail periodically (or when MallocPreScribble is set).
   bitmap.eraseARGB(0, 0, 0, 0);
@@ skipping 19 matching lines @@
                             kCGImageAlphaPremultipliedFirst |
                                 kCGBitmapByteOrder32Host);
 
     // Change the coordinate system to match WebCore's
     CGContextTranslateCTM(context, 0, height);
     CGContextScaleCTM(context, 1.0, -1.0);
     CGColorSpaceRelease(color_space);
   }
 
   // The device object will take ownership of the graphics context.
-  return new BitmapPlatformDeviceMac(
-      new BitmapPlatformDeviceMacData(context), bitmap);
+  return new BitmapPlatformDevice(
+      new BitmapPlatformDeviceData(context), bitmap);
 }
 
 // The device will own the bitmap, which corresponds to also owning the pixel
 // data. Therefore, we do not transfer ownership to the SkDevice's bitmap.
-BitmapPlatformDeviceMac::BitmapPlatformDeviceMac(
-    BitmapPlatformDeviceMacData* data, const SkBitmap& bitmap)
-    : PlatformDeviceMac(bitmap),
+BitmapPlatformDevice::BitmapPlatformDevice(
+    BitmapPlatformDeviceData* data, const SkBitmap& bitmap)
+    : PlatformDevice(bitmap),
       data_(data) {
 }
 
 // The copy constructor just adds another reference to the underlying data.
 // We use a const cast since the default Skia definitions don't define the
 // proper constedness that we expect (accessBitmap should really be const).
-BitmapPlatformDeviceMac::BitmapPlatformDeviceMac(
-    const BitmapPlatformDeviceMac& other)
-    : PlatformDeviceMac(
-          const_cast<BitmapPlatformDeviceMac&>(other).accessBitmap(true)),
+BitmapPlatformDevice::BitmapPlatformDevice(
+    const BitmapPlatformDevice& other)
+    : PlatformDevice(
+          const_cast<BitmapPlatformDevice&>(other).accessBitmap(true)),
       data_(other.data_) {
   data_->ref();
 }
 
-BitmapPlatformDeviceMac::~BitmapPlatformDeviceMac() {
+BitmapPlatformDevice::~BitmapPlatformDevice() {
   data_->unref();
 }
 
-BitmapPlatformDeviceMac& BitmapPlatformDeviceMac::operator=(
-    const BitmapPlatformDeviceMac& other) {
+BitmapPlatformDevice& BitmapPlatformDevice::operator=(
+    const BitmapPlatformDevice& other) {
   data_ = other.data_;
   data_->ref();
   return *this;
 }
 
-CGContextRef BitmapPlatformDeviceMac::GetBitmapContext() {
+CGContextRef BitmapPlatformDevice::GetBitmapContext() {
   return data_->GetBitmapContext();
 }
 
-void BitmapPlatformDeviceMac::setMatrixClip(const SkMatrix& transform,
-                                            const SkRegion& region) {
+void BitmapPlatformDevice::setMatrixClip(const SkMatrix& transform,
+                                         const SkRegion& region) {
   data_->SetMatrixClip(transform, region);
 }
 
-void BitmapPlatformDeviceMac::DrawToContext(CGContextRef context, int x, int y,
-                                            const CGRect* src_rect) {
+void BitmapPlatformDevice::DrawToContext(CGContextRef context, int x, int y,
+                                         const CGRect* src_rect) {
   bool created_dc = false;
   if (!data_->bitmap_context_) {
     created_dc = true;
     GetBitmapContext();
   }
 
   // this should not make a copy of the bits, since we're not doing
   // anything to trigger copy on write
   CGImageRef image = CGBitmapContextCreateImage(data_->bitmap_context_);
   CGRect bounds;
@@ skipping 11 matching lines @@
     bounds.size.height = height();
     CGContextDrawImage(context, bounds, image);
   }
   CGImageRelease(image);
 
   if (created_dc)
     data_->ReleaseBitmapContext();
 }
 
 // Returns the color value at the specified location.
-SkColor BitmapPlatformDeviceMac::getColorAt(int x, int y) {
+SkColor BitmapPlatformDevice::getColorAt(int x, int y) {
   const SkBitmap& bitmap = accessBitmap(true);
   SkAutoLockPixels lock(bitmap);
   uint32_t* data = bitmap.getAddr32(0, 0);
   return static_cast<SkColor>(data[x + y * width()]);
 }
 
-void BitmapPlatformDeviceMac::onAccessBitmap(SkBitmap*) {
+void BitmapPlatformDevice::onAccessBitmap(SkBitmap*) {
   // Not needed in CoreGraphics
 }
 
-void BitmapPlatformDeviceMac::processPixels(int x, int y,
-                                            int width, int height,
-                                            adjustAlpha adjustor) {
+void BitmapPlatformDevice::processPixels(int x, int y,
+                                         int width, int height,
+                                         adjustAlpha adjustor) {
   const SkBitmap& bitmap = accessBitmap(true);
   SkMatrix& matrix = data_->transform_;
   int bitmap_start_x = SkScalarRound(matrix.getTranslateX()) + x;
   int bitmap_start_y = SkScalarRound(matrix.getTranslateY()) + y;
 
   SkAutoLockPixels lock(bitmap);
   if (Constrain(bitmap.width(), &bitmap_start_x, &width) &&
       Constrain(bitmap.height(), &bitmap_start_y, &height)) {
     uint32_t* data = bitmap.getAddr32(0, 0);
     size_t row_words = bitmap.rowBytes() / 4;
     for (int i = 0; i < height; i++) {
       size_t offset = (i + bitmap_start_y) * row_words + bitmap_start_x;
       for (int j = 0; j < width; j++) {
         adjustor(data + offset + j);
       }
     }
   }
 }
 
 }  // namespace skia