CL removing inheritance of SkDevice from PlatformDevice. Flavours of PlatformDevice classes now ...

skia/ext/bitmap_platform_device_win.cc

 // Copyright (c) 2011 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 <windows.h>
 #include <psapi.h>
 
 #include "skia/ext/bitmap_platform_device_win.h"
 
 #include "skia/ext/bitmap_platform_device_data.h"
@@ skipping 70 matching lines @@
 
   // Transform.
   LoadTransformToDC(hdc_, transform_);
   LoadClippingRegionToDC(hdc_, clip_region_, transform_);
 }
 
 // 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.
-BitmapPlatformDevice* BitmapPlatformDevice::create(
+SkDevice* BitmapPlatformDevice::create(
     HDC screen_dc,
     int width,
     int height,
     bool is_opaque,
     HANDLE shared_section) {
   SkBitmap bitmap;
 
   // CreateDIBSection appears to get unhappy if we create an empty bitmap, so
   // just create a minimal bitmap
   if ((width == 0) || (height == 0)) {
@@ skipping 33 matching lines @@
 #ifndef NDEBUG
       // To aid in finding bugs, we set the background color to something
       // obviously wrong so it will be noticable when it is not cleared
       bitmap.eraseARGB(255, 0, 255, 128);  // bright bluish green
 #endif
     } else {
       bitmap.eraseARGB(0, 0, 0, 0);
     }
   }
 
+  SkDevice* new_device = new SkDevice(bitmap);
   // The device object will take ownership of the HBITMAP. The initial refcount
   // of the data object will be 1, which is what the constructor expects.
-  return new BitmapPlatformDevice(new BitmapPlatformDeviceData(hbitmap),
-                                  bitmap);
+  BitmapPlatformDevice* bitmap_platform_device =
+      new BitmapPlatformDevice(new BitmapPlatformDeviceData(hbitmap),
+                               new_device);
+  return new_device;
 }
 
 // static
-BitmapPlatformDevice* BitmapPlatformDevice::create(int width,
-                                                   int height,
-                                                   bool is_opaque,
-                                                   HANDLE shared_section) {
+SkDevice* BitmapPlatformDevice::create(int width,
+                                       int height,
+                                       bool is_opaque,
+                                       HANDLE shared_section) {
   HDC screen_dc = GetDC(NULL);
+#if 0
   BitmapPlatformDevice* device = BitmapPlatformDevice::create(
       screen_dc, width, height, is_opaque, shared_section);
+#endif
+  SkDevice* device = BitmapPlatformDevice::create(screen_dc, width, height,
+                                                  is_opaque, shared_section);
   ReleaseDC(NULL, screen_dc);
   return device;
 }
 
 // The device will own the HBITMAP, which corresponds to also owning the pixel
 // data. Therefore, we do not transfer ownership to the SkDevice's bitmap.
 BitmapPlatformDevice::BitmapPlatformDevice(
     BitmapPlatformDeviceData* data,
-    const SkBitmap& bitmap)
-    : PlatformDevice(bitmap),
+    SkDevice* device
+    /*const SkBitmap& bitmap*/)
+    : /*PlatformDevice(bitmap),*/
+      PlatformDevice(device),
       data_(data) {
   // The data object is already ref'ed for us by create().
   SkDEBUGCODE(begin_paint_count_ = 0);
+
+  GetOwningDevice()->setMatrixClipObserver(this);
 }
 
 BitmapPlatformDevice::~BitmapPlatformDevice() {
   SkASSERT(begin_paint_count_ == 0);
   data_->unref();
 }
 
 HDC BitmapPlatformDevice::BeginPlatformPaint() {
   SkDEBUGCODE(begin_paint_count_++);
   return data_->GetBitmapDC();
 }
 
 void BitmapPlatformDevice::EndPlatformPaint() {
   SkASSERT(begin_paint_count_--);
+  if (data_->IsBitmapDCCreated())
+    GdiFlush();
   PlatformDevice::EndPlatformPaint();
 }
 
+void BitmapPlatformDevice::matrixClipChanged(const SkMatrix& transform,
+                                             const SkRegion& region,
+                                             const SkClipStack&) {
+  data_->SetMatrixClip(transform, region);
+}
+
+#if 0
 void BitmapPlatformDevice::setMatrixClip(const SkMatrix& transform,
                                          const SkRegion& region,
                                          const SkClipStack&) {
   data_->SetMatrixClip(transform, region);
 }
+#endif
 
 void BitmapPlatformDevice::DrawToNativeContext(HDC dc, int x, int y,
                                                const RECT* src_rect) {
   bool created_dc = !data_->IsBitmapDCCreated();
   HDC source_dc = BeginPlatformPaint();
 
   RECT temp_rect;
   if (!src_rect) {
     temp_rect.left = 0;
-    temp_rect.right = width();
+    temp_rect.right = GetOwningDevice()->width();
     temp_rect.top = 0;
-    temp_rect.bottom = height();
+    temp_rect.bottom = GetOwningDevice()->height();
     src_rect = &temp_rect;
   }
 
   int copy_width = src_rect->right - src_rect->left;
   int copy_height = src_rect->bottom - src_rect->top;
 
   // We need to reset the translation for our bitmap or (0,0) won't be in the
   // upper left anymore
   SkMatrix identity;
   identity.reset();
 
   LoadTransformToDC(source_dc, identity);
-  if (isOpaque()) {
+  if (GetOwningDevice()->isOpaque()) {
     BitBlt(dc,
            x,
            y,
            copy_width,
            copy_height,
            source_dc,
            src_rect->left,
            src_rect->top,
            SRCCOPY);
   } else {
@@ skipping 11 matching lines @@
                   copy_height,
                   blend_function);
   }
   LoadTransformToDC(source_dc, data_->transform());
 
   EndPlatformPaint();
   if (created_dc)
     data_->ReleaseBitmapDC();
 }
 
+#if 0
 void BitmapPlatformDevice::onAccessBitmap(SkBitmap* bitmap) {
   // FIXME(brettw) OPTIMIZATION: We should only flush if we know a GDI
   // operation has occurred on our DC.
   if (data_->IsBitmapDCCreated())
     GdiFlush();
 }
+#endif
 
+#if 0
 SkDevice* BitmapPlatformDevice::onCreateCompatibleDevice(
     SkBitmap::Config config, int width, int height, bool isOpaque,
     Usage /*usage*/) {
   SkASSERT(config == SkBitmap::kARGB_8888_Config);
   return BitmapPlatformDevice::create(width, height, isOpaque, NULL);
 }
+#endif
 
 }  // namespace skia