Refactor the PlatformContext layer to have only one class.

skia/ext/platform_device_win.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/platform_device_win.h"
 
 #include "skia/ext/skia_utils_win.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "third_party/skia/include/core/SkUtils.h"
 
 namespace skia {
 
-PlatformDeviceWin::PlatformDeviceWin(const SkBitmap& bitmap)
+PlatformDevice::PlatformDevice(const SkBitmap& bitmap)
     : SkDevice(bitmap) {
 }
 
 // static
-void PlatformDeviceWin::InitializeDC(HDC context) {
+void PlatformDevice::InitializeDC(HDC context) {
   // Enables world transformation.
   // If the GM_ADVANCED graphics mode is set, GDI always draws arcs in the
   // counterclockwise direction in logical space. This is equivalent to the
   // statement that, in the GM_ADVANCED graphics mode, both arc control points
   // and arcs themselves fully respect the device context's world-to-device
   // transformation.
   BOOL res = SetGraphicsMode(context, GM_ADVANCED);
   SkASSERT(res != 0);
 
   // Enables dithering.
@@ skipping 19 matching lines @@
   SkASSERT(res != CLR_INVALID);
 
   // Sets up default transparency.
   res = SetBkMode(context, OPAQUE);
   SkASSERT(res != 0);
   res = SetROP2(context, R2_COPYPEN);
   SkASSERT(res != 0);
 }
 
 // static
-void PlatformDeviceWin::LoadPathToDC(HDC context, const SkPath& path) {
+void PlatformDevice::LoadPathToDC(HDC context, const SkPath& path) {
   switch (path.getFillType()) {
     case SkPath::kWinding_FillType: {
       int res = SetPolyFillMode(context, WINDING);
       SkASSERT(res != 0);
       break;
     }
     case SkPath::kEvenOdd_FillType: {
       int res = SetPolyFillMode(context, ALTERNATE);
       SkASSERT(res != 0);
       break;
@@ skipping 39 matching lines @@
   if (res == 0) {
     // Make sure the path is discarded.
     AbortPath(context);
   } else {
     res = EndPath(context);
     SkASSERT(res != 0);
   }
 }
 
 // static
-void PlatformDeviceWin::LoadTransformToDC(HDC dc, const SkMatrix& matrix) {
+void PlatformDevice::LoadTransformToDC(HDC dc, const SkMatrix& matrix) {
   XFORM xf;
   xf.eM11 = matrix[SkMatrix::kMScaleX];
   xf.eM21 = matrix[SkMatrix::kMSkewX];
   xf.eDx = matrix[SkMatrix::kMTransX];
   xf.eM12 = matrix[SkMatrix::kMSkewY];
   xf.eM22 = matrix[SkMatrix::kMScaleY];
   xf.eDy = matrix[SkMatrix::kMTransY];
   SetWorldTransform(dc, &xf);
 }
 
 // static
-bool PlatformDeviceWin::SkPathToCubicPaths(CubicPaths* paths,
-                                           const SkPath& skpath) {
+bool PlatformDevice::SkPathToCubicPaths(CubicPaths* paths,
+                                        const SkPath& skpath) {
   paths->clear();
   CubicPath* current_path = NULL;
   SkPoint current_points[4];
   CubicPoints points_to_add;
   SkPath::Iter iter(skpath, false);
   for (SkPath::Verb verb = iter.next(current_points);
        verb != SkPath::kDone_Verb;
        verb = iter.next(current_points)) {
     switch (verb) {
       case SkPath::kMove_Verb: {  // iter.next returns 1 point
@@ skipping 41 matching lines @@
     if (!current_path) {
       paths->clear();
       return false;
     }
     current_path->push_back(points_to_add);
   }
   return true;
 }
 
 // static
-void PlatformDeviceWin::LoadClippingRegionToDC(HDC context,
-                                               const SkRegion& region,
-                                               const SkMatrix& transformation) {
+void PlatformDevice::LoadClippingRegionToDC(HDC context,
+                                            const SkRegion& region,
+                                            const SkMatrix& transformation) {
   HRGN hrgn;
   if (region.isEmpty()) {
     // region can be empty, in which case everything will be clipped.
     hrgn = CreateRectRgn(0, 0, 0, 0);
   } else if (region.isRect()) {
     // We don't apply transformation, because the translation is already applied
     // to the region.
     hrgn = CreateRectRgnIndirect(&SkIRectToRECT(region.getBounds()));
   } else {
     // It is complex.
@@ skipping 11 matching lines @@
     hrgn = PathToRegion(context);
   }
   int result = SelectClipRgn(context, hrgn);
   SkASSERT(result != ERROR);
   result = DeleteObject(hrgn);
   SkASSERT(result != 0);
 }
 
 }  // namespace skia