Use std::string instead of WTF::String / TextStream

cc/CCLayerImpl.h

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CCLayerImpl_h
 #define CCLayerImpl_h
 
 #include "CCInputHandler.h"
 #include "CCLayerAnimationController.h"
 #include "CCRenderSurface.h"
 #include "CCResourceProvider.h"
 #include "CCSharedQuadState.h"
 #include "FloatRect.h"
 #include "IntRect.h"
 #include "Region.h"
 #include "SkColor.h"
-#include "TextStream.h"
 #include <public/WebFilterOperations.h>
 #include <public/WebTransformationMatrix.h>
 #include <wtf/OwnPtr.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
-#include <wtf/text/WTFString.h>
+#include <string>

[enne (OOO), 2012/09/10 03:43:42]

nit: header order

 
 namespace WebCore {
 
 class CCLayerSorter;
 class CCLayerTreeHostImpl;
 class CCQuadSink;
 class CCRenderer;
 class CCScrollbarAnimationController;
 class CCScrollbarLayerImpl;
 class LayerChromium;
@@ skipping 103 matching lines @@
     const WebKit::WebTransformationMatrix& sublayerTransform() const { return m_sublayerTransform; }
 
     // Debug layer border - visual effect only, do not change geometry/clipping/etc.
     void setDebugBorderColor(SkColor);
     SkColor debugBorderColor() const { return m_debugBorderColor; }
     void setDebugBorderWidth(float);
     float debugBorderWidth() const { return m_debugBorderWidth; }
     bool hasDebugBorders() const;
 
     // Debug layer name.
-    void setDebugName(const String& debugName) { m_debugName = debugName; }
-    String debugName() const { return m_debugName; }
+    void setDebugName(const std::string& debugName) { m_debugName = debugName; }
+    std::string debugName() const { return m_debugName; }
 
     CCRenderSurface* renderSurface() const { return m_renderSurface.get(); }
     void createRenderSurface();
     void clearRenderSurface() { m_renderSurface.clear(); }
 
     float drawOpacity() const { return m_drawOpacity; }
     void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
 
     bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; }
     void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; }
@@ skipping 58 matching lines @@
     bool drawTransformIsAnimating() const { return m_drawTransformIsAnimating; }
     void setDrawTransformIsAnimating(bool animating) { m_drawTransformIsAnimating = animating; }
     bool screenSpaceTransformIsAnimating() const { return m_screenSpaceTransformIsAnimating; }
     void setScreenSpaceTransformIsAnimating(bool animating) { m_screenSpaceTransformIsAnimating = animating; }
 
     const IntRect& drawableContentRect() const { return m_drawableContentRect; }
     void setDrawableContentRect(const IntRect& rect) { m_drawableContentRect = rect; }
     const FloatRect& updateRect() const { return m_updateRect; }
     void setUpdateRect(const FloatRect& updateRect) { m_updateRect = updateRect; }
 
-    String layerTreeAsText() const;
+    std::string layerTreeAsText() const;
 
     void setStackingOrderChanged(bool);
 
     bool layerPropertyChanged() const { return m_layerPropertyChanged || layerIsAlwaysDamaged(); }
     bool layerSurfacePropertyChanged() const;
 
     void resetAllChangeTrackingForSubtree();
 
     virtual bool layerIsAlwaysDamaged() const { return false; }
 
@@ skipping 12 matching lines @@
     void setHorizontalScrollbarLayer(CCScrollbarLayerImpl*);
 
     CCScrollbarLayerImpl* verticalScrollbarLayer() const;
     void setVerticalScrollbarLayer(CCScrollbarLayerImpl*);
 
 protected:
     explicit CCLayerImpl(int);
 
     void appendDebugBorderQuad(CCQuadSink&, const CCSharedQuadState*, CCAppendQuadsData&) const;
 
-    virtual void dumpLayerProperties(TextStream&, int indent) const;
-    static void writeIndent(TextStream&, int indent);
+    virtual void dumpLayerProperties(std::string*, int indent) const;
+    static std::string indentString(int indent);
 
 private:
     void setParent(CCLayerImpl* parent) { m_parent = parent; }
     friend class TreeSynchronizer;
     void clearChildList(); // Warning: This does not preserve tree structure invariants and so is only exposed to the tree synchronizer.
 
     void noteLayerPropertyChangedForSubtree();
 
     // Note carefully this does not affect the current layer.
     void noteLayerPropertyChangedForDescendants();
 
     virtual const char* layerTypeAsString() const { return "LayerChromium"; }
 
-    void dumpLayer(TextStream&, int indent) const;
+    void dumpLayer(std::string*, int indent) const;
 
     // Properties internal to CCLayerImpl
     CCLayerImpl* m_parent;
     Vector<OwnPtr<CCLayerImpl> > m_children;
     // m_maskLayer can be temporarily stolen during tree sync, we need this ID to confirm newly assigned layer is still the previous one
     int m_maskLayerId;
     OwnPtr<CCLayerImpl> m_maskLayer;
     int m_replicaLayerId; // ditto
     OwnPtr<CCLayerImpl> m_replicaLayer;
     int m_layerId;
@@ skipping 58 matching lines @@
     // to sort layers from back to front.
     float m_drawDepth;
     float m_drawOpacity;
     bool m_drawOpacityIsAnimating;
 
     // Debug borders.
     SkColor m_debugBorderColor;
     float m_debugBorderWidth;
 
     // Debug layer name.
-    String m_debugName;
+    std::string m_debugName;
 
     WebKit::WebFilterOperations m_filters;
     WebKit::WebFilterOperations m_backgroundFilters;
 
     WebKit::WebTransformationMatrix m_drawTransform;
     WebKit::WebTransformationMatrix m_screenSpaceTransform;
     bool m_drawTransformIsAnimating;
     bool m_screenSpaceTransformIsAnimating;
 
 #ifndef NDEBUG
@@ skipping 18 matching lines @@
 
     // Manages scrollbars for this layer
     OwnPtr<CCScrollbarAnimationController> m_scrollbarAnimationController;
 };
 
 void sortLayers(Vector<CCLayerImpl*>::iterator first, Vector<CCLayerImpl*>::iterator end, CCLayerSorter*);
 
 }
 
 #endif // CCLayerImpl_h