remove memoryinstrumentation

Source/core/css/CSSCalculationValue.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "CSSCalculationValue.h"
 
 #include "CSSValueList.h"
 #include "Length.h"
 #include "StyleResolver.h"
-#include "WebCoreMemoryInstrumentation.h"
 
 #include <wtf/OwnPtr.h>
 #include <wtf/PassOwnPtr.h>
 #include <wtf/text/StringBuilder.h>
 
 static const int maxExpressionDepth = 100;
 
 enum ParseState {
     OK,
     TooDeep,
@@ skipping 54 matching lines @@
 String CSSCalcValue::customSerializeResolvingVariables(const HashMap<AtomicString, String>& variables) const
 {
     return buildCssText(m_expression->serializeResolvingVariables(variables));
 }
 
 bool CSSCalcValue::hasVariableReference() const
 {
     return m_expression->hasVariableReference();
 }
 
-void CSSCalcValue::reportDescendantMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
-{
-    MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CSS);
-}
-    
 double CSSCalcValue::clampToPermittedRange(double value) const
 {
     return m_nonNegative && value < 0 ? 0 : value;
 }    
     
 double CSSCalcValue::doubleValue() const 
 { 
     return clampToPermittedRange(m_expression->doubleValue());
 }
 
@@ skipping 91 matching lines @@
     }
 
     virtual bool equals(const CSSCalcExpressionNode& other) const
     {
         if (type() != other.type())
             return false;
 
         return compareCSSValuePtr(m_value, static_cast<const CSSCalcPrimitiveValue&>(other).m_value);
     }
 
-    virtual void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const OVERRIDE
-    {
-        MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CSS);
-        info.addMember(m_value, "value");
-    }
-
     virtual Type type() const { return CssCalcPrimitiveValue; }
     
 private:
     explicit CSSCalcPrimitiveValue(CSSPrimitiveValue* value, bool isInteger)
         : CSSCalcExpressionNode(unitCategory((CSSPrimitiveValue::UnitTypes)value->primitiveType()), isInteger)
         , m_value(value)
     {
     }
 
     RefPtr<CSSPrimitiveValue> m_value;
@@ skipping 72 matching lines @@
         return evaluate(m_leftSide->doubleValue(), m_rightSide->doubleValue());
     }
     
     virtual double computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, double multiplier, bool computingFontSize) const
     {
         const double leftValue = m_leftSide->computeLengthPx(currentStyle, rootStyle, multiplier, computingFontSize);
         const double rightValue = m_rightSide->computeLengthPx(currentStyle, rootStyle, multiplier, computingFontSize);
         return evaluate(leftValue, rightValue);
     }
 
-    virtual void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const OVERRIDE
-    {
-        MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CSS);
-        info.addMember(m_leftSide, "leftSide");
-        info.addMember(m_rightSide, "rightSide");
-    }
-
     static String buildCssText(const String& leftExpression, const String& rightExpression, CalcOperator op)
     {
         StringBuilder result;
         result.append('(');
         result.append(leftExpression);
         result.append(' ');
         result.append(static_cast<char>(op));
         result.append(' ');
         result.append(rightExpression);
         result.append(')');
@@ skipping 201 matching lines @@
     RefPtr<CSSCalcExpressionNode> expression;
     
     if (equalIgnoringCase(name, "calc(") || equalIgnoringCase(name, "-webkit-calc("))
         expression = parser.parseCalc(parserValueList);    
     // FIXME calc (http://webkit.org/b/16662) Add parsing for min and max here
 
     return expression ? adoptRef(new CSSCalcValue(expression, range)) : 0;
 }
 
 } // namespace WebCore