CSSValue Immediates: Add move operators to CSSValue and NullableCSSValue

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 62 matching lines @@
 
     // Implicit conversion from CSSPrimitiveValue.
     CSSValue(CSSPrimitiveValue cssPrimitiveValue)
         : m_data(static_cast<CSSValueObject*>(cssPrimitiveValue.get()))
     {
         ref();
     }
 
     ~CSSValue()
     {
-        deref();
+        // Although m_data can't be null, a move constructor from NullableCSSValue
+        // could make it null for a short time.
+        if (m_data)
+            deref();
     }
 
     CSSValue& operator=(const CSSValue& rhs)
     {
         rhs.ref();
         deref();
         m_data = rhs.m_data;
         return *this;
     }
 
+    CSSValue& operator=(CSSValue&& rhs)
+    {
+        m_data = rhs.m_data;
+        rhs.m_data.clear();
+        return *this;
+    }
+
+    CSSValue(CSSValue&& rhs)
+    {
+        m_data = rhs.m_data;
+    }
+
     bool operator==(const CSSValue& other) const
     {
         if (m_data == other.m_data)
             return true;
         if (!isObject() || !other.isObject())
             return false;
         return m_data->equals(*other.m_data);
     }
 
     // TODO: Remove this and update callsites to use operator== instead.
@@ skipping 158 matching lines @@
     ~NullableCSSValue()
     {
         deref();
     };
 
     explicit operator bool() const
     {
         return m_data;
     }
 
+    NullableCSSValue(NullableCSSValue&& rhs)
+    {
+        m_data = rhs.m_data;
+        rhs.m_data = nullptr;
+    }
+
+    NullableCSSValue(CSSValue&& rhs)
+    {
+        m_data = rhs.m_data;
+        rhs.m_data = nullptr;
+    }
+
     NullableCSSValue& operator=(const NullableCSSValue& rhs)
     {
         rhs.ref();
         deref();
         m_data = rhs.m_data;
         return *this;
     }
 
+    NullableCSSValue& operator=(NullableCSSValue&& rhs)
+    {
+        m_data = rhs.m_data;
+        rhs.m_data.clear();
+        return *this;
+    }
+
     bool operator==(const NullableCSSValue& rhs) const
     {
         if (m_data == rhs.m_data)
             return true;
         if (!isObject() || (rhs && !rhs.isObject()))
             return false;
         return m_data ? rhs.m_data && m_data->equals(*rhs.m_data) : !bool(rhs.m_data);
     }
 
     bool operator!=(const NullableCSSValue& rhs) const
@@ skipping 112 matching lines @@
     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