Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/style/ComputedStyle.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 1064 matching lines @@
     void resetBorderLeft() { SET_VAR(surround, border.m_left, BorderValue()); }
     void resetBorderImage() { SET_VAR(surround, border.m_image, NinePieceImage()); }
     void resetBorderTopLeftRadius() { SET_VAR(surround, border.m_topLeft, initialBorderRadius()); }
     void resetBorderTopRightRadius() { SET_VAR(surround, border.m_topRight, initialBorderRadius()); }
     void resetBorderBottomLeftRadius() { SET_VAR(surround, border.m_bottomLeft, initialBorderRadius()); }
     void resetBorderBottomRightRadius() { SET_VAR(surround, border.m_bottomRight, initialBorderRadius()); }
 
     void setBackgroundColor(const StyleColor& v) { SET_VAR(m_background, m_color, v); }
 
     void setBorderImage(const NinePieceImage& b) { SET_VAR(surround, border.m_image, b); }
-    void setBorderImageSource(PassRefPtrWillBeRawPtr<StyleImage>);
+    void setBorderImageSource(RawPtr<StyleImage>);
     void setBorderImageSlices(const LengthBox&);
     void setBorderImageSlicesFill(bool);
     void setBorderImageWidth(const BorderImageLengthBox&);
     void setBorderImageOutset(const BorderImageLengthBox&);
 
     void setBorderTopLeftRadius(const LengthSize& s) { SET_VAR(surround, border.m_topLeft, s); }
     void setBorderTopRightRadius(const LengthSize& s) { SET_VAR(surround, border.m_topRight, s); }
     void setBorderBottomLeftRadius(const LengthSize& s) { SET_VAR(surround, border.m_bottomLeft, s); }
     void setBorderBottomRightRadius(const LengthSize& s) { SET_VAR(surround, border.m_bottomRight, s); }
 
@@ skipping 103 matching lines @@
 
     void adjustMaskLayers()
     {
         if (maskLayers().next()) {
             accessMaskLayers().cullEmptyLayers();
             accessMaskLayers().fillUnsetProperties();
         }
     }
 
     void setMaskBoxImage(const NinePieceImage& b) { SET_VAR(rareNonInheritedData, m_maskBoxImage, b); }
-    void setMaskBoxImageSource(PassRefPtrWillBeRawPtr<StyleImage> v) { rareNonInheritedData.access()->m_maskBoxImage.setImage(v); }
+    void setMaskBoxImageSource(RawPtr<StyleImage> v) { rareNonInheritedData.access()->m_maskBoxImage.setImage(v); }
     void setMaskBoxImageSlices(const LengthBox& slices)
     {
         rareNonInheritedData.access()->m_maskBoxImage.setImageSlices(slices);
     }
     void setMaskBoxImageSlicesFill(bool fill)
     {
         rareNonInheritedData.access()->m_maskBoxImage.setFill(fill);
     }
     void setMaskBoxImageWidth(const BorderImageLengthBox& slices)
     {
         rareNonInheritedData.access()->m_maskBoxImage.setBorderSlices(slices);
     }
     void setMaskBoxImageOutset(const BorderImageLengthBox& outset)
     {
         rareNonInheritedData.access()->m_maskBoxImage.setOutset(outset);
     }
 
     void setBorderCollapse(EBorderCollapse collapse) { inherited_flags._border_collapse = collapse; }
     void setHorizontalBorderSpacing(short);
     void setVerticalBorderSpacing(short);
     void setEmptyCells(EEmptyCell v) { inherited_flags._empty_cells = v; }
     void setCaptionSide(ECaptionSide v) { inherited_flags._caption_side = v; }
 
     void setListStyleType(EListStyleType v) { inherited_flags._list_style_type = v; }
-    void setListStyleImage(PassRefPtrWillBeRawPtr<StyleImage>);
+    void setListStyleImage(RawPtr<StyleImage>);
     void setListStylePosition(EListStylePosition v) { inherited_flags._list_style_position = v; }
 
     void setMarginTop(const Length& v) { SET_VAR(surround, margin.m_top, v); }
     void setMarginBottom(const Length& v) { SET_VAR(surround, margin.m_bottom, v); }
     void setMarginLeft(const Length& v) { SET_VAR(surround, margin.m_left, v); }
     void setMarginRight(const Length& v) { SET_VAR(surround, margin.m_right, v); }
     void setMarginStart(const Length&);
     void setMarginEnd(const Length&);
 
     void resetPadding() { SET_VAR(surround, padding, LengthBox(Fixed)); }
     void setPaddingBox(const LengthBox& b) { SET_VAR(surround, padding, b); }
     void setPaddingTop(const Length& v) { SET_VAR(surround, padding.m_top, v); }
     void setPaddingBottom(const Length& v) { SET_VAR(surround, padding.m_bottom, v); }
     void setPaddingLeft(const Length& v) { SET_VAR(surround, padding.m_left, v); }
     void setPaddingRight(const Length& v) { SET_VAR(surround, padding.m_right, v); }
 
     void setCursor(ECursor c) { inherited_flags._cursor_style = c; }
