change gpudevice and pdfdevice to inherit from basedevice

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "effects/GrBicubicEffect.h"
@@ skipping 112 matching lines @@
     GrContext* fContext;
     GrTextContext* fTextContext;
     GrFontScaler* fFontScaler;  // cached in the skia glyphcache
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /*
  * GrRenderTarget does not know its opaqueness, only its config, so we have
  * to make conservative guesses when we return an "equivalent" bitmap.
  */

[robertphillips, 2014/06/27 12:02:58]

Delete make_bitmap ?

[reed1, 2014/06/27 12:39:42]

Done.

 static SkBitmap make_bitmap(GrContext* context, GrRenderTarget* renderTarget) {
     SkBitmap bitmap;
     bitmap.setInfo(renderTarget->info());
     return bitmap;
 }
 
 SkGpuDevice* SkGpuDevice::Create(GrSurface* surface, unsigned flags) {
     SkASSERT(NULL != surface);
     if (NULL == surface->asRenderTarget() || NULL == surface->getContext()) {
         return NULL;
     }
     if (surface->asTexture()) {
         return SkNEW_ARGS(SkGpuDevice, (surface->getContext(), surface->asTexture(), flags));
     } else {
         return SkNEW_ARGS(SkGpuDevice, (surface->getContext(), surface->asRenderTarget(), flags));
     }
 }
 
-SkGpuDevice::SkGpuDevice(GrContext* context, GrTexture* texture, unsigned flags)
-    : SkBitmapDevice(make_bitmap(context, texture->asRenderTarget())) {
+SkGpuDevice::SkGpuDevice(GrContext* context, GrTexture* texture, unsigned flags) {
     this->initFromRenderTarget(context, texture->asRenderTarget(), flags);
 }
 
-SkGpuDevice::SkGpuDevice(GrContext* context, GrRenderTarget* renderTarget, unsigned flags)
-    : SkBitmapDevice(make_bitmap(context, renderTarget)) {
+SkGpuDevice::SkGpuDevice(GrContext* context, GrRenderTarget* renderTarget, unsigned flags) {
     this->initFromRenderTarget(context, renderTarget, flags);
 }
 
 void SkGpuDevice::initFromRenderTarget(GrContext* context,
                                        GrRenderTarget* renderTarget,
                                        unsigned flags) {
     fDrawProcs = NULL;
 
     fContext = context;
     fContext->ref();
 
     fRenderTarget = NULL;
     fNeedClear = flags & kNeedClear_Flag;
 
     SkASSERT(NULL != renderTarget);
     fRenderTarget = renderTarget;
     fRenderTarget->ref();
 
     // Hold onto to the texture in the pixel ref (if there is one) because the texture holds a ref
     // on the RT but not vice-versa.
     // TODO: Remove this trickery once we figure out how to make SkGrPixelRef do this without
     // busting chrome (for a currently unknown reason).
     GrSurface* surface = fRenderTarget->asTexture();
     if (NULL == surface) {
         surface = fRenderTarget;
     }
 
     SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef,
                                 (surface->info(), surface, SkToBool(flags & kCached_Flag)));
-
-    this->setPixelRef(pr)->unref();
+    fLegacyBitmap.setInfo(surface->info());
+    fLegacyBitmap.setPixelRef(pr)->unref();
 
     bool useDFFonts = !!(flags & kDFFonts_Flag);
     fMainTextContext = fContext->createTextContext(fRenderTarget, fLeakyProperties, useDFFonts);
     fFallbackTextContext = SkNEW_ARGS(GrBitmapTextContext, (fContext, fLeakyProperties));
 }
 
 SkGpuDevice* SkGpuDevice::Create(GrContext* context, const SkImageInfo& origInfo,
                                  int sampleCount) {
     if (kUnknown_SkColorType == origInfo.colorType() ||
         origInfo.width() < 0 || origInfo.height() < 0) {
@@ skipping 83 matching lines @@
     if (kUnknown_GrPixelConfig == config) {
         return false;
     }
     uint32_t flags = 0;
     if (kUnpremul_SkAlphaType == info.alphaType()) {
         flags = GrContext::kUnpremul_PixelOpsFlag;
     }
     fRenderTarget->writePixels(x, y, info.width(), info.height(), config, pixels, rowBytes, flags);
 
     // need to bump our genID for compatibility with clients that "know" we have a bitmap
-    this->onAccessBitmap().notifyPixelsChanged();
+    fLegacyBitmap.notifyPixelsChanged();
 
     return true;
 }
 
 const SkBitmap& SkGpuDevice::onAccessBitmap() {
     DO_DEFERRED_CLEAR();
-    return INHERITED::onAccessBitmap();
+    return fLegacyBitmap;
 }
 
 void SkGpuDevice::onAttachToCanvas(SkCanvas* canvas) {
     INHERITED::onAttachToCanvas(canvas);
 
     // Canvas promises that this ptr is valid until onDetachFromCanvas is called
     fClipData.fClipStack = canvas->getClipStack();
 }
 
 void SkGpuDevice::onDetachFromCanvas() {
@@ skipping 1685 matching lines @@
     picture->fPlayback->setReplacements(NULL);
 
     // unlock the layers
     for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
         GrCachedLayer* layer = fContext->getLayerCache()->findLayer(picture, i);
         fContext->getLayerCache()->unlock(layer);
     }
 
     return true;
 }