CSSValue Immediates: Make CSSPrimitiveValue a container

Source/core/css/CSSValue.h

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef CSSValue_h
 #define CSSValue_h
 
 #include "core/CoreExport.h"
+#include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSValueObject.h"
 #include "platform/heap/Handle.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 // A non-nullable container for CSSValueObject. Takes ownership of the passed
 // CSSValueObject.
 class CORE_EXPORT CSSValue {
@@ skipping 25 matching lines @@
         ASSERT(m_data);
     }
 #endif
 
     CSSValue(const CSSValue& cssValue)
         : m_data(cssValue.m_data)
     {
         ref();
     }
 
+    // Implicit conversion from CSSPrimitiveValue.
+    CSSValue(CSSPrimitiveValue cssPrimitiveValue)
+        : m_data(static_cast<CSSValueObject*>(cssPrimitiveValue.get()))
+    {
+        ref();
+    }
+
     ~CSSValue()
     {
         deref();
     }
 
     CSSValue& operator=(const CSSValue& rhs)
     {
         rhs.ref();
         deref();
         m_data = rhs.m_data;
@@ skipping 134 matching lines @@
     {
         ref();
     }
 
     NullableCSSValue(const CSSValue& cssValue)
         : m_data(cssValue.m_data)
     {
         ref();
     }
 
+    // Implicit conversion from CSSPrimitiveValue.
+    NullableCSSValue(CSSPrimitiveValue cssPrimitiveValue)
+        : m_data(static_cast<CSSValueObject*>(cssPrimitiveValue.get()))
+    {
+        ref();
+    }
+
     ~NullableCSSValue()
     {
         deref();
     };
 
-    operator bool() const
+    explicit operator bool() const
     {
         return m_data;
     }
 
     NullableCSSValue& operator=(const NullableCSSValue& rhs)
     {
         rhs.ref();
         deref();
         m_data = rhs.m_data;
         return *this;
     }
 
-    bool operator==(const NullableCSSValue& rhs)
+    bool operator==(const NullableCSSValue& rhs) const
     {
         return m_data ? rhs.m_data && m_data->equals(*rhs.m_data) : !bool(rhs.m_data);
     }
 
-    bool operator!=(const NullableCSSValue& rhs)
+    bool operator!=(const NullableCSSValue& rhs) const
     {
         return !(*this == rhs);
     }
 
     CSSValue& operator*()
     {
         ASSERT(m_data);
         // reinterpret_casts used to avoid ref-churn.
         return *reinterpret_cast<CSSValue*>(this);
     }
@@ skipping 83 matching lines @@
         return *static_cast<thisType*>(value.get()); \
     } \
     inline thisType* to##thisType(const NullableCSSValue& value) \
     { \
         if (!value) \
             return nullptr; \
         ASSERT_WITH_SECURITY_IMPLICATION(value->predicate); \
         return static_cast<thisType*>(value.get()); \
     }
 
+// Returns by value on purpose.
+inline CSSPrimitiveValue toCSSPrimitiveValue(const CSSValue& value)
+{
+    ASSERT_WITH_SECURITY_IMPLICATION(value.isPrimitiveValue());
+    return CSSPrimitiveValue(static_cast<CSSPrimitiveValue::CSSLargePrimitiveValue*>(value.get()));
+}
+
 } // namespace blink
 
 WTF_ALLOW_CLEAR_UNUSED_SLOTS_WITH_MEM_FUNCTIONS(blink::CSSValue);
 WTF_ALLOW_CLEAR_UNUSED_SLOTS_WITH_MEM_FUNCTIONS(blink::NullableCSSValue);
 
 #endif // CSSValue_h