CSSValue Immediates: Make toCSSPrimitiveValue() return a const reference

Source/core/css/CSSPrimitiveValueTest.cpp

 // Copyright 2015 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 "config.h"
 
 #include "core/css/CSSPrimitiveValue.h"
 
 #include "core/css/CSSValueTestHelper.h"
 #include <gtest/gtest.h>
 #include <strings.h>
 
 using namespace blink;
 
 namespace {
 
 void clearTaggedPtr(CSSPrimitiveValue::CSSTaggedPtrValue& taggedPtr)
 {
     taggedPtr.flag = 0;
     taggedPtr.type = static_cast<CSSPrimitiveValue::UnitType>(0);
-    taggedPtr.setValue(0.0);
+    taggedPtr.valueRaw = 0;
 }
 
-TEST(CSSPrimitiveValueTest, CSSPrimitiveValueTest)
+TEST(CSSPrimitiveValueTest, CSSPrimitiveDoubleValueTest)
 {
     // 1.0 can be stored in a tagged ptr.
     CSSPrimitiveValue value = CSSPrimitiveValue::create(1.0, CSSPrimitiveValue::CSS_INTEGER);
     EXPECT_EQ(1.0, value.getDoubleValue());
-    EXPECT_EQ("1", value.customCSSText());
+    EXPECT_STREQ("1", value.customCSSText().ascii().data());
     EXPECT_TRUE(value.isNumber());
     EXPECT_FALSE(value.isAttr());
 
     CSSValue cssValue(value);
     EXPECT_TRUE(cssValue.isPrimitiveValue());
     EXPECT_FALSE(cssValue.isImageValue());
-    EXPECT_EQ("1", cssValue.cssText());
+    EXPECT_STREQ("1", cssValue.cssText().ascii().data());
 
     // 3.3 cannot be stored in a tagged ptr.
     CSSPrimitiveValue valueInTaggedPtr = CSSPrimitiveValue::create(3.3, CSSPrimitiveValue::CSS_NUMBER);
     EXPECT_EQ(3.3, valueInTaggedPtr.getDoubleValue());
-    EXPECT_EQ("3.3", valueInTaggedPtr.customCSSText());
+    EXPECT_STREQ("3.3", valueInTaggedPtr.customCSSText().ascii().data());
     EXPECT_TRUE(valueInTaggedPtr.isNumber());
     EXPECT_FALSE(value.isAttr());
 
     CSSValue cssValueWithTaggedPtr(valueInTaggedPtr);
     EXPECT_TRUE(cssValueWithTaggedPtr.isPrimitiveValue());
     EXPECT_FALSE(cssValueWithTaggedPtr.isImageValue());
-    EXPECT_EQ("3.3", cssValueWithTaggedPtr.cssText());
+    EXPECT_STREQ("3.3", cssValueWithTaggedPtr.cssText().ascii().data());
 
     EXPECT_FALSE(cssValue.equals(cssValueWithTaggedPtr));
     EXPECT_FALSE(cssValueWithTaggedPtr.equals(cssValue));
 
     CSSValue cssValueCopy(cssValue);
     EXPECT_TRUE(cssValue.equals(cssValueCopy));
     EXPECT_TRUE(cssValueCopy.equals(cssValue));
 
     CSSValue cssValueWithTaggedPtrCopy(cssValueWithTaggedPtr);
     EXPECT_TRUE(cssValueWithTaggedPtr.equals(cssValueWithTaggedPtrCopy));
     EXPECT_TRUE(cssValueWithTaggedPtrCopy.equals(cssValueWithTaggedPtr));
 }
 
+TEST(CSSPrimitiveValueTest, CSSPrimitiveColorValueTest)
+{
+    // (r, g, b, 0) and (r, g, b, 255) can be stored as a tagged ptr.
+    RGBA32 colorAlpha0 = makeRGBA(5, 0, 15, 0);
+    CSSPrimitiveValue valueAlpha0 = CSSPrimitiveValue::createColor(colorAlpha0);
+    EXPECT_TRUE(valueAlpha0.isRGBColor());
+    EXPECT_FALSE(valueAlpha0.isNumber());
+    EXPECT_EQ(5, redChannel(valueAlpha0.getRGBA32Value()));
+    EXPECT_EQ(0, greenChannel(valueAlpha0.getRGBA32Value()));
+    EXPECT_EQ(15, blueChannel(valueAlpha0.getRGBA32Value()));
+    EXPECT_EQ(0, alphaChannel(valueAlpha0.getRGBA32Value()));
+    EXPECT_STREQ("rgba(5, 0, 15, 0)", valueAlpha0.customCSSText().ascii().data());
+
+    RGBA32 colorAlpha255 = makeRGBA(15, 100, 255, 255);
+    CSSPrimitiveValue valueAlpha255 = CSSPrimitiveValue::createColor(colorAlpha255);
+    EXPECT_TRUE(valueAlpha255.isRGBColor());
+    EXPECT_FALSE(valueAlpha255.isNumber());
+    EXPECT_EQ(15, redChannel(valueAlpha255.getRGBA32Value()));
+    EXPECT_EQ(100, greenChannel(valueAlpha255.getRGBA32Value()));
+    EXPECT_EQ(255, blueChannel(valueAlpha255.getRGBA32Value()));
+    EXPECT_EQ(255, alphaChannel(valueAlpha255.getRGBA32Value()));
+    EXPECT_STREQ("rgb(15, 100, 255)", valueAlpha255.customCSSText().ascii().data());
+
+    // Other alpha values can be stored as a tagged ptr on 64-bit only.
+    RGBA32 colorAlphaOther = makeRGBA(0, 10, 15, 51);
+    CSSPrimitiveValue valueAlphaOther = CSSPrimitiveValue::createColor(colorAlphaOther);
+    EXPECT_TRUE(valueAlphaOther.isRGBColor());
+    EXPECT_FALSE(valueAlphaOther.isNumber());
+    EXPECT_EQ(0, redChannel(valueAlphaOther.getRGBA32Value()));
+    EXPECT_EQ(10, greenChannel(valueAlphaOther.getRGBA32Value()));
+    EXPECT_EQ(15, blueChannel(valueAlphaOther.getRGBA32Value()));
+    EXPECT_EQ(51, alphaChannel(valueAlphaOther.getRGBA32Value()));
+    EXPECT_STREQ("rgba(0, 10, 15, 0.2)", valueAlphaOther.customCSSText().ascii().data());
+
+
+    EXPECT_FALSE(CSSValue(valueAlpha0).equals(CSSValue(valueAlpha255)));
+    EXPECT_FALSE(CSSValue(valueAlpha255).equals(CSSValue(valueAlpha0)));
+    EXPECT_FALSE(CSSValue(valueAlphaOther).equals(CSSValue(valueAlpha0)));
+    EXPECT_FALSE(CSSValue(valueAlpha0).equals(CSSValue(valueAlphaOther)));
+
+    CSSValue cssValueWithTaggedPtrCopy(valueAlpha0);
+    EXPECT_TRUE(CSSValue(valueAlpha0).equals(CSSValue(cssValueWithTaggedPtrCopy)));
+    EXPECT_TRUE(CSSValue(cssValueWithTaggedPtrCopy).equals(CSSValue(valueAlpha0)));
+
+    CSSValue cssValueCopy(valueAlphaOther);
+    EXPECT_TRUE(CSSValue(valueAlphaOther).equals(CSSValue(cssValueCopy)));
+    EXPECT_TRUE(CSSValue(cssValueCopy).equals(CSSValue(valueAlphaOther)));
+}
+
+TEST(CSSPrimitiveValueTest, CSSPrimitiveIDValueTest)
+{
+    // All value and property IDs can be stored as a tagged ptr.
+    CSSPrimitiveValue valueID = CSSPrimitiveValue::createIdentifier(CSSValueRed);
+    EXPECT_EQ(CSSPrimitiveValue::CSS_IDENT, valueID.primitiveType());
+    EXPECT_TRUE(valueID.isValueID());
+    EXPECT_FALSE(valueID.isNumber());
+    EXPECT_EQ(CSSValueRed, valueID.getValueID());
+    EXPECT_STREQ("red", valueID.customCSSText().ascii().data());
+
+    CSSPrimitiveValue propertyID = CSSPrimitiveValue::createIdentifier(CSSPropertyBorder);
+    EXPECT_EQ(CSSPrimitiveValue::CSS_IDENT, propertyID.primitiveType());
+    EXPECT_FALSE(propertyID.isNumber());
+    EXPECT_EQ(CSSPropertyBorder, propertyID.getPropertyID());
+    EXPECT_STREQ("border", propertyID.customCSSText().ascii().data());
+}
+
 TEST(CSSPrimitiveValueTest, CSSTaggedPtrValueTest)
 {
     CSSPrimitiveValue::CSSTaggedPtrValue taggedPtr;
     clearTaggedPtr(taggedPtr);
 
     // Check that all fields can be get/set correctly.
     EXPECT_EQ(0UL, taggedPtr.flag);
     taggedPtr.flag = 1;
     EXPECT_EQ(1UL, taggedPtr.flag);
 
     EXPECT_EQ(0UL, taggedPtr.type);
     taggedPtr.type = CSSPrimitiveValue::CSS_INTEGER;
     EXPECT_EQ(CSSPrimitiveValue::CSS_INTEGER, taggedPtr.type);
 
-    EXPECT_EQ(0UL, taggedPtr.getValue());
-    taggedPtr.setValue(1.0);
-    EXPECT_EQ(1.0, taggedPtr.getValue());
+    EXPECT_EQ(0UL, taggedPtr.getValue().num);
+    CSSPrimitiveValue::CSSPrimitiveValueData data;
+    data.num = 1.0;
+    taggedPtr.setValue(data, CSSPrimitiveValue::CSS_NUMBER);
+    EXPECT_EQ(1.0, taggedPtr.getValue().num);
 
     taggedPtr.flag = 1;
     taggedPtr.type = CSSPrimitiveValue::CSS_INTEGER;
-    taggedPtr.setValue(1.0);
+    taggedPtr.setValue(data, CSSPrimitiveValue::CSS_INTEGER);
     EXPECT_EQ(1UL, taggedPtr.flag);
     EXPECT_EQ(CSSPrimitiveValue::CSS_INTEGER, taggedPtr.type);
-    EXPECT_EQ(1.0, taggedPtr.getValue());
+    EXPECT_EQ(1.0, taggedPtr.getValue().num);
 
     clearTaggedPtr(taggedPtr);
     EXPECT_EQ(0UL, taggedPtr.flag);
     EXPECT_EQ(0UL, taggedPtr.type);
-    EXPECT_EQ(0UL, taggedPtr.getValue());
+    EXPECT_EQ(0.0, taggedPtr.getValue().num);
     EXPECT_EQ(0UL, *reinterpret_cast<uintptr_t*>(&taggedPtr));
 }
 
 TEST(CSSPrimitiveValueTest, FitsWithoutDataLossTest)
 {
+    CSSPrimitiveValue::CSSPrimitiveValueData data;
     // Consistent on 32-bit/64-bit
-    EXPECT_EQ(true, CSSPrimitiveValue::CSSTaggedPtrValue::fitsWithoutDataLoss(1.0));
-    EXPECT_EQ(false, CSSPrimitiveValue::CSSTaggedPtrValue::fitsWithoutDataLoss(3.3));
+    data.num = 1.0;
+    EXPECT_EQ(true, CSSPrimitiveValue::CSSTaggedPtrValue::canFitWithoutDataLoss(data, CSSPrimitiveValue::CSS_NUMBER));
+    data.num = 3.3;
+    EXPECT_EQ(false, CSSPrimitiveValue::CSSTaggedPtrValue::canFitWithoutDataLoss(data, CSSPrimitiveValue::CSS_NUMBER));
 
     uint64_t trailing1sOnAllPlatforms = 0xf;
-    EXPECT_EQ(false, CSSPrimitiveValue::CSSTaggedPtrValue::fitsWithoutDataLoss(*reinterpret_cast<double*>(&trailing1sOnAllPlatforms)));
+    data.num = *reinterpret_cast<double*>(&trailing1sOnAllPlatforms);
+    EXPECT_EQ(false, CSSPrimitiveValue::CSSTaggedPtrValue::canFitWithoutDataLoss(data, CSSPrimitiveValue::CSS_NUMBER));
 
     // Fits on 64-bit, but not on 32-bit
     uint64_t trailing1sOn32BitOnly = 0xf00;
+    data.num = *reinterpret_cast<double*>(&trailing1sOn32BitOnly);
     bool expectToFit;
 #if CPU(32BIT)
     expectToFit = false;
 #elif CPU(64BIT)
     expectToFit = true;
 #endif
-    EXPECT_EQ(expectToFit, CSSPrimitiveValue::CSSTaggedPtrValue::fitsWithoutDataLoss(*reinterpret_cast<double*>(&trailing1sOn32BitOnly)));
+    EXPECT_EQ(expectToFit, CSSPrimitiveValue::CSSTaggedPtrValue::canFitWithoutDataLoss(data, CSSPrimitiveValue::CSS_NUMBER));
 }
 
 // Tests that the flag bit is in the least-significant bit. This test is important
 // since we implement CSSTaggedPtrValue using bitfields, and the C++ standard specifies
 // that bitfield packing behavior is implementation-specific.
 TEST(CSSPrimitiveValueTest, FlagBitInLSBTest)
 {
     CSSPrimitiveValue::CSSTaggedPtrValue taggedPtr;
     clearTaggedPtr(taggedPtr);
 
     taggedPtr.flag = 1;
     EXPECT_EQ(1UL, *reinterpret_cast<uintptr_t*>(&taggedPtr));
 
     taggedPtr.flag = 0;
     EXPECT_EQ(0UL, *reinterpret_cast<uintptr_t*>(&taggedPtr));
+
+    // A real pointer should have a 'flag' of 0.
+    int* ptr = new int();
+    EXPECT_NE(nullptr, ptr);
+    CSSPrimitiveValue::CSSTaggedPtrValue ptrAsTaggedPtr = *reinterpret_cast<CSSPrimitiveValue::CSSTaggedPtrValue*>(&ptr);
+    EXPECT_EQ(0UL, ptrAsTaggedPtr.flag);
+    delete ptr;
 }
 
 // Test that all valid values for UnitType fit in the UnitType bit field in the
 // tagged pointer.
 TEST(CSSPrimitiveValueTest, UnitTypeSizeTest)
 {
     CSSPrimitiveValue::CSSTaggedPtrValue taggedPtr;
     clearTaggedPtr(taggedPtr);
 
     // We can't take the sizeof() of a bitfield. Instead, try set the largest primitive
     // value type we have, and see if we can read it out again.
     taggedPtr.type = CSSPrimitiveValue::CSS_QEM;
     ASSERT_EQ(CSSPrimitiveValue::CSS_QEM, taggedPtr.type);
 }
 
 
 } // namespace