feFlood with alpha color doesn't work correctly
[WebKit-https.git] / Source / WebCore / platform / graphics / Color.cpp
1 /*
2  * Copyright (C) 2003, 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "Color.h"
28
29 #include "AnimationUtilities.h"
30 #include "HashTools.h"
31 #include <wtf/Assertions.h>
32 #include <wtf/DecimalNumber.h>
33 #include <wtf/HexNumber.h>
34 #include <wtf/MathExtras.h>
35 #include <wtf/text/StringBuilder.h>
36 #include <wtf/text/TextStream.h>
37
38 namespace WebCore {
39
40 #if !COMPILER(MSVC)
41 const RGBA32 Color::black;
42 const RGBA32 Color::white;
43 const RGBA32 Color::darkGray;
44 const RGBA32 Color::gray;
45 const RGBA32 Color::lightGray;
46 const RGBA32 Color::transparent;
47 #endif
48
49 static const RGBA32 lightenedBlack = 0xFF545454;
50 static const RGBA32 darkenedWhite = 0xFFABABAB;
51
52 static inline unsigned premultipliedChannel(unsigned c, unsigned a, bool ceiling = true)
53 {
54     return fastDivideBy255(ceiling ? c * a + 254 : c * a);
55 }
56
57 static inline unsigned unpremultipliedChannel(unsigned c, unsigned a)
58 {
59     return (fastMultiplyBy255(c) + a - 1) / a;
60 }
61
62 RGBA32 makeRGB(int r, int g, int b)
63 {
64     return 0xFF000000 | std::max(0, std::min(r, 255)) << 16 | std::max(0, std::min(g, 255)) << 8 | std::max(0, std::min(b, 255));
65 }
66
67 RGBA32 makeRGBA(int r, int g, int b, int a)
68 {
69     return std::max(0, std::min(a, 255)) << 24 | std::max(0, std::min(r, 255)) << 16 | std::max(0, std::min(g, 255)) << 8 | std::max(0, std::min(b, 255));
70 }
71
72 RGBA32 makePremultipliedRGBA(int r, int g, int b, int a, bool ceiling)
73 {
74     return makeRGBA(premultipliedChannel(r, a, ceiling), premultipliedChannel(g, a, ceiling), premultipliedChannel(b, a, ceiling), a);
75 }
76
77 RGBA32 makeUnPremultipliedRGBA(int r, int g, int b, int a)
78 {
79     return makeRGBA(unpremultipliedChannel(r, a), unpremultipliedChannel(g, a), unpremultipliedChannel(b, a), a);
80 }
81
82 static int colorFloatToRGBAByte(float f)
83 {
84     // We use lroundf and 255 instead of nextafterf(256, 0) to match CG's rounding
85     return std::max(0, std::min(static_cast<int>(lroundf(255.0f * f)), 255));
86 }
87
88 RGBA32 makeRGBA32FromFloats(float r, float g, float b, float a)
89 {
90     return colorFloatToRGBAByte(a) << 24 | colorFloatToRGBAByte(r) << 16 | colorFloatToRGBAByte(g) << 8 | colorFloatToRGBAByte(b);
91 }
92
93 RGBA32 colorWithOverrideAlpha(RGBA32 color, float overrideAlpha)
94 {
95     RGBA32 rgbOnly = color & 0x00FFFFFF;
96     RGBA32 rgba = rgbOnly | colorFloatToRGBAByte(overrideAlpha) << 24;
97     return rgba;
98 }
99
100 static double calcHue(double temp1, double temp2, double hueVal)
101 {
102     if (hueVal < 0.0)
103         hueVal += 6.0;
104     else if (hueVal >= 6.0)
105         hueVal -= 6.0;
106     if (hueVal < 1.0)
107         return temp1 + (temp2 - temp1) * hueVal;
108     if (hueVal < 3.0)
109         return temp2;
110     if (hueVal < 4.0)
111         return temp1 + (temp2 - temp1) * (4.0 - hueVal);
112     return temp1;
113 }
114
115 // Explanation of this algorithm can be found in the CSS Color 4 Module
116 // specification at https://drafts.csswg.org/css-color-4/#hsl-to-rgb with
117 // further explanation available at http://en.wikipedia.org/wiki/HSL_color_space
118
119 // Hue is in the range of 0 to 6.0, the remainder are in the range 0 to 1.0
120 // FIXME: Use HSLToSRGB().
121 RGBA32 makeRGBAFromHSLA(double hue, double saturation, double lightness, double alpha)
122 {
123     const double scaleFactor = nextafter(256.0, 0.0);
124
125     if (!saturation) {
126         int greyValue = static_cast<int>(lightness * scaleFactor);
127         return makeRGBA(greyValue, greyValue, greyValue, static_cast<int>(alpha * scaleFactor));
128     }
129
130     double temp2 = lightness <= 0.5 ? lightness * (1.0 + saturation) : lightness + saturation - lightness * saturation;
131     double temp1 = 2.0 * lightness - temp2;
132     
133     return makeRGBA(static_cast<int>(calcHue(temp1, temp2, hue + 2.0) * scaleFactor), 
134                     static_cast<int>(calcHue(temp1, temp2, hue) * scaleFactor),
135                     static_cast<int>(calcHue(temp1, temp2, hue - 2.0) * scaleFactor),
136                     static_cast<int>(alpha * scaleFactor));
137 }
138
139 RGBA32 makeRGBAFromCMYKA(float c, float m, float y, float k, float a)
140 {
141     double colors = 1 - k;
142     int r = static_cast<int>(nextafter(256, 0) * (colors * (1 - c)));
143     int g = static_cast<int>(nextafter(256, 0) * (colors * (1 - m)));
144     int b = static_cast<int>(nextafter(256, 0) * (colors * (1 - y)));
145     return makeRGBA(r, g, b, static_cast<float>(nextafter(256, 0) * a));
146 }
147
148 // originally moved here from the CSS parser
149 template <typename CharacterType>
150 static inline bool parseHexColorInternal(const CharacterType* name, unsigned length, RGBA32& rgb)
151 {
152     if (length != 3 && length != 4 && length != 6 && length != 8)
153         return false;
154     unsigned value = 0;
155     for (unsigned i = 0; i < length; ++i) {
156         if (!isASCIIHexDigit(name[i]))
157             return false;
158         value <<= 4;
159         value |= toASCIIHexValue(name[i]);
160     }
161     if (length == 6) {
162         rgb = 0xFF000000 | value;
163         return true;
164     }
165     if (length == 8) {
166         // We parsed the values into RGBA order, but the RGBA32 type
167         // expects them to be in ARGB order, so we right rotate eight bits.
168         rgb = value << 24 | value >> 8;
169         return true;
170     }
171     if (length == 4) {
172         // #abcd converts to ddaabbcc in RGBA32.
173         rgb = (value & 0xF) << 28 | (value & 0xF) << 24
174             | (value & 0xF000) << 8 | (value & 0xF000) << 4
175             | (value & 0xF00) << 4 | (value & 0xF00)
176             | (value & 0xF0) | (value & 0xF0) >> 4;
177         return true;
178     }
179     // #abc converts to #aabbcc
180     rgb = 0xFF000000
181         | (value & 0xF00) << 12 | (value & 0xF00) << 8
182         | (value & 0xF0) << 8 | (value & 0xF0) << 4
183         | (value & 0xF) << 4 | (value & 0xF);
184     return true;
185 }
186
187 bool Color::parseHexColor(const LChar* name, unsigned length, RGBA32& rgb)
188 {
189     return parseHexColorInternal(name, length, rgb);
190 }
191
192 bool Color::parseHexColor(const UChar* name, unsigned length, RGBA32& rgb)
193 {
194     return parseHexColorInternal(name, length, rgb);
195 }
196
197 bool Color::parseHexColor(const String& name, RGBA32& rgb)
198 {
199     unsigned length = name.length();
200     
201     if (!length)
202         return false;
203     if (name.is8Bit())
204         return parseHexColor(name.characters8(), name.length(), rgb);
205     return parseHexColor(name.characters16(), name.length(), rgb);
206 }
207
208 bool Color::parseHexColor(const StringView& name, RGBA32& rgb)
209 {
210     unsigned length = name.length();
211     if (!length)
212         return false;
213     if (name.is8Bit())
214         return parseHexColor(name.characters8(), name.length(), rgb);
215     return parseHexColor(name.characters16(), name.length(), rgb);
216 }
217
218 int differenceSquared(const Color& c1, const Color& c2)
219 {
220     // FIXME: This is assuming that the colors are in the same colorspace.
221     // FIXME: This should probably return a floating point number, but many of the call
222     // sites have picked comparison values based on feel. We'd need to break out
223     // our logarithm tables to change them :)
224     int c1Red = c1.isExtended() ? c1.asExtended().red() * 255 : c1.red();
225     int c1Green = c1.isExtended() ? c1.asExtended().green() * 255 : c1.green();
226     int c1Blue = c1.isExtended() ? c1.asExtended().blue() * 255 : c1.blue();
227     int c2Red = c2.isExtended() ? c2.asExtended().red() * 255 : c2.red();
228     int c2Green = c2.isExtended() ? c2.asExtended().green() * 255 : c2.green();
229     int c2Blue = c2.isExtended() ? c2.asExtended().blue() * 255 : c2.blue();
230     int dR = c1Red - c2Red;
231     int dG = c1Green - c2Green;
232     int dB = c1Blue - c2Blue;
233     return dR * dR + dG * dG + dB * dB;
234 }
235
236 static inline const NamedColor* findNamedColor(const String& name)
237 {
238     char buffer[64]; // easily big enough for the longest color name
239     unsigned length = name.length();
240     if (length > sizeof(buffer) - 1)
241         return nullptr;
242     for (unsigned i = 0; i < length; ++i) {
243         UChar c = name[i];
244         if (!c || !WTF::isASCII(c))
245             return nullptr;
246         buffer[i] = toASCIILower(static_cast<char>(c));
247     }
248     buffer[length] = '\0';
249     return findColor(buffer, length);
250 }
251
252 Color::Color(const String& name)
253 {
254     if (name[0] == '#') {
255         RGBA32 color;
256         bool valid;
257
258         if (name.is8Bit())
259             valid = parseHexColor(name.characters8() + 1, name.length() - 1, color);
260         else
261             valid = parseHexColor(name.characters16() + 1, name.length() - 1, color);
262
263         if (valid)
264             setRGB(color);
265     } else {
266         if (auto* foundColor = findNamedColor(name))
267             setRGB(foundColor->ARGBValue);
268         else
269             m_colorData.rgbaAndFlags = invalidRGBAColor;
270     }
271 }
272
273 Color::Color(const char* name)
274 {
275     RGBA32 color;
276     bool valid;
277     if (name[0] == '#')
278         valid = parseHexColor((String)&name[1], color);
279     else {
280         const NamedColor* foundColor = findColor(name, strlen(name));
281         color = foundColor ? foundColor->ARGBValue : 0;
282         valid = foundColor;
283     }
284
285     if (valid)
286         setRGB(color);
287 }
288
289 Color::Color(const Color& other)
290     : m_colorData(other.m_colorData)
291 {
292     if (isExtended())
293         m_colorData.extendedColor->ref();
294 }
295
296 Color::Color(Color&& other)
297 {
298     *this = WTFMove(other);
299 }
300
301 Color::Color(float r, float g, float b, float a, ColorSpace colorSpace)
302 {
303     // Zero the union, just in case a 32-bit system only assigns the
304     // top 32 bits when copying the extendedColor pointer below.
305     m_colorData.rgbaAndFlags = 0;
306     auto extendedColorRef = ExtendedColor::create(r, g, b, a, colorSpace);
307     m_colorData.extendedColor = &extendedColorRef.leakRef();
308     ASSERT(isExtended());
309 }
310
311 Color& Color::operator=(const Color& other)
312 {
313     if (*this == other)
314         return *this;
315
316     if (isExtended())
317         m_colorData.extendedColor->deref();
318
319     m_colorData = other.m_colorData;
320
321     if (isExtended())
322         m_colorData.extendedColor->ref();
323     return *this;
324 }
325
326 Color& Color::operator=(Color&& other)
327 {
328     if (*this == other)
329         return *this;
330
331     if (isExtended())
332         m_colorData.extendedColor->deref();
333
334     m_colorData = other.m_colorData;
335     other.m_colorData.rgbaAndFlags = invalidRGBAColor;
336
337     return *this;
338 }
339
340 String Color::serialized() const
341 {
342     if (isExtended())
343         return asExtended().cssText();
344
345     if (isOpaque()) {
346         StringBuilder builder;
347         builder.reserveCapacity(7);
348         builder.append('#');
349         appendByteAsHex(red(), builder, Lowercase);
350         appendByteAsHex(green(), builder, Lowercase);
351         appendByteAsHex(blue(), builder, Lowercase);
352         return builder.toString();
353     }
354
355     return cssText();
356 }
357
358 String Color::cssText() const
359 {
360     if (isExtended())
361         return asExtended().cssText();
362
363     StringBuilder builder;
364     builder.reserveCapacity(28);
365     bool colorHasAlpha = !isOpaque();
366     if (colorHasAlpha)
367         builder.appendLiteral("rgba(");
368     else
369         builder.appendLiteral("rgb(");
370
371     builder.appendNumber(static_cast<unsigned char>(red()));
372     builder.appendLiteral(", ");
373
374     builder.appendNumber(static_cast<unsigned char>(green()));
375     builder.appendLiteral(", ");
376
377
378     builder.appendNumber(static_cast<unsigned char>(blue()));
379     if (colorHasAlpha) {
380         builder.appendLiteral(", ");
381
382         NumberToStringBuffer buffer;
383         bool shouldTruncateTrailingZeros = true;
384         builder.append(numberToFixedPrecisionString(alpha() / 255.0f, 6, buffer, shouldTruncateTrailingZeros));
385     }
386         
387     builder.append(')');
388     return builder.toString();
389 }
390
391 String Color::nameForRenderTreeAsText() const
392 {
393     // FIXME: Handle ExtendedColors.
394     if (alpha() < 0xFF)
395         return String::format("#%02X%02X%02X%02X", red(), green(), blue(), alpha());
396     return String::format("#%02X%02X%02X", red(), green(), blue());
397 }
398
399 Color Color::light() const
400 {
401     // Hardcode this common case for speed.
402     if (rgb() == black)
403         return lightenedBlack;
404     
405     const float scaleFactor = nextafterf(256.0f, 0.0f);
406
407     float r, g, b, a;
408     getRGBA(r, g, b, a);
409
410     float v = std::max(r, std::max(g, b));
411
412     if (v == 0.0f)
413         // Lightened black with alpha.
414         return Color(0x54, 0x54, 0x54, alpha());
415
416     float multiplier = std::min(1.0f, v + 0.33f) / v;
417
418     return Color(static_cast<int>(multiplier * r * scaleFactor),
419                  static_cast<int>(multiplier * g * scaleFactor),
420                  static_cast<int>(multiplier * b * scaleFactor),
421                  alpha());
422 }
423
424 Color Color::dark() const
425 {
426     // Hardcode this common case for speed.
427     if (rgb() == white)
428         return darkenedWhite;
429     
430     const float scaleFactor = nextafterf(256.0f, 0.0f);
431
432     float r, g, b, a;
433     getRGBA(r, g, b, a);
434
435     float v = std::max(r, std::max(g, b));
436     float multiplier = std::max(0.0f, (v - 0.33f) / v);
437
438     return Color(static_cast<int>(multiplier * r * scaleFactor),
439                  static_cast<int>(multiplier * g * scaleFactor),
440                  static_cast<int>(multiplier * b * scaleFactor),
441                  alpha());
442 }
443
444 bool Color::isDark() const
445 {
446     float red;
447     float green;
448     float blue;
449     float alpha;
450     getRGBA(red, green, blue, alpha);
451     float largestNonAlphaChannel = std::max(red, std::max(green, blue));
452     return alpha > 0.5 && largestNonAlphaChannel < 0.5;
453 }
454
455 static int blendComponent(int c, int a)
456 {
457     // We use white.
458     float alpha = a / 255.0f;
459     int whiteBlend = 255 - a;
460     c -= whiteBlend;
461     return static_cast<int>(c / alpha);
462 }
463
464 const int cStartAlpha = 153; // 60%
465 const int cEndAlpha = 204; // 80%;
466 const int cAlphaIncrement = 17; // Increments in between.
467
468 Color Color::blend(const Color& source) const
469 {
470     if (!isVisible() || source.isOpaque())
471         return source;
472
473     if (!source.alpha())
474         return *this;
475
476     int d = 255 * (alpha() + source.alpha()) - alpha() * source.alpha();
477     int a = d / 255;
478     int r = (red() * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source.red()) / d;
479     int g = (green() * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source.green()) / d;
480     int b = (blue() * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source.blue()) / d;
481     return Color(r, g, b, a);
482 }
483
484 Color Color::blendWithWhite() const
485 {
486     // If the color contains alpha already, we leave it alone.
487     if (!isOpaque())
488         return *this;
489
490     Color newColor;
491     for (int alpha = cStartAlpha; alpha <= cEndAlpha; alpha += cAlphaIncrement) {
492         // We have a solid color.  Convert to an equivalent color that looks the same when blended with white
493         // at the current alpha.  Try using less transparency if the numbers end up being negative.
494         int r = blendComponent(red(), alpha);
495         int g = blendComponent(green(), alpha);
496         int b = blendComponent(blue(), alpha);
497         
498         newColor = Color(r, g, b, alpha);
499
500         if (r >= 0 && g >= 0 && b >= 0)
501             break;
502     }
503
504     if (isSemantic())
505         newColor.setIsSemantic();
506     return newColor;
507 }
508
509 Color Color::colorWithAlphaMultipliedBy(float amount) const
510 {
511     float newAlpha = amount * (isExtended() ? m_colorData.extendedColor->alpha() : static_cast<float>(alpha()) / 255);
512     return colorWithAlpha(newAlpha);
513 }
514
515 Color Color::colorWithAlpha(float alpha) const
516 {
517     if (isExtended())
518         return Color { m_colorData.extendedColor->red(), m_colorData.extendedColor->green(), m_colorData.extendedColor->blue(), alpha, m_colorData.extendedColor->colorSpace() };
519
520     int newAlpha = alpha * 255; // Why doesn't this use colorFloatToRGBAByte() like colorWithOverrideAlpha()?
521
522     Color result = { red(), green(), blue(), newAlpha };
523     if (isSemantic())
524         result.setIsSemantic();
525     return result;
526 }
527
528 void Color::getRGBA(float& r, float& g, float& b, float& a) const
529 {
530     r = red() / 255.0f;
531     g = green() / 255.0f;
532     b = blue() / 255.0f;
533     a = alpha() / 255.0f;
534 }
535
536 void Color::getRGBA(double& r, double& g, double& b, double& a) const
537 {
538     r = red() / 255.0;
539     g = green() / 255.0;
540     b = blue() / 255.0;
541     a = alpha() / 255.0;
542 }
543
544 // FIXME: Use sRGBToHSL().
545 void Color::getHSL(double& hue, double& saturation, double& lightness) const
546 {
547     // http://en.wikipedia.org/wiki/HSL_color_space. This is a direct copy of
548     // the algorithm therein, although it's 360^o based and we end up wanting
549     // [0...1) based. It's clearer if we stick to 360^o until the end.
550     double r = static_cast<double>(red()) / 255.0;
551     double g = static_cast<double>(green()) / 255.0;
552     double b = static_cast<double>(blue()) / 255.0;
553     double max = std::max(std::max(r, g), b);
554     double min = std::min(std::min(r, g), b);
555     double chroma = max - min;
556
557     if (!chroma)
558         hue = 0.0;
559     else if (max == r)
560         hue = (60.0 * ((g - b) / chroma)) + 360.0;
561     else if (max == g)
562         hue = (60.0 * ((b - r) / chroma)) + 120.0;
563     else
564         hue = (60.0 * ((r - g) / chroma)) + 240.0;
565
566     if (hue >= 360.0)
567         hue -= 360.0;
568
569     // makeRGBAFromHSLA assumes that hue is in [0...1).
570     hue /= 360.0;
571
572     lightness = 0.5 * (max + min);
573     if (!chroma)
574         saturation = 0.0;
575     else if (lightness <= 0.5)
576         saturation = (chroma / (max + min));
577     else
578         saturation = (chroma / (2.0 - (max + min)));
579 }
580
581 void Color::getHSV(double& hue, double& saturation, double& value) const
582 {
583     double r = static_cast<double>(red()) / 255.0;
584     double g = static_cast<double>(green()) / 255.0;
585     double b = static_cast<double>(blue()) / 255.0;
586     double max = std::max(std::max(r, g), b);
587     double min = std::min(std::min(r, g), b);
588     double chroma = max - min;
589
590     if (!chroma)
591         hue = 0.0;
592     else if (max == r)
593         hue = (60.0 * ((g - b) / chroma)) + 360.0;
594     else if (max == g)
595         hue = (60.0 * ((b - r) / chroma)) + 120.0;
596     else
597         hue = (60.0 * ((r - g) / chroma)) + 240.0;
598
599     if (hue >= 360.0)
600         hue -= 360.0;
601
602     hue /= 360.0;
603
604     if (!max)
605         saturation = 0;
606     else
607         saturation = chroma / max;
608
609     value = max;
610 }
611
612 Color colorFromPremultipliedARGB(RGBA32 pixelColor)
613 {
614     int alpha = alphaChannel(pixelColor);
615     if (alpha && alpha < 255)
616         pixelColor = makeUnPremultipliedRGBA(redChannel(pixelColor), greenChannel(pixelColor), blueChannel(pixelColor), alpha);
617     return Color(pixelColor);
618 }
619
620 RGBA32 premultipliedARGBFromColor(const Color& color)
621 {
622     if (color.isOpaque()) {
623         if (color.isExtended())
624             return makeRGB(color.asExtended().red() * 255, color.asExtended().green() * 255, color.asExtended().blue() * 255);
625         return color.rgb();
626     }
627
628     if (color.isExtended())
629         return makePremultipliedRGBA(color.asExtended().red() * 255, color.asExtended().green() * 255, color.asExtended().blue() * 255, color.asExtended().alpha() * 255);
630
631     return makePremultipliedRGBA(color.red(), color.green(), color.blue(), color.alpha());
632 }
633
634 Color blend(const Color& from, const Color& to, double progress, bool blendPremultiplied)
635 {
636     // FIXME: ExtendedColor - needs to handle color spaces.
637     // We need to preserve the state of the valid flag at the end of the animation
638     if (progress == 1 && !to.isValid())
639         return Color();
640
641     if (blendPremultiplied) {
642         // Contrary to the name, RGBA32 actually stores ARGB, so we can initialize Color directly from premultipliedARGBFromColor().
643         // Also, premultipliedARGBFromColor() bails on zero alpha, so special-case that.
644         Color premultFrom = from.alpha() ? premultipliedARGBFromColor(from) : 0;
645         Color premultTo = to.alpha() ? premultipliedARGBFromColor(to) : 0;
646
647         Color premultBlended(blend(premultFrom.red(), premultTo.red(), progress),
648             blend(premultFrom.green(), premultTo.green(), progress),
649             blend(premultFrom.blue(), premultTo.blue(), progress),
650             blend(premultFrom.alpha(), premultTo.alpha(), progress));
651
652         return Color(colorFromPremultipliedARGB(premultBlended.rgb()));
653     }
654
655     return Color(blend(from.red(), to.red(), progress),
656         blend(from.green(), to.green(), progress),
657         blend(from.blue(), to.blue(), progress),
658         blend(from.alpha(), to.alpha(), progress));
659 }
660
661 void Color::tagAsValid()
662 {
663     m_colorData.rgbaAndFlags |= validRGBAColor;
664 }
665
666 ExtendedColor& Color::asExtended() const
667 {
668     ASSERT(isExtended());
669     return *m_colorData.extendedColor;
670 }
671
672 TextStream& operator<<(TextStream& ts, const Color& color)
673 {
674     return ts << color.nameForRenderTreeAsText();
675 }
676
677 TextStream& operator<<(TextStream& ts, ColorSpace colorSpace)
678 {
679     switch (colorSpace) {
680     case ColorSpaceSRGB:
681         ts << "sRGB";
682         break;
683     case ColorSpaceLinearRGB:
684         ts << "LinearRGB";
685         break;
686     case ColorSpaceDisplayP3:
687         ts << "DisplayP3";
688         break;
689     }
690     return ts;
691 }
692
693 } // namespace WebCore