Allow specifying ColorBehavior to ImageSource

third_party/WebKit/Source/platform/graphics/BitmapImage.cpp

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/graphics/BitmapImage.h"
 
 #include "platform/PlatformInstrumentation.h"
+#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/Timer.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/graphics/BitmapImageMetrics.h"
 #include "platform/graphics/DeferredImageDecoder.h"
 #include "platform/graphics/ImageObserver.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/tracing/TraceEvent.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
+namespace {
+
+ColorBehavior defaultColorBehavior() {
+  // TODO(ccameron): ColorBehavior should be specified by the caller requesting
+  // SkImages.
+  // https://crbug.com/667420
+  if (RuntimeEnabledFeatures::trueColorRenderingEnabled())
+    return ColorBehavior::tag();
+  return ColorBehavior::transformToGlobalTarget();
+}
+
+}  // namespace
+
 PassRefPtr<BitmapImage> BitmapImage::createWithOrientationForTesting(
     const SkBitmap& bitmap,
     ImageOrientation orientation) {
   if (bitmap.isNull()) {
     return BitmapImage::create();
   }
 
   RefPtr<BitmapImage> result = adoptRef(new BitmapImage(bitmap));
   result->m_frames[0].m_orientation = orientation;
   if (orientation.usesWidthAsHeight())
     result->m_sizeRespectingOrientation = result->m_size.transposedSize();
   return result.release();
 }
 
 BitmapImage::BitmapImage(ImageObserver* observer)
     : Image(observer),
       m_currentFrame(0),
       m_cachedFrameIndex(0),
+      m_cachedFrameColorBehavior(defaultColorBehavior()),
       m_repetitionCount(cAnimationNone),
       m_repetitionCountStatus(Unknown),
       m_repetitionsComplete(0),
       m_desiredFrameStartTime(0),
       m_frameCount(0),
       m_animationPolicy(ImageAnimationPolicyAllowed),
       m_animationFinished(false),
       m_allDataReceived(false),
       m_haveSize(false),
       m_sizeAvailable(false),
       m_haveFrameCount(false) {}
 
 BitmapImage::BitmapImage(const SkBitmap& bitmap, ImageObserver* observer)
     : Image(observer),
       m_size(bitmap.width(), bitmap.height()),
       m_currentFrame(0),
       m_cachedFrame(SkImage::MakeFromBitmap(bitmap)),
       m_cachedFrameIndex(0),
+      m_cachedFrameColorBehavior(defaultColorBehavior()),
       m_repetitionCount(cAnimationNone),
       m_repetitionCountStatus(Unknown),
       m_repetitionsComplete(0),
       m_frameCount(1),
       m_animationPolicy(ImageAnimationPolicyAllowed),
       m_animationFinished(true),
       m_allDataReceived(true),
       m_haveSize(true),
       m_sizeAvailable(true),
       m_haveFrameCount(true) {
@@ skipping 32 matching lines @@
 }
 
 size_t BitmapImage::totalFrameBytes() {
   const size_t numFrames = frameCount();
   size_t totalBytes = 0;
   for (size_t i = 0; i < numFrames; ++i)
     totalBytes += m_source.frameBytesAtIndex(i);
   return totalBytes;
 }
 
