cc: Store tiles, painters, tiling data in scoped_ptr

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 "GraphicsContext3D.h"
 #include "Region.h"
-#include <wtf/CurrentTime.h>
-#include <wtf/MathExtras.h>
 
 using namespace std;
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
 class UpdatableTile : public CCLayerTilingData::Tile {
 public:
-    static PassOwnPtr<UpdatableTile> create(PassOwnPtr<LayerTextureUpdater::Texture> texture)
+    static scoped_ptr<UpdatableTile> create(PassOwnPtr<LayerTextureUpdater::Texture> texture)
     {
-        return adoptPtr(new UpdatableTile(texture));
+        return make_scoped_ptr(new UpdatableTile(texture));
     }
 
     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 156 matching lines @@
     LayerChromium::pushPropertiesTo(layer);
 
     CCTiledLayerImpl* tiledLayer = static_cast<CCTiledLayerImpl*>(layer);
 
     tiledLayer->setSkipsDraw(m_skipsDraw);
     tiledLayer->setContentsSwizzled(m_sampledTexelFormat != LayerTextureUpdater::SampledTexelFormatRGBA);
     tiledLayer->setTilingData(*m_tiler);
     Vector<UpdatableTile*> invalidTiles;
 
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
-#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
-        int i = iter->key.first;
-        int j = iter->key.second;
-        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->value.get());
-#else
         int i = iter->first.first;
         int j = iter->first.second;
-        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
-#endif
+        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
 
         tile->isInUseOnImpl = false;
 
         if (!tile->managedTexture()->haveBackingTexture()) {
             // Evicted tiles get deleted from both layers
             invalidTiles.append(tile);
             continue;
@@ skipping 16 matching lines @@
 {
     if (!layerTreeHost())
         return 0;
     return layerTreeHost()->contentsTextureManager();
 }
 
 void TiledLayerChromium::setLayerTreeHost(CCLayerTreeHost* host)
 {
     if (host && host != layerTreeHost()) {
         for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
-#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
-            UpdatableTile* tile = static_cast<UpdatableTile*>(iter->value.get());
-#else
-            UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
-#endif
+            UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
             tile->managedTexture()->setTextureManager(host->contentsTextureManager());
         }
     }
     LayerChromium::setLayerTreeHost(host);
 }
 
 UpdatableTile* TiledLayerChromium::tileAt(int i, int j) const
 {
     return static_cast<UpdatableTile*>(m_tiler->tileAt(i, j));
 }
 
 UpdatableTile* TiledLayerChromium::createTile(int i, int j)
 {
     createTextureUpdaterIfNeeded();
 
-    OwnPtr<UpdatableTile> tile(UpdatableTile::create(textureUpdater()->createTexture(textureManager())));
+    scoped_ptr<UpdatableTile> tile(UpdatableTile::create(textureUpdater()->createTexture(textureManager())));
     tile->managedTexture()->setDimensions(m_tiler->tileSize(), m_textureFormat);
 
     UpdatableTile* addedTile = tile.get();
-    m_tiler->addTile(tile.release(), i, j);
+    m_tiler->addTile(tile.PassAs<CCLayerTilingData::Tile>(), i, j);
 
     addedTile->dirtyRect = m_tiler->tileRect(addedTile);
 
     // Temporary diagnostic crash.
     if (!addedTile)
         CRASH();
     if (!tileAt(i, j))
         CRASH();
 
     return addedTile;
@@ skipping 24 matching lines @@
     setBorderTexelOption(borderTexelOption);
 }
 
 void TiledLayerChromium::invalidateContentRect(const IntRect& contentRect)
 {
     updateBounds();
     if (m_tiler->isEmpty() || contentRect.isEmpty() || m_skipsDraw)
         return;
 
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
-#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
-        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->value.get());
-#else
-        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
-#endif
+        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
         ASSERT(tile);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         IntRect bound = m_tiler->tileRect(tile);
         bound.intersect(contentRect);
         tile->dirtyRect.unite(bound);
     }
 }
 
@@ skipping 303 matching lines @@
                                                                                         backBuffer->texture()->format());
                 // Swap backBuffer into frontBuffer and add it to delete after commit queue.
                 backBuffer->swapTextureWith(frontBuffer);
                 layerTreeHost()->deleteTextureAfterCommit(frontBuffer.Pass());
             }
         }
     }
 
     // Now update priorities on all tiles we have in the layer, no matter where they are.
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
-#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
-        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->value.get());
-#else
-        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
-#endif
+        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         IntRect tileRect = m_tiler->tileRect(tile);
         setPriorityForTexture(visibleContentRect(), tileRect, drawsToRoot, smallAnimatedLayer, tile->managedTexture());
     }
 }
 
 Region TiledLayerChromium::visibleContentOpaqueRegion() const
 {
     if (m_skipsDraw)
         return Region();
     if (contentsOpaque())
         return visibleContentRect();
     return m_tiler->opaqueRegionInContentRect(visibleContentRect());
 }
 
 void TiledLayerChromium::resetUpdateState()
 {
     m_skipsDraw = false;
     m_failedUpdate = false;
 
     CCLayerTilingData::TileMap::const_iterator end = m_tiler->tiles().end();
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != end; ++iter) {
-#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
-        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->value.get());
-#else
-        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
-#endif
+        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         tile->resetUpdateState();
     }
 }
 
 void TiledLayerChromium::update(CCTextureUpdateQueue& queue, const CCOcclusionTracker* occlusion, CCRenderingStats& stats)
 {
     ASSERT(!m_skipsDraw && !m_failedUpdate); // Did resetUpdateState get skipped?
@@ skipping 108 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;
 }
 
 }