cc: Remove wtf includes from *LayerTextureUpdater headers

cc/tiled_layer.cc

 // 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.
 
 #include "config.h"
 
 #include "TiledLayerChromium.h"
 
 #include "base/basictypes.h"
 #include "CCLayerImpl.h"
 #include "CCLayerTreeHost.h"
 #include "CCOverdrawMetrics.h"
 #include "CCTextureUpdateQueue.h"
 #include "CCTiledLayerImpl.h"
 #include "Region.h"
 
 using namespace std;
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
 class UpdatableTile : public CCLayerTilingData::Tile {
 public:
-    static scoped_ptr<UpdatableTile> create(PassOwnPtr<LayerTextureUpdater::Texture> texture)
+    static scoped_ptr<UpdatableTile> create(scoped_ptr<LayerTextureUpdater::Texture> texture)
     {
-        return make_scoped_ptr(new UpdatableTile(texture));
+        return make_scoped_ptr(new UpdatableTile(texture.Pass()));
     }
 
     LayerTextureUpdater::Texture* texture() { return m_texture.get(); }
     CCPrioritizedTexture* managedTexture() { return m_texture->texture(); }
 
     bool isDirty() const { return !dirtyRect.isEmpty(); }
 
     // Reset update state for the current frame. This should occur before painting
     // for all layers. Since painting one layer can invalidate another layer
     // after it has already painted, mark all non-dirty tiles as valid before painting
@@ skipping 15 matching lines @@
         updateRect = dirtyRect;
         dirtyRect = IntRect();
     }
 
     IntRect dirtyRect;
     IntRect updateRect;
     bool partialUpdate;
     bool validForFrame;
     bool occluded;
     bool isInUseOnImpl;
+
 private:
-    explicit UpdatableTile(PassOwnPtr<LayerTextureUpdater::Texture> texture)
+    explicit UpdatableTile(scoped_ptr<LayerTextureUpdater::Texture> texture)
         : partialUpdate(false)
         , validForFrame(false)
         , occluded(false)
         , isInUseOnImpl(false)
-        , m_texture(texture)
+        , m_texture(texture.Pass())
     {
     }
 
-    OwnPtr<LayerTextureUpdater::Texture> m_texture;
+    scoped_ptr<LayerTextureUpdater::Texture> m_texture;
 
     DISALLOW_COPY_AND_ASSIGN(UpdatableTile);
 };
 
 TiledLayerChromium::TiledLayerChromium()
     : LayerChromium()
     , m_textureFormat(GraphicsContext3D::INVALID_ENUM)
     , m_skipsDraw(false)
     , m_failedUpdate(false)
     , m_sampledTexelFormat(LayerTextureUpdater::SampledTexelFormatInvalid)
@@ skipping 368 matching lines @@
     // The updateRect should be in layer space. So we have to convert the paintRect from content space to layer space.
     m_updateRect = FloatRect(paintRect);
     float widthScale = bounds().width() / static_cast<float>(contentBounds().width());
     float heightScale = bounds().height() / static_cast<float>(contentBounds().height());
     m_updateRect.scale(widthScale, heightScale);
 
     // Calling prepareToUpdate() calls into WebKit to paint, which may have the side
     // effect of disabling compositing, which causes our reference to the texture updater to be deleted.
     // However, we can't free the memory backing the SkCanvas until the paint finishes,
     // so we grab a local reference here to hold the updater alive until the paint completes.
-    RefPtr<LayerTextureUpdater> protector(textureUpdater());
+    scoped_refptr<LayerTextureUpdater> protector(textureUpdater());
     IntRect paintedOpaqueRect;
     textureUpdater()->prepareToUpdate(paintRect, m_tiler->tileSize(), 1 / widthScale, 1 / heightScale, paintedOpaqueRect, stats);
 
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
             ASSERT(tile); // Did setTexturePriorites get skipped?
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
@@ skipping 306 matching lines @@
     IntRect prepaintRect = visibleContentRect();
     prepaintRect.inflateX(m_tiler->tileSize().width());
     prepaintRect.inflateY(m_tiler->tileSize().height() * 2);
     IntRect contentRect(IntPoint::zero(), contentBounds());
     prepaintRect.intersect(contentRect);
 
     return prepaintRect;
 }
 
 }