Fix SkImage::asLegacyBitmap() to respect color space info

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
@@ skipping 612 matching lines @@
 
 void SkCanvas::resetForNextPicture(const SkIRect& bounds) {
     this->restoreToCount(1);
     fClipStack->reset();
     fMCRec->reset(bounds);
 
     // We're peering through a lot of structs here.  Only at this scope do we
     // know that the device is an SkBitmapDevice (really an SkNoPixelsBitmapDevice).
     static_cast<SkBitmapDevice*>(fMCRec->fLayer->fDevice)->setNewSize(bounds.size());
     fDeviceClipBounds = qr_clip_bounds(bounds);
-    fConservativeIsScaleTranslate = true;
+    fIsScaleTranslate = true;
 }
 
 SkBaseDevice* SkCanvas::init(SkBaseDevice* device, InitFlags flags) {
     if (device && device->forceConservativeRasterClip()) {
         flags = InitFlags(flags | kConservativeRasterClip_InitFlag);
     }
     // Since init() is only called once by our constructors, it is safe to perform this
     // const-cast.
     *const_cast<bool*>(&fConservativeRasterClip) = SkToBool(flags & kConservativeRasterClip_InitFlag);
 
     fAllowSoftClip = true;
     fAllowSimplifyClip = false;
     fDeviceCMDirty = true;
     fSaveCount = 1;
     fMetaData = nullptr;
 #ifdef SK_EXPERIMENTAL_SHADOWING
     fLights = nullptr;
 #endif
 
     fClipStack.reset(new SkClipStack);
 
     fMCRec = (MCRec*)fMCStack.push_back();
     new (fMCRec) MCRec(fConservativeRasterClip);
+    fIsScaleTranslate = true;
 
     SkASSERT(sizeof(DeviceCM) <= sizeof(fDeviceCMStorage));
     fMCRec->fLayer = (DeviceCM*)fDeviceCMStorage;
     new (fDeviceCMStorage) DeviceCM(nullptr, nullptr, nullptr, fConservativeRasterClip,
                                     fMCRec->fMatrix);
 
     fMCRec->fTopLayer = fMCRec->fLayer;
 
     fSurfaceBase = nullptr;
 
     if (device) {
         // The root device and the canvas should always have the same pixel geometry
         SkASSERT(fProps.pixelGeometry() == device->surfaceProps().pixelGeometry());
         fMCRec->fLayer->fDevice = SkRef(device);
         fMCRec->fRasterClip.setRect(device->getGlobalBounds());
         fDeviceClipBounds = qr_clip_bounds(device->getGlobalBounds());
-        fConservativeIsScaleTranslate = true;
     }
 
     return device;
 }
 
 SkCanvas::SkCanvas()
     : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage))
     , fProps(SkSurfaceProps::kLegacyFontHost_InitType)
     , fConservativeRasterClip(false)
 {
@@ skipping 637 matching lines @@
             delete layer;
         } else {
             // we're at the root
             SkASSERT(layer == (void*)fDeviceCMStorage);
             layer->~DeviceCM();
             // no need to update fMCRec, 'cause we're killing the canvas
         }
     }
 
     if (fMCRec) {
-        fConservativeIsScaleTranslate = fMCRec->fMatrix.isScaleTranslate();
+        fIsScaleTranslate = fMCRec->fMatrix.isScaleTranslate();
         fDeviceClipBounds = qr_clip_bounds(fMCRec->fRasterClip.getBounds());
     }
 }
 
 sk_sp<SkSurface> SkCanvas::makeSurface(const SkImageInfo& info, const SkSurfaceProps* props) {
     if (nullptr == props) {
         props = &fProps;
     }
     return this->onNewSurface(info, *props);
 }
@@ skipping 137 matching lines @@
 }
 
 void SkCanvas::concat(const SkMatrix& matrix) {
     if (matrix.isIdentity()) {
         return;
     }
 
     this->checkForDeferredSave();
     fDeviceCMDirty = true;
     fMCRec->fMatrix.preConcat(matrix);
-    fConservativeIsScaleTranslate = fMCRec->fMatrix.isScaleTranslate();
+    fIsScaleTranslate = fMCRec->fMatrix.isScaleTranslate();
     this->didConcat(matrix);
 }
 
 void SkCanvas::internalSetMatrix(const SkMatrix& matrix) {
     fDeviceCMDirty = true;
     fMCRec->fMatrix = matrix;
 }
 
 void SkCanvas::setMatrix(const SkMatrix& matrix) {
     this->checkForDeferredSave();
     this->internalSetMatrix(matrix);
-    fConservativeIsScaleTranslate = matrix.isScaleTranslate();
+    fIsScaleTranslate = matrix.isScaleTranslate();
     this->didSetMatrix(matrix);
 }
 
 void SkCanvas::resetMatrix() {
     this->setMatrix(SkMatrix::I());
 }
 
 #ifdef SK_EXPERIMENTAL_SHADOWING
 void SkCanvas::translateZ(SkScalar z) {
     this->checkForDeferredSave();
@@ skipping 325 matching lines @@
 bool SkCanvas::quickReject(const SkRect& src) const {
 #ifdef SK_DEBUG
     // Verify that fDeviceClipBounds are set properly.
     SkRect tmp = qr_clip_bounds(fMCRec->fRasterClip.getBounds());
     if (fMCRec->fRasterClip.isEmpty()) {
         SkASSERT(fDeviceClipBounds.isEmpty());
     } else {
         SkASSERT(tmp == fDeviceClipBounds);
     }
 
-    // Verify that fConservativeIsScaleTranslate is set properly.
-    SkASSERT(!fConservativeIsScaleTranslate || fMCRec->fMatrix.isScaleTranslate());
+    // Verify that fIsScaleTranslate is set properly.
+    SkASSERT(fIsScaleTranslate == fMCRec->fMatrix.isScaleTranslate());
 #endif
 
-    if (!fConservativeIsScaleTranslate) {
+    if (!fIsScaleTranslate) {
         return quick_reject_slow_path(src, fDeviceClipBounds, fMCRec->fMatrix);
     }
 
     // We inline the implementation of mapScaleTranslate() for the fast path.
     float sx = fMCRec->fMatrix.getScaleX();
     float sy = fMCRec->fMatrix.getScaleY();
     float tx = fMCRec->fMatrix.getTranslateX();
     float ty = fMCRec->fMatrix.getTranslateY();
     Sk4f scale(sx, sy, sx, sy);
     Sk4f trans(tx, ty, tx, ty);
@@ skipping 1501 matching lines @@
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }
 
 #ifdef SK_SUPPORT_LEGACY_NEW_SURFACE_API
 SkSurface* SkCanvas::newSurface(const SkImageInfo& info, const SkSurfaceProps* props) {
     return this->makeSurface(info, props).release();
 }
 #endif