-    void addCursor(PassRefPtrWillBeRawPtr<StyleImage>, bool hotSpotSpecified, const IntPoint& hotSpot = IntPoint());
-    void setCursorList(PassRefPtrWillBeRawPtr<CursorList>);
+    void addCursor(RawPtr<StyleImage>, bool hotSpotSpecified, const IntPoint& hotSpot = IntPoint());
+    void setCursorList(RawPtr<CursorList>);
     void clearCursorList();
 
     void setInsideLink(EInsideLink insideLink) { inherited_flags._insideLink = insideLink; }
     void setIsLink(bool b) { noninherited_flags.isLink = b; }
 
     PrintColorAdjust printColorAdjust() const { return static_cast<PrintColorAdjust>(inherited_flags.m_printColorAdjust); }
     void setPrintColorAdjust(PrintColorAdjust value) { inherited_flags.m_printColorAdjust = value; }
 
     // A stacking context is painted atomically and defines a stacking order, whereas
     // a containing stacking context defines in which order the stacking contexts
@@ skipping 266 matching lines @@
 
     EBaselineShift baselineShift() const { return svgStyle().baselineShift(); }
     const Length& baselineShiftValue() const { return svgStyle().baselineShiftValue(); }
     void setBaselineShiftValue(const Length& value)
     {
         SVGComputedStyle& svgStyle = accessSVGStyle();
         svgStyle.setBaselineShift(BS_LENGTH);
         svgStyle.setBaselineShiftValue(value);
     }
 
-    void setShapeOutside(PassRefPtrWillBeRawPtr<ShapeValue> value)
+    void setShapeOutside(RawPtr<ShapeValue> value)
     {
         if (rareNonInheritedData->m_shapeOutside == value)
             return;
         rareNonInheritedData.access()->m_shapeOutside = value;
     }
     ShapeValue* shapeOutside() const { return rareNonInheritedData->m_shapeOutside.get(); }
 
     static ShapeValue* initialShapeOutside() { return 0; }
 
     void setClipPath(PassRefPtr<ClipPathOperation> operation)
@@ skipping 15 matching lines @@
         float clampedShapeImageThreshold = clampTo<float>(shapeImageThreshold, 0, 1);
         SET_VAR(rareNonInheritedData, m_shapeImageThreshold, clampedShapeImageThreshold);
     }
     static float initialShapeImageThreshold() { return 0; }
 
     bool hasContent() const { return contentData(); }
     ContentData* contentData() const { return rareNonInheritedData->m_content.get(); }
     bool contentDataEquivalent(const ComputedStyle* otherStyle) const { return const_cast<ComputedStyle*>(this)->rareNonInheritedData->contentDataEquivalent(*const_cast<ComputedStyle*>(otherStyle)->rareNonInheritedData); }
     void clearContent();
     void setContent(const String&, bool add = false);
-    void setContent(PassRefPtrWillBeRawPtr<StyleImage>, bool add = false);
+    void setContent(RawPtr<StyleImage>, bool add = false);
     void setContent(PassOwnPtr<CounterContent>, bool add = false);
     void setContent(QuoteType, bool add = false);
 
     const CounterDirectiveMap* counterDirectives() const;
     CounterDirectiveMap& accessCounterDirectives();
     const CounterDirectives getCounterDirectives(const AtomicString& identifier) const;
     void clearIncrementDirectives();
     void clearResetDirectives();
 
     QuotesData* quotes() const { return rareInheritedData->quotes.get(); }
@@ skipping 304 matching lines @@
     StyleColor visitedLinkTextFillColor() const { return rareInheritedData->visitedLinkTextFillColor(); }
     StyleColor visitedLinkTextStrokeColor() const { return rareInheritedData->visitedLinkTextStrokeColor(); }
 
     StyleColor decorationColorIncludingFallback(bool visitedLink) const;
     Color colorIncludingFallback(int colorProperty, bool visitedLink) const;
 
     Color stopColor() const { return svgStyle().stopColor(); }
     Color floodColor() const { return svgStyle().floodColor(); }
     Color lightingColor() const { return svgStyle().lightingColor(); }
 
-    void appendContent(PassOwnPtrWillBeRawPtr<ContentData>);
+    void appendContent(RawPtr<ContentData>);
     void addAppliedTextDecoration(const AppliedTextDecoration&);
     void applyMotionPathTransform(float originX, float originY, TransformationMatrix&) const;
 
     bool diffNeedsFullLayoutAndPaintInvalidation(const ComputedStyle& other) const;
     bool diffNeedsFullLayout(const ComputedStyle& other) const;
     bool diffNeedsPaintInvalidationLayer(const ComputedStyle& other) const;
     bool diffNeedsPaintInvalidationObject(const ComputedStyle& other) const;
     void updatePropertySpecificDifferences(const ComputedStyle& other, StyleDifference&) const;
 
     bool requireTransformOrigin(ApplyTransformOrigin applyOrigin, ApplyMotionPath) const;
@@ skipping 106 matching lines @@
 }
 
 inline bool ComputedStyle::hasPseudoElementStyle() const
 {
     return noninherited_flags.pseudoBits & PSEUDO_ELEMENT_MASK;
 }
 
 } // namespace blink
 
 #endif // ComputedStyle_h