cc: Remove wtf includes from resource provider

cc/resource_provider.cc

 // Copyright 2012 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 "CCResourceProvider.h"
 #ifdef LOG
 #undef LOG
 #endif
@@ skipping 94 matching lines @@
 }
 
 CCResourceProvider::Child::Child()
 {
 }
 
 CCResourceProvider::Child::~Child()
 {
 }
 
-PassOwnPtr<CCResourceProvider> CCResourceProvider::create(CCGraphicsContext* context)
+scoped_ptr<CCResourceProvider> CCResourceProvider::create(CCGraphicsContext* context)
 {
-    OwnPtr<CCResourceProvider> resourceProvider(adoptPtr(new CCResourceProvider(context)));
+    scoped_ptr<CCResourceProvider> resourceProvider(new CCResourceProvider(context));
     if (!resourceProvider->initialize())
-        return nullptr;
-    return resourceProvider.release();
+        return scoped_ptr<CCResourceProvider>();
+    return resourceProvider.Pass();
 }
 
 CCResourceProvider::~CCResourceProvider()
 {
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent())
         return;
-    m_textureUploader.clear();
-    m_textureCopier.clear();
+    m_textureUploader.reset();
+    m_textureCopier.reset();
 }
 
 WebGraphicsContext3D* CCResourceProvider::graphicsContext3D()
 {
     ASSERT(CCProxy::isImplThread());
     return m_context->context3D();
 }
 
 bool CCResourceProvider::inUseByConsumer(ResourceId id)
 {
@@ skipping 97 matching lines @@
 
     m_resources.erase(it);
 }
 
 void CCResourceProvider::deleteOwnedResources(int pool)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceIdArray toDelete;
     for (ResourceMap::iterator it = m_resources.begin(); it != m_resources.end(); ++it) {
         if (it->second.pool == pool && !it->second.external && !it->second.markedForDeletion)
-            toDelete.append(it->first);
+            toDelete.push_back(it->first);
     }
     for (ResourceIdArray::iterator it = toDelete.begin(); it != toDelete.end(); ++it)
         deleteResource(*it);
 }
 
 CCResourceProvider::ResourceType CCResourceProvider::resourceType(ResourceId id)
 {
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
@@ skipping 147 matching lines @@
 CCResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware()
 {
     m_resourceProvider->unlockForRead(m_resourceId);
 }
 
 CCResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware(CCResourceProvider* resourceProvider, CCResourceProvider::ResourceId resourceId)
     : m_resourceProvider(resourceProvider)
     , m_resourceId(resourceId)
 {
     CCResourceProvider::populateSkBitmapWithResource(&m_skBitmap, resourceProvider->lockForWrite(resourceId));
-    m_skCanvas = adoptPtr(new SkCanvas(m_skBitmap));
+    m_skCanvas.reset(new SkCanvas(m_skBitmap));
 }
 
 CCResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware()
 {
     m_resourceProvider->unlockForWrite(m_resourceId);
 }
 
 CCResourceProvider::CCResourceProvider(CCGraphicsContext* context)
     : m_context(context)
     , m_nextId(1)
@@ skipping 29 matching lines @@
         else if (extensions[i] == "GL_ANGLE_texture_usage")
             m_useTextureUsageHint = true;
         else if (extensions[i] == "GL_CHROMIUM_map_sub")
             useMapSub = true;
         else if (extensions[i] == "GL_CHROMIUM_shallow_flush")
             m_useShallowFlush = true;
         else if (extensions[i] == "GL_CHROMIUM_bind_uniform_location")
             useBindUniform = true;
     }
 
