Upstream version 10.39.225.0

[platform/framework/web/crosswalk.git] / src / third_party / WebKit / Source / core / html / canvas / CanvasStyle.cpp

diff --git a/src/third_party/WebKit/Source/core/html/canvas/CanvasStyle.cpp b/src/third_party/WebKit/Source/core/html/canvas/CanvasStyle.cpp
index 3e9e869..cfb5c4f 100644 (file)
--- a/src/third_party/WebKit/Source/core/html/canvas/CanvasStyle.cpp
+++ b/src/third_party/WebKit/Source/core/html/canvas/CanvasStyle.cpp
@@ -29,27 +29,27 @@
 #include "config.h"
 #include "core/html/canvas/CanvasStyle.h"
 
-#include "CSSPropertyNames.h"
-#include "core/css/CSSParser.h"
+#include "core/CSSPropertyNames.h"
 #include "core/css/StylePropertySet.h"
+#include "core/css/parser/CSSParser.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/canvas/CanvasGradient.h"
 #include "core/html/canvas/CanvasPattern.h"
-#include "core/platform/graphics/GraphicsContext.h"
-#include "wtf/Assertions.h"
+#include "platform/graphics/GraphicsContext.h"
 #include "wtf/PassRefPtr.h"
 
-namespace WebCore {
+namespace blink {
 
 enum ColorParseResult { ParsedRGBA, ParsedCurrentColor, ParsedSystemColor, ParseFailed };
 
-static ColorParseResult parseColor(RGBA32& parsedColor, const String& colorString, Document* document = 0)
+static ColorParseResult parseColor(RGBA32& parsedColor, const String& colorString)
 {
     if (equalIgnoringCase(colorString, "currentcolor"))
         return ParsedCurrentColor;
-    if (CSSParser::parseColor(parsedColor, colorString))
+    const bool useStrictParsing = true;
+    if (CSSParser::parseColor(parsedColor, colorString, useStrictParsing))
         return ParsedRGBA;
-    if (CSSParser::parseSystemColor(parsedColor, colorString, document))
+    if (CSSParser::parseSystemColor(parsedColor, colorString))
         return ParsedSystemColor;
     return ParseFailed;
 }
@@ -65,7 +65,7 @@ RGBA32 currentColor(HTMLCanvasElement* canvas)
 
 bool parseColorOrCurrentColor(RGBA32& parsedColor, const String& colorString, HTMLCanvasElement* canvas)
 {
-    ColorParseResult parseResult = parseColor(parsedColor, colorString, canvas ? &canvas->document() : 0);
+    ColorParseResult parseResult = parseColor(parsedColor, colorString);
     switch (parseResult) {
     case ParsedRGBA:
     case ParsedSystemColor:
@@ -112,64 +112,65 @@ CanvasStyle::CanvasStyle(float c, float m, float y, float k, float a)
 {
 }
 
-CanvasStyle::CanvasStyle(PassRefPtr<CanvasGradient> gradient)
+CanvasStyle::CanvasStyle(PassRefPtrWillBeRawPtr<CanvasGradient> gradient)
     : m_type(Gradient)
     , m_gradient(gradient)
 {
 }
 
-CanvasStyle::CanvasStyle(PassRefPtr<CanvasPattern> pattern)
+CanvasStyle::CanvasStyle(PassRefPtrWillBeRawPtr<CanvasPattern> pattern)
     : m_type(ImagePattern)
     , m_pattern(pattern)
 {
 }
 
-PassRefPtr<CanvasStyle> CanvasStyle::createFromString(const String& color, Document* document)
+PassRefPtrWillBeRawPtr<CanvasStyle> CanvasStyle::createFromString(const String& color)
 {
     RGBA32 rgba;
-    ColorParseResult parseResult = parseColor(rgba, color, document);
+    ColorParseResult parseResult = parseColor(rgba, color);
     switch (parseResult) {
     case ParsedRGBA:
     case ParsedSystemColor:
-        return adoptRef(new CanvasStyle(rgba));
+        return adoptRefWillBeNoop(new CanvasStyle(rgba));
     case ParsedCurrentColor:
-        return adoptRef(new CanvasStyle(CurrentColor));
+        return adoptRefWillBeNoop(new CanvasStyle(CurrentColor));
     case ParseFailed:
-        return 0;
+        return nullptr;
     default:
         ASSERT_NOT_REACHED();
-        return 0;
+        return nullptr;
     }
 }
 
-PassRefPtr<CanvasStyle> CanvasStyle::createFromStringWithOverrideAlpha(const String& color, float alpha)
+PassRefPtrWillBeRawPtr<CanvasStyle> CanvasStyle::createFromStringWithOverrideAlpha(const String& color, float alpha)
 {
     RGBA32 rgba;
     ColorParseResult parseResult = parseColor(rgba, color);
     switch (parseResult) {
     case ParsedRGBA:
-        return adoptRef(new CanvasStyle(colorWithOverrideAlpha(rgba, alpha)));
+        return adoptRefWillBeNoop(new CanvasStyle(colorWithOverrideAlpha(rgba, alpha)));
     case ParsedCurrentColor:
-        return adoptRef(new CanvasStyle(CurrentColorWithOverrideAlpha, alpha));
+        return adoptRefWillBeNoop(new CanvasStyle(CurrentColorWithOverrideAlpha, alpha));
     case ParseFailed:
-        return 0;
+        return nullptr;
     default:
         ASSERT_NOT_REACHED();
-        return 0;
+        return nullptr;
     }
 }
 
-PassRefPtr<CanvasStyle> CanvasStyle::createFromGradient(PassRefPtr<CanvasGradient> gradient)
+PassRefPtrWillBeRawPtr<CanvasStyle> CanvasStyle::createFromGradient(PassRefPtrWillBeRawPtr<CanvasGradient> gradient)
 {
     if (!gradient)
-        return 0;
-    return adoptRef(new CanvasStyle(gradient));
+        return nullptr;
+    return adoptRefWillBeNoop(new CanvasStyle(gradient));
 }
-PassRefPtr<CanvasStyle> CanvasStyle::createFromPattern(PassRefPtr<CanvasPattern> pattern)
+
+PassRefPtrWillBeRawPtr<CanvasStyle> CanvasStyle::createFromPattern(PassRefPtrWillBeRawPtr<CanvasPattern> pattern)
 {
     if (!pattern)
-        return 0;
-    return adoptRef(new CanvasStyle(pattern));
+        return nullptr;
+    return adoptRefWillBeNoop(new CanvasStyle(pattern));
 }
 
 bool CanvasStyle::isEquivalentColor(const CanvasStyle& other) const
@@ -271,4 +272,10 @@ void CanvasStyle::applyFillColor(GraphicsContext* context)
     }
 }
 
+void CanvasStyle::trace(Visitor* visitor)
+{
+    visitor->trace(m_gradient);
+    visitor->trace(m_pattern);
+}
+
 }