stop calling SkCanvas::getDevice

samplecode/SampleApp.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 "SampleApp.h"
 
 #include "OverView.h"
@@ skipping 989 matching lines @@
 static SkBitmap capture_bitmap(SkCanvas* canvas) {
     SkBitmap bm;
     if (bm.allocPixels(canvas->imageInfo())) {
         canvas->readPixels(&bm, 0, 0);
     }
     return bm;
 }
 
 static bool bitmap_diff(SkCanvas* canvas, const SkBitmap& orig,
                         SkBitmap* diff) {
-    const SkBitmap& src = canvas->getDevice()->accessBitmap(false);
+    SkBitmap src = capture_bitmap(canvas);
 
     SkAutoLockPixels alp0(src);
     SkAutoLockPixels alp1(orig);
     for (int y = 0; y < src.height(); y++) {
         const void* srcP = src.getAddr(0, y);
         const void* origP = orig.getAddr(0, y);
         size_t bytes = src.width() * src.bytesPerPixel();
         if (memcmp(srcP, origP, bytes)) {
             SkDebugf("---------- difference on line %d\n", y);
             return true;
@@ skipping 254 matching lines @@
 #include "SkColorPriv.h"
 
 void SampleWindow::saveToPdf()
 {
     fSaveToPdf = true;
     this->inval(NULL);
 }
 
 SkCanvas* SampleWindow::beforeChildren(SkCanvas* canvas) {
     if (fSaveToPdf) {
-        const SkBitmap& bmp = canvas->getDevice()->accessBitmap(false);
+        const SkBitmap bmp = capture_bitmap(canvas);
         SkISize size = SkISize::Make(bmp.width(), bmp.height());
         SkPDFDevice* pdfDevice = new SkPDFDevice(size, size,
                 canvas->getTotalMatrix());
         fPdfCanvas = new SkCanvas(pdfDevice);
         pdfDevice->unref();
         canvas = fPdfCanvas;
     } else if (kPicture_DeviceType == fDeviceType) {
         canvas = fRecorder.beginRecording(9999, 9999, NULL, 0);
     } else {
 #if SK_SUPPORT_GPU
         if (kNullGPU_DeviceType != fDeviceType)
 #endif
         {
             canvas = this->INHERITED::beforeChildren(canvas);
         }
     }
 
     if (fUseClip) {
         canvas->drawColor(0xFFFF88FF);
         canvas->clipPath(fClipPath, SkRegion::kIntersect_Op, true);
     }
 
     return canvas;
 }
 
-static void paint_rgn(const SkBitmap& bm, const SkIRect& r,
-                      const SkRegion& rgn) {
-    SkCanvas    canvas(bm);
-    SkRegion    inval(rgn);
-
-    inval.translate(r.fLeft, r.fTop);
-    canvas.clipRegion(inval);
-    canvas.drawColor(0xFFFF8080);
-}
 #include "SkData.h"
 void SampleWindow::afterChildren(SkCanvas* orig) {
     if (fSaveToPdf) {
         fSaveToPdf = false;
         if (fShowZoomer) {
             showZoomer(fPdfCanvas);
         }
         SkString name;
         name.printf("%s.pdf", this->getTitle());
         SkPDFDocument doc;
-        SkPDFDevice* device = static_cast<SkPDFDevice*>(fPdfCanvas->getDevice());
+        SkPDFDevice* device = NULL;//static_cast<SkPDFDevice*>(fPdfCanvas->getDevice());
+        SkASSERT(false);
         doc.appendPage(device);
 #ifdef SK_BUILD_FOR_ANDROID
         name.prepend("/sdcard/");
 #endif
 
 #ifdef SK_BUILD_FOR_IOS
         SkDynamicMemoryWStream mstream;
         doc.emitPDF(&mstream);
         fPDFData = mstream.copyToData();
 #endif
         SkFILEWStream stream(name.c_str());
         if (stream.isValid()) {
             doc.emitPDF(&stream);
             const char* desc = "File saved from Skia SampleApp";
             this->onPDFSaved(this->getTitle(), desc, name.c_str());
         }
 
         delete fPdfCanvas;
         fPdfCanvas = NULL;
 
         // We took over the draw calls in order to create the PDF, so we need
         // to redraw.
         this->inval(NULL);
         return;
     }
 
     if (fRequestGrabImage) {
         fRequestGrabImage = false;
 
-        SkBaseDevice* device = orig->getDevice();
-        SkBitmap bmp;
-        if (device->accessBitmap(false).copyTo(&bmp, kN32_SkColorType)) {
+        SkBitmap bmp = capture_bitmap(orig);
+        if (!bmp.isNull()) {
             static int gSampleGrabCounter;
             SkString name;
             name.printf("sample_grab_%d.png", gSampleGrabCounter++);
             SkImageEncoder::EncodeFile(name.c_str(), bmp,
                                        SkImageEncoder::kPNG_Type, 100);
         }
     }
 
     if (kPicture_DeviceType == fDeviceType) {
         SkAutoTUnref<SkPicture> picture(fRecorder.endRecording());
@@ skipping 15 matching lines @@
             }
         } else {
             picture->draw(orig);
         }
     }
 
     // Do this after presentGL and other finishing, rather than in afterChild
     if (fMeasureFPS && fMeasureFPS_StartTime) {
         fMeasureFPS_Time += SkTime::GetMSecs() - fMeasureFPS_StartTime;
     }
-
-    //    if ((fScrollTestX | fScrollTestY) != 0)
-    if (false) {
-        const SkBitmap& bm = orig->getDevice()->accessBitmap(true);
-        int dx = fScrollTestX * 7;
-        int dy = fScrollTestY * 7;
-        SkIRect r;
-        SkRegion inval;
-
-        r.set(50, 50, 50+100, 50+100);
-        bm.scrollRect(&r, dx, dy, &inval);
-        paint_rgn(bm, r, inval);
-    }
 }
 
 void SampleWindow::beforeChild(SkView* child, SkCanvas* canvas) {
     if (fRotate) {
         fRotateAnimTime += SampleCode::GetAnimSecondsDelta();
 
         SkScalar cx = this->width() / 2;
         SkScalar cy = this->height() / 2;
         canvas->translate(cx, cy);
         canvas->rotate(fRotateAnimTime * 10);
@@ skipping 829 matching lines @@
 
     fAtomsWritten += 1;
 }
 
 void SampleView::draw(SkCanvas* canvas) {
     if (SkOSMenu::kOffState == fPipeState) {
         this->INHERITED::draw(canvas);
     } else {
         SkGPipeWriter writer;
         SimplePC controller(canvas);
-        TiledPipeController tc(canvas->getDevice()->accessBitmap(false),
-                               &SkImageDecoder::DecodeMemory,
-                               &canvas->getTotalMatrix());
+        SkBitmap bitmap = capture_bitmap(canvas);
+        TiledPipeController tc(bitmap, &SkImageDecoder::DecodeMemory, &canvas->getTotalMatrix());
         SkGPipeController* pc;
         if (SkOSMenu::kMixedState == fPipeState) {
             pc = &tc;
         } else {
             pc = &controller;
         }
         uint32_t flags = SkGPipeWriter::kCrossProcess_Flag;
 
         canvas = writer.startRecording(pc, flags);
         //Must draw before controller goes out of scope and sends data
@@ skipping 152 matching lines @@
     SkGraphics::Init();
     SkEvent::Init();
 }
 
 // FIXME: this should be in a header
 void application_term();
 void application_term() {
     SkEvent::Term();
     SkGraphics::Term();
 }