-    m_texSubImage = adoptPtr(new LayerTextureSubImage(useMapSub));
+    m_texSubImage.reset(new LayerTextureSubImage(useMapSub));
     m_textureCopier = AcceleratedTextureCopier::create(context3d, useBindUniform);
 
     m_textureUploader = ThrottledTextureUploader::create(context3d);
     GLC(context3d, context3d->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_maxTextureSize));
     return true;
 }
 
 int CCResourceProvider::createChild(int pool)
 {
     ASSERT(CCProxy::isImplThread());
@@ skipping 29 matching lines @@
     list.syncPoint = 0;
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return list;
     }
     for (ResourceIdArray::const_iterator it = resources.begin(); it != resources.end(); ++it) {
         TransferableResource resource;
         if (transferResource(context3d, *it, &resource)) {
             m_resources.find(*it)->second.exported = true;
-            list.resources.append(resource);
+            list.resources.push_back(resource);
         }
     }
     if (list.resources.size())
         list.syncPoint = context3d->insertSyncPoint();
     return list;
 }
 
 CCResourceProvider::TransferableResourceList CCResourceProvider::prepareSendToChild(int child, const ResourceIdArray& resources)
 {
     ASSERT(CCProxy::isImplThread());
     TransferableResourceList list;
     list.syncPoint = 0;
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return list;
     }
     Child& childInfo = m_children.find(child)->second;
     for (ResourceIdArray::const_iterator it = resources.begin(); it != resources.end(); ++it) {
         TransferableResource resource;
         if (!transferResource(context3d, *it, &resource))
             ASSERT_NOT_REACHED();
         ASSERT(childInfo.parentToChildMap.find(*it) != childInfo.parentToChildMap.end());
         resource.id = childInfo.parentToChildMap[*it];
         childInfo.parentToChildMap.erase(*it);
         childInfo.childToParentMap.erase(resource.id);
-        list.resources.append(resource);
+        list.resources.push_back(resource);
         deleteResource(*it);
     }
     if (list.resources.size())
         list.syncPoint = context3d->insertSyncPoint();
     return list;
 }
 
 void CCResourceProvider::receiveFromChild(int child, const TransferableResourceList& resources)
 {
     ASSERT(CCProxy::isImplThread());
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
     if (resources.syncPoint) {
         // NOTE: If the parent is a browser and the child a renderer, the parent
         // is not supposed to have its context wait, because that could induce
         // deadlocks and/or security issues. The caller is responsible for
         // waiting asynchronously, and resetting syncPoint before calling this.
         // However if the parent is a renderer (e.g. browser tag), it may be ok
         // (and is simpler) to wait.
         GLC(context3d, context3d->waitSyncPoint(resources.syncPoint));
     }
     Child& childInfo = m_children.find(child)->second;
-    for (Vector<TransferableResource>::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
+    for (TransferableResourceArray::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
         unsigned textureId;
         GLC(context3d, textureId = context3d->createTexture());
         GLC(context3d, context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, textureId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GraphicsContext3D::TEXTURE_2D, it->mailbox.name));
         ResourceId id = m_nextId++;
         Resource resource(textureId, childInfo.pool, it->size, it->format);
         m_resources[id] = resource;
-        m_mailboxes.append(it->mailbox);
+        m_mailboxes.push_back(it->mailbox);
         childInfo.parentToChildMap[id] = it->id;
         childInfo.childToParentMap[it->id] = id;
     }
 }
 
 void CCResourceProvider::receiveFromParent(const TransferableResourceList& resources)
 {
     ASSERT(CCProxy::isImplThread());
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
     if (resources.syncPoint)
         GLC(context3d, context3d->waitSyncPoint(resources.syncPoint));
-    for (Vector<TransferableResource>::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
+    for (TransferableResourceArray::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
         ResourceMap::iterator mapIterator = m_resources.find(it->id);
         ASSERT(mapIterator != m_resources.end());
         Resource* resource = &mapIterator->second;
         ASSERT(resource->exported);
         resource->exported = false;
         GLC(context3d, context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, resource->glId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GraphicsContext3D::TEXTURE_2D, it->mailbox.name));
-        m_mailboxes.append(it->mailbox);
+        m_mailboxes.push_back(it->mailbox);
         if (resource->markedForDeletion)
             deleteResourceInternal(mapIterator);
     }
 }
 
 bool CCResourceProvider::transferResource(WebGraphicsContext3D* context, ResourceId id, TransferableResource* resource)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceMap::const_iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     const Resource* source = &it->second;
     ASSERT(!source->lockedForWrite);
     ASSERT(!source->lockForReadCount);
     ASSERT(!source->external);
     if (source->exported)
         return false;
     resource->id = id;
     resource->format = source->format;
     resource->size = source->size;
-    if (!m_mailboxes.isEmpty())
-        resource->mailbox = m_mailboxes.takeFirst();
+    if (m_mailboxes.size()) {
+        resource->mailbox = m_mailboxes.front();
+        m_mailboxes.pop_front();
+    }
     else
         GLC(context, context->genMailboxCHROMIUM(resource->mailbox.name));
     GLC(context, context->bindTexture(GraphicsContext3D::TEXTURE_2D, source->glId));
     GLC(context, context->produceTextureCHROMIUM(GraphicsContext3D::TEXTURE_2D, resource->mailbox.name));
     return true;
 }
 
 void CCResourceProvider::trimMailboxDeque()
 {
     // Trim the mailbox deque to the maximum number of resources we may need to
@@ skipping 10 matching lines @@
     } else {
         base::hash_set<int> childPoolSet;
         for (ChildMap::iterator it = m_children.begin(); it != m_children.end(); ++it)
             childPoolSet.insert(it->second.pool);
         for (ResourceMap::iterator it = m_resources.begin(); it != m_resources.end(); ++it) {
             if (ContainsKey(childPoolSet, it->second.pool))
                 ++maxMailboxCount;
         }
     }
     while (m_mailboxes.size() > maxMailboxCount)
-        m_mailboxes.removeFirst();
+        m_mailboxes.pop_front();
 }
 
 }