cc: Remove the WTF::Vector dependency from CCRenderPass.

cc/CCLayerTreeHostImpl.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 "CCLayerTreeHostImpl.h"
 
 #include "CCAppendQuadsData.h"
 #include "CCDamageTracker.h"
@@ skipping 12 matching lines @@
 #include "CCRenderPassDrawQuad.h"
 #include "CCRendererGL.h"
 #include "CCRendererSoftware.h"
 #include "CCRenderingStats.h"
 #include "CCScrollbarAnimationController.h"
 #include "CCScrollbarLayerImpl.h"
 #include "CCSettings.h"
 #include "CCSingleThreadProxy.h"
 #include "TraceEvent.h"
 #include <wtf/CurrentTime.h>
+#include <algorithm>
 
 using WebKit::WebTransformationMatrix;
 
 namespace {
 
 void didVisibilityChange(cc::CCLayerTreeHostImpl* id, bool visible)
 {
     if (visible) {
         TRACE_EVENT_ASYNC_BEGIN1("webkit", "CCLayerTreeHostImpl::setVisible", id, "CCLayerTreeHostImpl", id);
         return;
@@ skipping 202 matching lines @@
         CCLayerTreeHostCommon::calculateDrawTransforms(m_rootLayerImpl.get(), deviceViewportSize(), m_deviceScaleFactor, &m_layerSorter, rendererCapabilities().maxTextureSize, renderSurfaceLayerList);
         CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
 
         trackDamageForAllSurfaces(m_rootLayerImpl.get(), renderSurfaceLayerList);
     }
 }
 
 void CCLayerTreeHostImpl::FrameData::appendRenderPass(scoped_ptr<CCRenderPass> renderPass)
 {
     CCRenderPass* pass = renderPass.get();
-    renderPasses.append(pass);
+    renderPasses.push_back(pass);
     renderPassesById.set(pass->id(), renderPass.Pass());
 }
 
 bool CCLayerTreeHostImpl::calculateRenderPasses(FrameData& frame)
 {
-    ASSERT(frame.renderPasses.isEmpty());
+    ASSERT(!frame.renderPasses.size());

[tfarina, 2012/10/05 02:02:12]

this should have been empty().

[danakj, 2012/10/05 14:32:13]

yes, thanks!

 
     calculateRenderSurfaceLayerList(*frame.renderSurfaceLayerList);
 
     TRACE_EVENT1("cc", "CCLayerTreeHostImpl::calculateRenderPasses", "renderSurfaceLayerList.size()", static_cast<long long unsigned>(frame.renderSurfaceLayerList->size()));
 
     // Create the render passes in dependency order.
     for (int surfaceIndex = frame.renderSurfaceLayerList->size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
         CCLayerImpl* renderSurfaceLayer = (*frame.renderSurfaceLayerList)[surfaceIndex];
         renderSurfaceLayer->renderSurface()->appendRenderPasses(frame);
     }
@@ skipping 64 matching lines @@
 
 #if !ASSERT_DISABLED
     for (size_t i = 0; i < frame.renderPasses.size(); ++i) {
         for (size_t j = 0; j < frame.renderPasses[i]->quadList().size(); ++j)
             ASSERT(frame.renderPasses[i]->quadList()[j]->sharedQuadStateId() >= 0);
         ASSERT(frame.renderPassesById.contains(frame.renderPasses[i]->id()));
     }
 #endif
 
     if (!m_hasTransparentBackground) {
-        frame.renderPasses.last()->setHasTransparentBackground(false);
-        frame.renderPasses.last()->appendQuadsToFillScreen(m_rootLayerImpl.get(), m_backgroundColor, occlusionTracker);
+        frame.renderPasses.back()->setHasTransparentBackground(false);
+        frame.renderPasses.back()->appendQuadsToFillScreen(m_rootLayerImpl.get(), m_backgroundColor, occlusionTracker);
     }
 
     if (drawFrame)
         occlusionTracker.overdrawMetrics().recordMetrics(this);
 
     removeRenderPasses(CullRenderPassesWithNoQuads(), frame);
     m_renderer->decideRenderPassAllocationsForFrame(frame.renderPasses);
     removeRenderPasses(CullRenderPassesWithCachedTextures(*m_renderer), frame);
 
     return drawFrame;
@@ skipping 48 matching lines @@
 static inline CCRenderPass* findRenderPassById(CCRenderPass::Id renderPassId, const CCLayerTreeHostImpl::FrameData& frame)
 {
     CCRenderPassIdHashMap::const_iterator it = frame.renderPassesById.find(renderPassId);
     ASSERT(it != frame.renderPassesById.end());
     return it->second;
 }
 
 static void removeRenderPassesRecursive(CCRenderPass::Id removeRenderPassId, CCLayerTreeHostImpl::FrameData& frame)
 {
     CCRenderPass* removeRenderPass = findRenderPassById(removeRenderPassId, frame);
-    size_t removeIndex = frame.renderPasses.find(removeRenderPass);
+    CCRenderPassList& renderPasses = frame.renderPasses;
+    CCRenderPassList::iterator toRemove = std::find(renderPasses.begin(), renderPasses.end(), removeRenderPass);
 
     // The pass was already removed by another quad - probably the original, and we are the replica.
-    if (removeIndex == notFound)
+    if (toRemove == renderPasses.end())
         return;
 
-    const CCRenderPass* removedPass = frame.renderPasses[removeIndex];
-    frame.renderPasses.remove(removeIndex);
+    const CCRenderPass* removedPass = *toRemove;
+    frame.renderPasses.erase(toRemove);
 
     // Now follow up for all RenderPass quads and remove their RenderPasses recursively.
     const CCQuadList& quadList = removedPass->quadList();
     CCQuadList::constBackToFrontIterator quadListIterator = quadList.backToFrontBegin();
     for (; quadListIterator != quadList.backToFrontEnd(); ++quadListIterator) {
         CCDrawQuad* currentQuad = (*quadListIterator);
         if (currentQuad->material() != CCDrawQuad::RenderPass)
             continue;
 
         CCRenderPass::Id nextRemoveRenderPassId = CCRenderPassDrawQuad::materialCast(currentQuad)->renderPassId();
         removeRenderPassesRecursive(nextRemoveRenderPassId, frame);
     }
 }
 
 bool CCLayerTreeHostImpl::CullRenderPassesWithCachedTextures::shouldRemoveRenderPass(const CCRenderPassDrawQuad& quad, const FrameData&) const
 {
     return quad.contentsChangedSinceLastFrame().isEmpty() && m_renderer.haveCachedResourcesForRenderPassId(quad.renderPassId());
 }
 
 bool CCLayerTreeHostImpl::CullRenderPassesWithNoQuads::shouldRemoveRenderPass(const CCRenderPassDrawQuad& quad, const FrameData& frame) const
 {
     const CCRenderPass* renderPass = findRenderPassById(quad.renderPassId(), frame);
-    size_t passIndex = frame.renderPasses.find(renderPass);
+    const CCRenderPassList& renderPasses = frame.renderPasses;
+    CCRenderPassList::const_iterator foundPass = std::find(renderPasses.begin(), renderPasses.end(), renderPass);
 
-    bool renderPassAlreadyRemoved = passIndex == notFound;
+    bool renderPassAlreadyRemoved = foundPass == renderPasses.end();
     if (renderPassAlreadyRemoved)
         return false;
 
     // If any quad or RenderPass draws into this RenderPass, then keep it.
-    const CCQuadList& quadList = frame.renderPasses[passIndex]->quadList();
+    const CCQuadList& quadList = (*foundPass)->quadList();
     for (CCQuadList::constBackToFrontIterator quadListIterator = quadList.backToFrontBegin(); quadListIterator != quadList.backToFrontEnd(); ++quadListIterator) {
         CCDrawQuad* currentQuad = *quadListIterator;
 
         if (currentQuad->material() != CCDrawQuad::RenderPass)
             return false;
 
         const CCRenderPass* contributingPass = findRenderPassById(CCRenderPassDrawQuad::materialCast(currentQuad)->renderPassId(), frame);
-        if (frame.renderPasses.contains(contributingPass))
+        CCRenderPassList::const_iterator foundContributingPass = std::find(renderPasses.begin(), renderPasses.end(), contributingPass);
+        if (foundContributingPass != renderPasses.end())
             return false;
     }
     return true;
 }
 
 // Defined for linking tests.
 template void CCLayerTreeHostImpl::removeRenderPasses<CCLayerTreeHostImpl::CullRenderPassesWithCachedTextures>(CullRenderPassesWithCachedTextures, FrameData&);
 template void CCLayerTreeHostImpl::removeRenderPasses<CCLayerTreeHostImpl::CullRenderPassesWithNoQuads>(CullRenderPassesWithNoQuads, FrameData&);
 
 // static
@@ skipping 68 matching lines @@
 
 void CCLayerTreeHostImpl::onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds)
 {
     m_client->onVSyncParametersChanged(monotonicTimebase, intervalInSeconds);
 }
 
 void CCLayerTreeHostImpl::drawLayers(const FrameData& frame)
 {
     TRACE_EVENT0("cc", "CCLayerTreeHostImpl::drawLayers");
     ASSERT(canDraw());
-    ASSERT(!frame.renderPasses.isEmpty());
+    ASSERT(frame.renderPasses.size());
 
     // FIXME: use the frame begin time from the overall compositor scheduler.
     // This value is currently inaccessible because it is up in Chromium's
     // RenderWidget.
     m_fpsCounter->markBeginningOfFrame(currentTime());
 
     if (m_settings.showDebugRects())
         m_debugRectHistory->saveDebugRectsForCurrentFrame(m_rootLayerImpl.get(), *frame.renderSurfaceLayerList, frame.occludingScreenSpaceRects, settings());
 
     // Because the contents of the HUD depend on everything else in the frame, the contents
@@ skipping 741 matching lines @@
 
     CCScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], monotonicTime);
 }
 
 } // namespace cc