Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/svg/SVGFEConvolveMatrixElement.cpp

 /*
  * Copyright (C) 2009 Dirk Schulze <krit@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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 24 matching lines @@
     if (entries.isEmpty()) {
         entries.append(std::make_pair(EDGEMODE_DUPLICATE, "duplicate"));
         entries.append(std::make_pair(EDGEMODE_WRAP, "wrap"));
         entries.append(std::make_pair(EDGEMODE_NONE, "none"));
     }
     return entries;
 }
 
 class SVGAnimatedOrder : public SVGAnimatedIntegerOptionalInteger {
 public:
-    static PassRefPtrWillBeRawPtr<SVGAnimatedOrder> create(SVGElement* contextElement)
+    static RawPtr<SVGAnimatedOrder> create(SVGElement* contextElement)
     {
-        return adoptRefWillBeNoop(new SVGAnimatedOrder(contextElement));
+        return (new SVGAnimatedOrder(contextElement));
     }
 
     SVGParsingError setBaseValueAsString(const String&) override;
 
 protected:
     SVGAnimatedOrder(SVGElement* contextElement)
         : SVGAnimatedIntegerOptionalInteger(contextElement, SVGNames::orderAttr, 0, 0)
     {
     }
 
@@ skipping 97 matching lines @@
         || attrName == SVGNames::orderAttr
         || attrName == SVGNames::kernelMatrixAttr) {
         SVGElement::InvalidationGuard invalidationGuard(this);
         invalidate();
         return;
     }
 
     SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);
 }
 
-PassRefPtrWillBeRawPtr<FilterEffect> SVGFEConvolveMatrixElement::build(SVGFilterBuilder* filterBuilder, Filter* filter)
+RawPtr<FilterEffect> SVGFEConvolveMatrixElement::build(SVGFilterBuilder* filterBuilder, Filter* filter)
 {
     FilterEffect* input1 = filterBuilder->getEffectById(AtomicString(m_in1->currentValue()->value()));
     ASSERT(input1);
 
     int orderXValue = orderX()->currentValue()->value();
     int orderYValue = orderY()->currentValue()->value();
     if (!m_order->isSpecified()) {
         orderXValue = 3;
         orderYValue = 3;
     }
 
     int targetXValue = m_targetX->currentValue()->value();
     // The spec says the default value is: targetX = floor ( orderX / 2 ))
     if (!m_targetX->isSpecified())
         targetXValue = static_cast<int>(floorf(orderXValue / 2));
 
     int targetYValue = m_targetY->currentValue()->value();
     // The spec says the default value is: targetY = floor ( orderY / 2 ))
     if (!m_targetY->isSpecified())
         targetYValue = static_cast<int>(floorf(orderYValue / 2));
 
     float divisorValue = m_divisor->currentValue()->value();
     if (!m_divisor->isSpecified()) {
-        RefPtrWillBeRawPtr<SVGNumberList> kernelMatrix = m_kernelMatrix->currentValue();
+        RawPtr<SVGNumberList> kernelMatrix = m_kernelMatrix->currentValue();
         size_t kernelMatrixSize = kernelMatrix->length();
         for (size_t i = 0; i < kernelMatrixSize; ++i)
             divisorValue += kernelMatrix->at(i)->value();
         if (!divisorValue)
             divisorValue = 1;
     }
 
-    RefPtrWillBeRawPtr<FilterEffect> effect = FEConvolveMatrix::create(filter,
+    RawPtr<FilterEffect> effect = FEConvolveMatrix::create(filter,
         IntSize(orderXValue, orderYValue), divisorValue,
         m_bias->currentValue()->value(), IntPoint(targetXValue, targetYValue), m_edgeMode->currentValue()->enumValue(),
         m_preserveAlpha->currentValue()->value(), m_kernelMatrix->currentValue()->toFloatVector());
     effect->inputEffects().append(input1);
     return effect.release();
 }
 
 } // namespace blink