color: Enable color conversion in image decoder caches

cc/tiles/gpu_image_decode_cache.cc

 // Copyright 2016 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 "cc/tiles/gpu_image_decode_cache.h"
 
 #include <inttypes.h>
 
 #include "base/auto_reset.h"
 #include "base/debug/alias.h"
@@ skipping 1112 matching lines @@
           DLOG(ERROR) << "getDeferredTextureImageData failed despite params "
                       << "having validated.";
           backing_memory->Unlock();
           backing_memory.reset();
         }
         break;
       }
     }
   }
 
-  // TODO(ccameron,msarett): Convert image to target color space.
-  // http://crbug.com/706613
-
   if (image_data->decode.data()) {
     // An at-raster task decoded this before us. Ingore our decode.
     return;
   }
 
   if (!backing_memory) {
     // If |backing_memory| was not populated, we had a non-decodable image.
     image_data->decode.decode_failure = true;
     return;
   }
@@ skipping 43 matching lines @@
         uploaded_image = SkImage::MakeFromDeferredTextureImageData(
             context_->GrContext(), image_data->decode.data()->data(),
             SkBudgeted::kNo);
         break;
       }
     }
   }
   image_data->decode.mark_used();
   DCHECK(uploaded_image);
 
+  if (draw_image.target_color_space().IsValid()) {
+    TRACE_EVENT0("cc", "GpuImageDecodeCache::UploadImage - color conversion");
+    uploaded_image = uploaded_image->makeColorSpace(
+        draw_image.target_color_space().ToSkColorSpace(),
+        SkTransferFunctionBehavior::kIgnore);
+  }
+  DCHECK(uploaded_image);
+
   // At-raster may have decoded this while we were unlocked. If so, ignore our
   // result.
   if (!image_data->upload.image())
     image_data->upload.SetImage(std::move(uploaded_image));
 }
 
 scoped_refptr<GpuImageDecodeCache::ImageData>
 GpuImageDecodeCache::CreateImageData(const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "GpuImageDecodeCache::CreateImageData");
   lock_.AssertAcquired();
 
   DecodedDataMode mode;
   int upload_scale_mip_level = CalculateUploadScaleMipLevel(draw_image);
   auto params = SkImage::DeferredTextureImageUsageParams(
       draw_image.matrix(), CalculateUploadScaleFilterQuality(draw_image),
       upload_scale_mip_level);
   size_t data_size = draw_image.image()->getDeferredTextureImageData(
-      *context_threadsafe_proxy_.get(), &params, 1, nullptr,
-      draw_image.target_color_space().ToSkColorSpace().get());
+      *context_threadsafe_proxy_.get(), &params, 1, nullptr, nullptr);
 
   if (data_size == 0) {
     // Can't upload image, too large or other failure. Try to use SW fallback.
     SkImageInfo image_info =
         CreateImageInfoForDrawImage(draw_image, upload_scale_mip_level);
     data_size = image_info.getSafeSize(image_info.minRowBytes());
     mode = DecodedDataMode::CPU;
   } else {
     mode = DecodedDataMode::GPU;
   }
@@ skipping 106 matching lines @@
 
 void GpuImageDecodeCache::OnPurgeMemory() {
   base::AutoLock lock(lock_);
   // Temporary changes |memory_state_| to free up cache as much as possible.
   base::AutoReset<base::MemoryState> reset(&memory_state_,
                                            base::MemoryState::SUSPENDED);
   EnsureCapacity(0);
 }
 
 }  // namespace cc