-sk_sp<SkImage> BitmapImage::decodeAndCacheFrame(size_t index) {
+sk_sp<SkImage> BitmapImage::decodeAndCacheFrame(
+    size_t index,
+    const ColorBehavior& colorBehavior) {
   size_t numFrames = frameCount();
   if (m_frames.size() < numFrames)
     m_frames.grow(numFrames);
 
   // We are caching frame snapshots.  This is OK even for partially decoded
   // frames, as they are cleared by dataChanged() when new data arrives.
-  sk_sp<SkImage> image = m_source.createFrameAtIndex(index);
+  sk_sp<SkImage> image = m_source.createFrameAtIndex(index, colorBehavior);
   m_cachedFrame = image;
   m_cachedFrameIndex = index;
+  m_cachedFrameColorBehavior = colorBehavior;
 
   m_frames[index].m_orientation = m_source.orientationAtIndex(index);
   m_frames[index].m_haveMetadata = true;
   m_frames[index].m_isComplete = m_source.frameIsCompleteAtIndex(index);
   if (repetitionCount(false) != cAnimationNone)
     m_frames[index].m_duration = m_source.frameDurationAtIndex(index);
   m_frames[index].m_hasAlpha = m_source.frameHasAlphaAtIndex(index);
   m_frames[index].m_frameBytes = m_source.frameBytesAtIndex(index);
 
   notifyMemoryChanged();
@@ skipping 164 matching lines @@
   if (m_sizeAvailable && hasVisibleImageSize(size())) {
     BitmapImageMetrics::countDecodedImageType(m_source.filenameExtension());
     if (m_source.filenameExtension() == "jpg")
       BitmapImageMetrics::countImageOrientation(
           m_source.orientationAtIndex(0).orientation());
   }
 
   return m_sizeAvailable;
 }
 
-sk_sp<SkImage> BitmapImage::frameAtIndex(size_t index) {
+sk_sp<SkImage> BitmapImage::frameAtIndex(size_t index,
+                                         const ColorBehavior& colorBehavior) {
   if (index >= frameCount())
     return nullptr;
 
-  if (index == m_cachedFrameIndex && m_cachedFrame)
+  if (index == m_cachedFrameIndex && m_cachedFrame &&
+      m_cachedFrameColorBehavior == colorBehavior)
     return m_cachedFrame;
 
-  return decodeAndCacheFrame(index);
+  return decodeAndCacheFrame(index, colorBehavior);
 }
 
 bool BitmapImage::frameIsCompleteAtIndex(size_t index) const {
   if (index < m_frames.size() && m_frames[index].m_haveMetadata &&
       m_frames[index].m_isComplete)
     return true;
 
   return m_source.frameIsCompleteAtIndex(index);
 }
 
 float BitmapImage::frameDurationAtIndex(size_t index) const {
   if (index < m_frames.size() && m_frames[index].m_haveMetadata)
     return m_frames[index].m_duration;
 
   return m_source.frameDurationAtIndex(index);
 }
 
 sk_sp<SkImage> BitmapImage::imageForCurrentFrame() {
-  return frameAtIndex(currentFrame());
+  // TODO(ccameron): Allow the caller of imageForCurrentFrame to specify the
+  // the desired ColorBehavior.
+  // https://crbug.com/667420
+  const ColorBehavior& colorBehavior = m_cachedFrameColorBehavior;
+  return frameAtIndex(currentFrame(), colorBehavior);
 }
 
 PassRefPtr<Image> BitmapImage::imageForDefaultFrame() {
+  // TODO(ccameron): Determine the appropriate ColorBehavior for this situation.
+  // https://crbug.com/667420
+  const ColorBehavior& colorBehavior = m_cachedFrameColorBehavior;
   if (frameCount() > 1) {
-    sk_sp<SkImage> firstFrame = frameAtIndex(0);
+    sk_sp<SkImage> firstFrame = frameAtIndex(0, colorBehavior);
     if (firstFrame)
       return StaticBitmapImage::create(std::move(firstFrame));
   }
 
   return Image::imageForDefaultFrame();
 }
 
 bool BitmapImage::frameHasAlphaAtIndex(size_t index) {
   if (m_frames.size() <= index)
     return true;
 
   if (m_frames[index].m_haveMetadata && !m_frames[index].m_hasAlpha)
     return false;
 
   // m_hasAlpha may change after m_haveMetadata is set to true, so always ask
   // ImageSource for the value if the cached value is the default value.
   bool hasAlpha = m_source.frameHasAlphaAtIndex(index);
 
   if (m_frames[index].m_haveMetadata)
     m_frames[index].m_hasAlpha = hasAlpha;
 
   return hasAlpha;
 }
 
 bool BitmapImage::currentFrameKnownToBeOpaque(MetadataMode metadataMode) {
   if (metadataMode == PreCacheMetadata) {
     // frameHasAlphaAtIndex() conservatively returns false for uncached frames.
     // To increase the chance of an accurate answer, pre-cache the current frame
-    // metadata.
-    frameAtIndex(currentFrame());
+    // metadata. Because ColorBehavior does not affect this result, use
+    // whatever ColorBehavior was last used (if any).
+    frameAtIndex(currentFrame(), m_cachedFrameColorBehavior);
   }
   return !frameHasAlphaAtIndex(currentFrame());
 }
 
 bool BitmapImage::currentFrameIsComplete() {
   return frameIsCompleteAtIndex(currentFrame());
 }
 
 bool BitmapImage::currentFrameIsLazyDecoded() {
-  sk_sp<SkImage> image = frameAtIndex(currentFrame());
+  // Because ColorBehavior does not affect this result, use whatever
+  // ColorBehavior was last used (if any).
+  sk_sp<SkImage> image =
+      frameAtIndex(currentFrame(), m_cachedFrameColorBehavior);
   return image && image->isLazyGenerated();
 }
 
 ImageOrientation BitmapImage::currentFrameOrientation() {
   return frameOrientationAtIndex(currentFrame());
 }
 
 ImageOrientation BitmapImage::frameOrientationAtIndex(size_t index) {
   if (m_frames.size() <= index)
     return DefaultImageOrientation;
@@ skipping 212 matching lines @@
     getImageObserver()->animationAdvanced(this);
 
   return true;
 }
 
 void BitmapImage::notifyObserversOfAnimationAdvance(TimerBase*) {
   getImageObserver()->animationAdvanced(this);
 }
 
 }  // namespace blink