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

skia/ext/vector_platform_device_skia.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 "skia/ext/vector_platform_device_skia.h"
 
 #include "skia/ext/bitmap_platform_device.h"
+#include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkClipStack.h"
 #include "third_party/skia/include/core/SkDraw.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "third_party/skia/include/core/SkScalar.h"
 
 namespace skia {
 
 static inline SkBitmap makeABitmap(int width, int height) {
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kNo_Config, width, height);
   return bitmap;
 }
 
 VectorPlatformDeviceSkia::VectorPlatformDeviceSkia(SkPDFDevice* pdf_device)
-    : PlatformDevice(makeABitmap(pdf_device->width(), pdf_device->height())),
-      pdf_device_(pdf_device) {
+    : PlatformDevice(pdf_device) {//PlatformDevice(makeABitmap(pdf_device->width(), pdf_device->height())),
+      //pdf_device_(pdf_device) {
 }
 
 VectorPlatformDeviceSkia::~VectorPlatformDeviceSkia() {
 }
 
 bool VectorPlatformDeviceSkia::IsNativeFontRenderingAllowed() {
   return false;
 }
 
 PlatformDevice::PlatformSurface VectorPlatformDeviceSkia::BeginPlatformPaint() {
   // Even when drawing a vector representation of the page, we have to
   // provide a raster surface for plugins to render into - they don't have
   // a vector interface.  Therefore we create a BitmapPlatformDevice here
   // and return the context from it, then layer on the raster data as an
   // image in EndPlatformPaint.
   DCHECK(raster_surface_ == NULL);
 #if defined(OS_WIN)
-  raster_surface_ = BitmapPlatformDevice::create(pdf_device_->width(),
-                                                 pdf_device_->height(),
+  raster_surface_ = BitmapPlatformDevice::create(GetOwningDevice()->width(),
+                                                 GetOwningDevice()->height(),
                                                  false, /* not opaque */
                                                  NULL);
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
-  raster_surface_ = BitmapPlatformDevice::Create(pdf_device_->width(),
-                                                 pdf_device_->height(),
+  raster_surface_ = BitmapPlatformDevice::Create(GetOwningDevice()->width(),
+                                                 GetOwningDevice()->height(),
                                                  false /* not opaque */);
 #endif
   raster_surface_->unref();  // SkRefPtr and create both took a reference.
 
-  SkCanvas canvas(raster_surface_.get());
-  return raster_surface_->BeginPlatformPaint();
+  //SkCanvas canvas(raster_surface_.get());
+  raster_canvas_ = new SkCanvas(raster_surface_.get());
+  //return raster_surface_->BeginPlatformPaint();
+  return skia::BeginPlatformPaint(raster_canvas_.get());
 }
 
 void VectorPlatformDeviceSkia::EndPlatformPaint() {
   DCHECK(raster_surface_ != NULL);
+
+  // BitmapPlatformDevice matches begin and end calls.
+  skia::EndPlatformPaint(raster_canvas_.get());

[Jeff Timanus, 2011/08/12 23:59:22]

This was an example of where BitmapPlatformDevice::onAccessBitmap was required. 
The code was drawing from a GDI backed bitmap before calling EndPlatformPaint,
and so no gdiFlush would have been called.  By placing the EndPlatformPaint call
at the entrance to the routine, the problem should be fixed.

   SkPaint paint;
   // SkPDFDevice checks the passed SkDraw for an empty clip (only).  Fake
   // it out by setting a non-empty clip.
   SkDraw draw;
-  SkRegion clip(SkIRect::MakeWH(pdf_device_->width(), pdf_device_->height()));
+  SkRegion clip(SkIRect::MakeWH(GetOwningDevice()->width(),
+                                GetOwningDevice()->height()));
   draw.fClip=&clip;
-  pdf_device_->drawSprite(draw, raster_surface_->accessBitmap(false), 0, 0,
-                          paint);
-  // BitmapPlatformDevice matches begin and end calls.
-  raster_surface_->EndPlatformPaint();
+
+  SkCanvas pdf_canvas(GetOwningDevice());

[vandebo (ex-Chrome), 2011/08/15 19:52:10]

Will using two different canvases (with different clips and transforms) confuse
the device if it uses setMatrixClip?  Seems like we might need to match the
matrix and clip in this canvas even though drawSprite doesn't really need them.

Another solution might be a static canvas method to draw a sprite to a device
without molesting the device's other state.

[Jeff Timanus, 2011/08/15 20:06:25]

A third option is to make drawSprite a public entry point to SkDevice.  Are
there reasons why we should not take this approach?  Which is cleaner, from an
API perspective - public drawSprite call, or static method that preserves state?

[vandebo (ex-Chrome), 2011/08/15 20:13:56]

I don't think either of these are particularly clean...  The consumer isn't
really meant to deal with drawing to the device directly, that's the job of
canvas.

Is there enough information exposed from canvas to clone the state into the
local canvas you already have?

There aren't any particular ramifications for PDF for any of these options, but
that might not be true for GPU.  Maybe we can get Brian to weigh in.

+  pdf_canvas.drawSprite(raster_surface_->accessBitmap(false), 0, 0, &paint);
+#if 0
+  GetOwningDevice()->drawSprite(
+      draw,
+      raster_surface_->accessBitmap(false), 0, 0, paint);
+#endif
+  //raster_surface_->EndPlatformPaint();
+  raster_canvas_ = NULL;
   raster_surface_ = NULL;
 }
 
+#if 0
 uint32_t VectorPlatformDeviceSkia::getDeviceCapabilities() {
   return SkDevice::getDeviceCapabilities() | kVector_Capability;
 }
 
 int VectorPlatformDeviceSkia::width() const {
   return pdf_device_->width();
 }
 
 int VectorPlatformDeviceSkia::height() const {
   return pdf_device_->height();
@@ skipping 101 matching lines @@
   SkDevice* real_device = device;
   if ((device->getDeviceCapabilities() & kVector_Capability)) {
     // Assume that a vectorial device means a VectorPlatformDeviceSkia, we need
     // to unwrap the embedded SkPDFDevice.
     VectorPlatformDeviceSkia* vector_device =
         static_cast<VectorPlatformDeviceSkia*>(device);
     real_device = vector_device->pdf_device_.get();
   }
   pdf_device_->drawDevice(draw, real_device, x, y, paint);
 }
+#endif
 
 #if defined(OS_WIN)
 void VectorPlatformDeviceSkia::DrawToNativeContext(HDC dc,
                                                    int x,
                                                    int y,
                                                    const RECT* src_rect) {
   SkASSERT(false);
 }
 #elif defined(OS_MACOSX)
 void VectorPlatformDeviceSkia::DrawToNativeContext(CGContext* context, int x,
     int y, const CGRect* src_rect) {
   SkASSERT(false);
 }
 
 CGContextRef VectorPlatformDeviceSkia::GetBitmapContext() {
   SkASSERT(false);
   return NULL;
 }
 
 #endif
 
+#if 0
 SkDevice* VectorPlatformDeviceSkia::onCreateCompatibleDevice(
     SkBitmap::Config config, int width, int height, bool isOpaque, 
     Usage /*usage*/) {
   SkAutoTUnref<SkDevice> dev(pdf_device_->createCompatibleDevice(config, width,
                                                                  height,
                                                                  isOpaque));
   return new VectorPlatformDeviceSkia(static_cast<SkPDFDevice*>(dev.get()));
 }
+#endif
 
 }  // namespace skia