CSSValue Immediates: Make toCSSPrimitiveValue() return a const reference

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,
@@ skipping 54 matching lines @@
     }
 #endif
 
     CSSValue(const CSSValue& cssValue)
         : m_data(cssValue.m_data)
     {
         ref();
     }
 
     // Implicit conversion from CSSPrimitiveValue.
-    CSSValue(CSSPrimitiveValue cssPrimitiveValue)
+    CSSValue(const CSSPrimitiveValue& cssPrimitiveValue)
         : m_data(static_cast<CSSValueObject*>(cssPrimitiveValue.get()))
     {
         ref();
     }
 
     ~CSSValue()
     {
         deref();
     }
 
@@ skipping 160 matching lines @@
         ref();
     }
 
     NullableCSSValue(const CSSValue& cssValue)
         : m_data(cssValue.m_data)
     {
         ref();
     }
 
     // Implicit conversion from CSSPrimitiveValue.
-    NullableCSSValue(CSSPrimitiveValue cssPrimitiveValue)
+    NullableCSSValue(const CSSPrimitiveValue& cssPrimitiveValue)
         : m_data(static_cast<CSSValueObject*>(cssPrimitiveValue.get()))
     {
         ref();
     }
 
     ~NullableCSSValue()
     {
         deref();
     };
 
@@ skipping 89 matching lines @@
     {
         return !(*reinterpret_cast<const uintptr_t*>(&m_data) & 1);
     }
 
     RawPtrWillBeMember<CSSValueObject> m_data;
 };
 
 static_assert(sizeof(CSSValue) == sizeof(void*), "CSSValue should be pointer-sized");
 static_assert(sizeof(NullableCSSValue) == sizeof(void*), "CSSValue should be pointer-sized");
 static_assert(sizeof(CSSValue) == sizeof(NullableCSSValue), "Both CSSValue containers must contain the same data");
+static_assert(sizeof(CSSValue) == sizeof(CSSPrimitiveValue), "Both CSSValue and CSSPrimitiveValue must contain the same data");
 
 template<size_t inlineCapacity>
 inline bool compareCSSValueVector(const WillBeHeapVector<CSSValue, inlineCapacity>& firstVector, const WillBeHeapVector<CSSValue, inlineCapacity>& secondVector)
 {
     size_t size = firstVector.size();
     if (size != secondVector.size())
         return false;
 
     for (size_t i = 0; i < size; i++) {
         const CSSValue& firstPtr = firstVector[i];
@@ skipping 14 matching lines @@
     } \
     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)
+inline const CSSPrimitiveValue& toCSSPrimitiveValue(const CSSValue& value)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(value.isPrimitiveValue());
-    return CSSPrimitiveValue(static_cast<CSSPrimitiveValue::CSSLargePrimitiveValue*>(value.get()));
+    return *reinterpret_cast<const CSSPrimitiveValue*>(&value);
 }
+/*
+inline CSSPrimitiveValue& toCSSPrimitiveValue(const CSSValue& value)
+{
+    ASSERT_WITH_SECURITY_IMPLICATION(value.isPrimitiveValue());
+    return *const_cast<CSSPrimitiveValue*>(reinterpret_cast<const CSSPrimitiveValue*>(&value));
+}
+*/
 
 } // 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