Remove ColorBehavior argument to Image::imageForCurrentFrame

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
@@ skipping 29 matching lines @@
 #include "platform/instrumentation/tracing/TraceEvent.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,
-    const ColorBehavior& colorBehavior) {
+sk_sp<SkImage> BitmapImage::decodeAndCacheFrame(size_t index) {
   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, colorBehavior);
+  sk_sp<SkImage> image =
+      m_source.createFrameAtIndex(index, defaultColorBehavior());
   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 89 matching lines @@
 
 void BitmapImage::draw(
     PaintCanvas* canvas,
     const PaintFlags& flags,
     const FloatRect& dstRect,
     const FloatRect& srcRect,
     RespectImageOrientationEnum shouldRespectImageOrientation,
     ImageClampingMode clampMode) {
   TRACE_EVENT0("skia", "BitmapImage::draw");
 
-  sk_sp<SkImage> image =
-      imageForCurrentFrame(ColorBehavior::transformToGlobalTarget());
+  sk_sp<SkImage> image = imageForCurrentFrame();
   if (!image)
     return;  // It's too early and we don't have an image yet.
 
   FloatRect adjustedSrcRect = srcRect;
   adjustedSrcRect.intersect(SkRect::Make(image->bounds()));
 
   if (adjustedSrcRect.isEmpty() || dstRect.isEmpty())
     return;  // Nothing to draw.
 
   ImageOrientation orientation = DefaultImageOrientation;
@@ skipping 55 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,
-                                         const ColorBehavior& colorBehavior) {
+sk_sp<SkImage> BitmapImage::frameAtIndex(size_t index) {
   if (index >= frameCount())
     return nullptr;
 
-  if (index == m_cachedFrameIndex && m_cachedFrame &&
-      m_cachedFrameColorBehavior == colorBehavior)
+  if (index == m_cachedFrameIndex && m_cachedFrame)
     return m_cachedFrame;
 
-  return decodeAndCacheFrame(index, colorBehavior);
+  return decodeAndCacheFrame(index);
 }
 
 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(
-    const ColorBehavior& colorBehavior) {
-  return frameAtIndex(currentFrame(), colorBehavior);
+sk_sp<SkImage> BitmapImage::imageForCurrentFrame() {
+  return frameAtIndex(currentFrame());
 }
 
 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, colorBehavior);
+    sk_sp<SkImage> firstFrame = frameAtIndex(0);
     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. Because ColorBehavior does not affect this result, use
-    // whatever ColorBehavior was last used (if any).
-    frameAtIndex(currentFrame(), m_cachedFrameColorBehavior);
+    // metadata.
+    frameAtIndex(currentFrame());
   }
   return !frameHasAlphaAtIndex(currentFrame());
 }
 
 bool BitmapImage::currentFrameIsComplete() {
   return frameIsCompleteAtIndex(currentFrame());
 }
 
 bool BitmapImage::currentFrameIsLazyDecoded() {
-  // Because ColorBehavior does not affect this result, use whatever
-  // ColorBehavior was last used (if any).
-  sk_sp<SkImage> image =
-      frameAtIndex(currentFrame(), m_cachedFrameColorBehavior);
+  sk_sp<SkImage> image = frameAtIndex(currentFrame());
   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