Adding color space to SkSpecialImage

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 "GrBlurUtils.h"
@@ skipping 1222 matching lines @@
         }
     }
 
     SkIRect srcRect = SkIRect::MakeXYWH(bitmap.pixelRefOrigin().fX,
                                         bitmap.pixelRefOrigin().fY,
                                         bitmap.width(),
                                         bitmap.height());
 
     sk_sp<SkSpecialImage> srcImg(SkSpecialImage::MakeFromGpu(srcRect,
                                                              bitmap.getGenerationID(),
-                                                             std::move(texture), 
+                                                             std::move(texture),
+                                                             sk_ref_sp(bitmap.colorSpace()),
                                                              &this->surfaceProps()));
 
     this->drawSpecial(draw, srcImg.get(), left, top, paint);
 }
 
 
 void SkGpuDevice::drawSpecial(const SkDraw& draw, 
                               SkSpecialImage* special1,
                               int left, int top,
                               const SkPaint& paint) {
@@ skipping 145 matching lines @@
 
     GrTexture* texture;
     AutoBitmapTexture abt(fContext, bitmap, GrTextureParams::ClampNoFilter(),   
                           SkSourceGammaTreatment::kRespect, &texture);
     if (!texture) {
         return nullptr;
     }
 
     return SkSpecialImage::MakeFromGpu(bitmap.bounds(),
                                        bitmap.getGenerationID(),
-                                       sk_ref_sp(texture), 
+                                       sk_ref_sp(texture),
+                                       sk_ref_sp(bitmap.colorSpace()),
                                        &this->surfaceProps());
 }
 
 sk_sp<SkSpecialImage> SkGpuDevice::makeSpecial(const SkImage* image) {
     SkPixmap pm;
     if (image->isTextureBacked()) {
         GrTexture* texture = as_IB(image)->peekTexture();
 
         return SkSpecialImage::MakeFromGpu(SkIRect::MakeWH(image->width(), image->height()),
                                            image->uniqueID(),
-                                           sk_ref_sp(texture), 
+                                           sk_ref_sp(texture),
+                                           sk_ref_sp(as_IB(image)->onImageInfo().colorSpace()),
                                            &this->surfaceProps());
     } else if (image->peekPixels(&pm)) {
         SkBitmap bm;
 
         bm.installPixels(pm);
         return this->makeSpecial(bm);
     } else {
         return nullptr;
     }
 }
@@ skipping 13 matching lines @@
         if (!fContext->copySurface(texture.get(), this->accessDrawContext()->accessRenderTarget())){
             return nullptr;
         }
     }
 
     const SkImageInfo ii = this->imageInfo();
     const SkIRect srcRect = SkIRect::MakeWH(ii.width(), ii.height());
 
     return SkSpecialImage::MakeFromGpu(srcRect,
                                        kNeedNewImageUniqueID_SpecialImage,
-                                       std::move(texture), 
+                                       std::move(texture),
+                                       sk_ref_sp(ii.colorSpace()),
                                        &this->surfaceProps());
 }
 
 void SkGpuDevice::drawDevice(const SkDraw& draw, SkBaseDevice* device,
                              int left, int top, const SkPaint& paint) {
     SkASSERT(!paint.getImageFilter());
 
     ASSERT_SINGLE_OWNER
     // clear of the source device must occur before CHECK_SHOULD_DRAW
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawDevice", fContext);
@@ skipping 426 matching lines @@
 }
 
 SkImageFilterCache* SkGpuDevice::getImageFilterCache() {
     ASSERT_SINGLE_OWNER
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilterCache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif