Revert of Evacuate ComputedStyle references from the CSS*Value hierarchy

third_party/WebKit/Source/core/css/CSSPrimitiveValue.h

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  *
  * 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.
  *
@@ skipping 11 matching lines @@
 #ifndef CSSPrimitiveValue_h
 #define CSSPrimitiveValue_h
 
 #include "core/CSSPropertyNames.h"
 #include "core/CSSValueKeywords.h"
 #include "core/CoreExport.h"
 #include "core/css/CSSValue.h"
 #include "wtf/BitVector.h"
 #include "wtf/Forward.h"
 #include "wtf/MathExtras.h"
+#include "wtf/PassRefPtr.h"
 #include "wtf/TypeTraits.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/StringView.h"
 
 namespace blink {
 
 class CSSCalcValue;
 class CSSToLengthConversionData;
 class Length;
+class ComputedStyle;
 
 // Dimension calculations are imprecise, often resulting in values of e.g.
 // 44.99998. We need to go ahead and round if we're really close to the next
 // integer value.
 template<typename T> inline T roundForImpreciseConversion(double value)
 {
     value += (value < 0) ? -0.01 : +0.01;
     return ((value > std::numeric_limits<T>::max()) || (value < std::numeric_limits<T>::min())) ? 0 : static_cast<T>(value);
 }
 
@@ skipping 149 matching lines @@
     bool isCalculated() const { return type() == UnitType::Calc; }
     bool isCalculatedPercentageWithNumber() const { return typeWithCalcResolved() == UnitType::CalcPercentageWithNumber; }
     bool isCalculatedPercentageWithLength() const { return typeWithCalcResolved() == UnitType::CalcPercentageWithLength; }
     static bool isResolution(UnitType type) { return type >= UnitType::DotsPerPixel && type <= UnitType::DotsPerCentimeter; }
     bool isFlex() const { return typeWithCalcResolved() == UnitType::Fraction; }
     bool isValueID() const { return type() == UnitType::ValueID; }
     bool colorIsDerivedFromElement() const;
 
     static CSSPrimitiveValue* createIdentifier(CSSValueID);
     static CSSPrimitiveValue* create(double value, UnitType);
+    // TODO(sashab): Remove this create() method, CSSPrimitiveValue should not
+    // reference ComputedStyle.
+    static CSSPrimitiveValue* create(const Length& value, const ComputedStyle&);
     static CSSPrimitiveValue* create(const Length& value, float zoom)
     {
         return new CSSPrimitiveValue(value, zoom);
     }
     template<typename T> static CSSPrimitiveValue* create(T value)
     {
         static_assert(!std::is_same<T, CSSValueID>::value, "Do not call create() with a CSSValueID; call createIdentifier() instead");
         return new CSSPrimitiveValue(value);
     }
 
@@ skipping 79 matching lines @@
     } m_value;
 };
 
 using CSSLengthArray = CSSPrimitiveValue::CSSLengthArray;
 
 DEFINE_CSS_VALUE_TYPE_CASTS(CSSPrimitiveValue, isPrimitiveValue());
 
 } // namespace blink
 
 #endif // CSSPrimitiveValue_h