cc: Make the ScopedPtrVector and ScopedPtrDeque containers act like STL vector and deque.

cc/delegated_renderer_layer_impl.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 "cc/delegated_renderer_layer_impl.h"
 
 #include "cc/append_quads_data.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/render_pass_sink.h"
 
 namespace cc {
 
 DelegatedRendererLayerImpl::DelegatedRendererLayerImpl(LayerTreeImpl* treeImpl, int id)
     : LayerImpl(treeImpl, id)
 {
 }
 
 DelegatedRendererLayerImpl::~DelegatedRendererLayerImpl()
 {
     clearRenderPasses();
 }
 
 bool DelegatedRendererLayerImpl::hasDelegatedContent() const
 {
-    return !m_renderPassesInDrawOrder.isEmpty();
+    return !m_renderPassesInDrawOrder.empty();
 }
 
 bool DelegatedRendererLayerImpl::hasContributingDelegatedRenderPasses() const
 {
     // The root RenderPass for the layer is merged with its target
     // RenderPass in each frame. So we only have extra RenderPasses
     // to merge when we have a non-root RenderPass present.
     return m_renderPassesInDrawOrder.size() > 1;
 }
 
 void DelegatedRendererLayerImpl::setRenderPasses(ScopedPtrVector<RenderPass>& renderPassesInDrawOrder)
 {
     gfx::RectF oldRootDamage;
-    if (!m_renderPassesInDrawOrder.isEmpty())
-        oldRootDamage = m_renderPassesInDrawOrder.last()->damage_rect;
+    if (!m_renderPassesInDrawOrder.empty())
+        oldRootDamage = m_renderPassesInDrawOrder.back()->damage_rect;
 
     clearRenderPasses();
 
     for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i) {
         m_renderPassesIndexById.insert(std::pair<RenderPass::Id, int>(renderPassesInDrawOrder[i]->id, i));
-        m_renderPassesInDrawOrder.append(renderPassesInDrawOrder.take(i));
+        m_renderPassesInDrawOrder.push_back(renderPassesInDrawOrder.take(renderPassesInDrawOrder.begin() + i));
     }
     renderPassesInDrawOrder.clear();
 
-    if (!m_renderPassesInDrawOrder.isEmpty())
-        m_renderPassesInDrawOrder.last()->damage_rect.Union(oldRootDamage);
+    if (!m_renderPassesInDrawOrder.empty())
+        m_renderPassesInDrawOrder.back()->damage_rect.Union(oldRootDamage);
 }
 
 void DelegatedRendererLayerImpl::clearRenderPasses()
 {
     // FIXME: Release the resources back to the nested compositor.
     m_renderPassesIndexById.clear();
     m_renderPassesInDrawOrder.clear();
 }
 
 void DelegatedRendererLayerImpl::didLoseOutputSurface()
@@ skipping 31 matching lines @@
 
         // Don't clash with the RenderPass we generate if we own a RenderSurfaceImpl.
         DCHECK(outputRenderPassId.index > 0);
 
         renderPassSink.appendRenderPass(m_renderPassesInDrawOrder[i]->Copy(outputRenderPassId));
     }
 }
 
 void DelegatedRendererLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
 {
-    if (m_renderPassesInDrawOrder.isEmpty())
+    if (m_renderPassesInDrawOrder.empty())
         return;
 
     RenderPass::Id targetRenderPassId = appendQuadsData.renderPassId;
 
     // If the index of the renderPassId is 0, then it is a renderPass generated for a layer
     // in this compositor, not the delegated renderer. Then we want to merge our root renderPass with
     // the target renderPass. Otherwise, it is some renderPass which we added from the delegated
     // renderer.
     bool shouldMergeRootRenderPassWithTarget = !targetRenderPassId.index;
     if (shouldMergeRootRenderPassWithTarget) {
         // Verify that the renderPass we are appending to is created our renderTarget.
         DCHECK(targetRenderPassId.layer_id == renderTarget()->id());
 
-        const RenderPass* rootDelegatedRenderPass = m_renderPassesInDrawOrder.last();
+        const RenderPass* rootDelegatedRenderPass = m_renderPassesInDrawOrder.back();
         appendRenderPassQuads(quadSink, appendQuadsData, rootDelegatedRenderPass);
     } else {
         // Verify that the renderPass we are appending to was created by us.
         DCHECK(targetRenderPassId.layer_id == id());
 
         int renderPassIndex = idToIndex(targetRenderPassId.index);
         const RenderPass* delegatedRenderPass = m_renderPassesInDrawOrder[renderPassIndex];
         appendRenderPassQuads(quadSink, appendQuadsData, delegatedRenderPass);
     }
 }
 
 void DelegatedRendererLayerImpl::appendRenderPassQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData, const RenderPass* delegatedRenderPass) const
 {
     const SharedQuadState* currentSharedQuadState = 0;
     SharedQuadState* copiedSharedQuadState = 0;
     for (size_t i = 0; i < delegatedRenderPass->quad_list.size(); ++i) {
         const DrawQuad* quad = delegatedRenderPass->quad_list[i];
 
         if (quad->shared_quad_state != currentSharedQuadState) {
             currentSharedQuadState = quad->shared_quad_state;
             copiedSharedQuadState = quadSink.useSharedQuadState(currentSharedQuadState->Copy());
             bool targetIsFromDelegatedRendererLayer = appendQuadsData.renderPassId.layer_id == id();
             if (!targetIsFromDelegatedRendererLayer) {
               // Should be the root render pass.
-              DCHECK(delegatedRenderPass == m_renderPassesInDrawOrder.last());
+              DCHECK(delegatedRenderPass == m_renderPassesInDrawOrder.back());
               // This layer must be drawing to a renderTarget other than itself.
               DCHECK(renderTarget() != this);
 
               copiedSharedQuadState->content_to_target_transform = copiedSharedQuadState->content_to_target_transform * drawTransform();
               copiedSharedQuadState->clipped_rect_in_target = MathUtil::mapClippedRect(drawTransform(), copiedSharedQuadState->clipped_rect_in_target);
               copiedSharedQuadState->opacity *= drawOpacity();
             }
         }
         DCHECK(copiedSharedQuadState);
 
@@ skipping 12 matching lines @@
         quadSink.append(copyQuad.Pass(), appendQuadsData);
     }
 }
 
 const char* DelegatedRendererLayerImpl::layerTypeAsString() const
 {
     return "DelegatedRendererLayer";
 }
 
 }  // namespace cc