[cc] Remove all WTF #includes from CCLayerTreeHost

cc/CCLayerTreeHost.cpp

 // 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 "CCLayerTreeHost.h"
 
 #include "CCFontAtlas.h"
 #include "CCGraphicsContext.h"
@@ skipping 116 matching lines @@
 
     return m_proxy->initializeContext();
 }
 
 CCLayerTreeHost::~CCLayerTreeHost()
 {
     if (m_rootLayer)
         m_rootLayer->setLayerTreeHost(0);
     ASSERT(CCProxy::isMainThread());
     TRACE_EVENT0("cc", "CCLayerTreeHost::~CCLayerTreeHost");
-    ASSERT(m_proxy);
+    ASSERT(m_proxy.get());
     m_proxy->stop();
-    m_proxy.clear();
+    m_proxy.reset();
     numLayerTreeInstances--;
     RateLimiterMap::iterator it = m_rateLimiters.begin();
     if (it != m_rateLimiters.end())
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
         it->value->stop();
 #else
         it->second->stop();
 #endif
 }
 
@@ skipping 223 matching lines @@
     m_proxy->setNeedsRedraw();
     if (!CCThreadProxy::implThread())
         m_client->scheduleComposite();
 }
 
 bool CCLayerTreeHost::commitRequested() const
 {
     return m_proxy->commitRequested();
 }
 
-void CCLayerTreeHost::setAnimationEvents(PassOwnPtr<CCAnimationEventsVector> events, double wallClockTime)
+void CCLayerTreeHost::setAnimationEvents(scoped_ptr<CCAnimationEventsVector> events, double wallClockTime)
 {
     ASSERT(CCThreadProxy::isMainThread());
-    setAnimationEventsRecursive(*events, m_rootLayer.get(), wallClockTime);
+    setAnimationEventsRecursive(*events.get(), m_rootLayer.get(), wallClockTime);
 }
 
 void CCLayerTreeHost::didAddAnimation()
 {
     m_needsAnimateLayers = true;
     m_proxy->didAddAnimation();
 }
 
 void CCLayerTreeHost::setRootLayer(scoped_refptr<LayerChromium> rootLayer)
 {
@@ skipping 354 matching lines @@
 
     ASSERT(context);
     RateLimiterMap::iterator it = m_rateLimiters.find(context);
     if (it != m_rateLimiters.end())
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
         it->value->start();
 #else
         it->second->start();
 #endif
     else {
-        RefPtr<RateLimiter> rateLimiter = RateLimiter::create(context, this);
-        m_rateLimiters.set(context, rateLimiter);
+        scoped_refptr<RateLimiter> rateLimiter = RateLimiter::create(context, this);
+        m_rateLimiters[context] = rateLimiter;
         rateLimiter->start();
     }
 }
 
 void CCLayerTreeHost::stopRateLimiter(WebKit::WebGraphicsContext3D* context)
 {
     RateLimiterMap::iterator it = m_rateLimiters.find(context);
     if (it != m_rateLimiters.end()) {
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
         it->value->stop();
 #else
         it->second->stop();
 #endif
-        m_rateLimiters.remove(it);
+        m_rateLimiters.erase(it);
     }
 }
 
 void CCLayerTreeHost::rateLimit()
 {
     // Force a no-op command on the compositor context, so that any ratelimiting commands will wait for the compositing
     // context, and therefore for the SwapBuffers.
     m_proxy->forceSerializeOnSwapBuffers();
 }
 
 bool CCLayerTreeHost::bufferedUpdates()
 {
     return m_settings.maxPartialTextureUpdates != numeric_limits<size_t>::max();
 }
 
 bool CCLayerTreeHost::requestPartialTextureUpdate()
 {
     if (m_partialTextureUpdateRequests >= m_settings.maxPartialTextureUpdates)
         return false;
 
     m_partialTextureUpdateRequests++;
     return true;
 }
 
-void CCLayerTreeHost::deleteTextureAfterCommit(PassOwnPtr<CCPrioritizedTexture> texture)
+void CCLayerTreeHost::deleteTextureAfterCommit(scoped_ptr<CCPrioritizedTexture> texture)
 {
-    m_deleteTextureAfterCommitList.append(texture);
+    m_deleteTextureAfterCommitList.append(texture.Pass());
 }
 
 void CCLayerTreeHost::setDeviceScaleFactor(float deviceScaleFactor)
 {
     if (deviceScaleFactor ==  m_deviceScaleFactor)
         return;
     m_deviceScaleFactor = deviceScaleFactor;
 
     setNeedsCommit();
 }
@@ skipping 40 matching lines @@
             else
                 layer->notifyAnimationFinished(wallClockTime);
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 } // namespace cc