Add wrapper container for a vector of OwnPtr<T>

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 337 matching lines @@
     // We animated if we either ticked a running animation, or started a new animation.
     if (hadActiveAnimation || startedAnimation)
         didAnimate = true;
 
     // If the current controller still has an active animation, we must continue animating layers.
     if (currentController->hasActiveAnimation())
          subtreeNeedsAnimateLayers = true;
 
     for (size_t i = 0; i < current->children().size(); ++i) {
         bool childNeedsAnimateLayers = false;
-        animateLayersRecursive(current->children()[i].get(), monotonicTime, wallClockTime, events, didAnimate, childNeedsAnimateLayers);
+        animateLayersRecursive(current->children()[i], monotonicTime, wallClockTime, events, didAnimate, childNeedsAnimateLayers);
         if (childNeedsAnimateLayers)
             subtreeNeedsAnimateLayers = true;
     }
 
     needsAnimateLayers = subtreeNeedsAnimateLayers;
 }
 
 void CCLayerTreeHostImpl::setBackgroundTickingEnabled(bool enabled)
 {
     // Lazily create the timeSource adapter so that we can vary the interval for testing.
@@ skipping 32 matching lines @@
     if (removeIndex == notFound)
         return;
 
     const CCRenderPass* removedPass = frame.renderPasses[removeIndex];
     frame.renderPasses.remove(removeIndex);
 
     // 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).get();
+        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);
 
     bool renderPassAlreadyRemoved = passIndex == notFound;
     if (renderPassAlreadyRemoved)
         return false;
 
     // If any quad or RenderPass draws into this RenderPass, then keep it.
     const CCQuadList& quadList = frame.renderPasses[passIndex]->quadList();
     for (CCQuadList::constBackToFrontIterator quadListIterator = quadList.backToFrontBegin(); quadListIterator != quadList.backToFrontEnd(); ++quadListIterator) {
-        CCDrawQuad* currentQuad = quadListIterator->get();
+        CCDrawQuad* currentQuad = *quadListIterator;
 
         if (currentQuad->material() != CCDrawQuad::RenderPass)
             return false;
 
         const CCRenderPass* contributingPass = findRenderPassById(CCRenderPassDrawQuad::materialCast(currentQuad)->renderPassId(), frame);
         if (frame.renderPasses.contains(contributingPass))
             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
 template<typename RenderPassCuller>
 void CCLayerTreeHostImpl::removeRenderPasses(RenderPassCuller culler, FrameData& frame)
 {
     for (size_t it = culler.renderPassListBegin(frame.renderPasses); it != culler.renderPassListEnd(frame.renderPasses); it = culler.renderPassListNext(it)) {
         const CCRenderPass* currentPass = frame.renderPasses[it];
         const CCQuadList& quadList = currentPass->quadList();
         CCQuadList::constBackToFrontIterator quadListIterator = quadList.backToFrontBegin();
 
         for (; quadListIterator != quadList.backToFrontEnd(); ++quadListIterator) {
-            CCDrawQuad* currentQuad = quadListIterator->get();
+            CCDrawQuad* currentQuad = *quadListIterator;
 
             if (currentQuad->material() != CCDrawQuad::RenderPass)
                 continue;
 
             CCRenderPassDrawQuad* renderPassQuad = static_cast<CCRenderPassDrawQuad*>(currentQuad);
             if (!culler.shouldRemoveRenderPass(*renderPassQuad, frame))
                 continue;
 
             // We are changing the vector in the middle of iteration. Because we
             // delete render passes that draw into the current pass, we are
@@ skipping 131 matching lines @@
 
 static CCLayerImpl* findRootScrollLayer(CCLayerImpl* layer)
 {
     if (!layer)
         return 0;
 
     if (layer->scrollable())
         return layer;
 
     for (size_t i = 0; i < layer->children().size(); ++i) {
-        CCLayerImpl* found = findRootScrollLayer(layer->children()[i].get());
+        CCLayerImpl* found = findRootScrollLayer(layer->children()[i]);
         if (found)
             return found;
     }
 
     return 0;
 }
 
 // Content layers can be either directly scrollable or contained in an outer
 // scrolling layer which applies the scroll transform. Given a content layer,
 // this function returns the associated scroll layer if any.
@@ skipping 124 matching lines @@
         return;
 
     if (layerImpl->scrollable()) {
         // We need to convert impl-side scroll deltas to pageScale space.
         FloatSize scrollDelta = layerImpl->scrollDelta();
         scrollDelta.scale(pageScaleChange);
         layerImpl->setScrollDelta(scrollDelta);
     }
 
     for (size_t i = 0; i < layerImpl->children().size(); ++i)
-        adjustScrollsForPageScaleChange(layerImpl->children()[i].get(), pageScaleChange);
+        adjustScrollsForPageScaleChange(layerImpl->children()[i], pageScaleChange);
 }
 
 void CCLayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor)
 {
     if (deviceScaleFactor == m_deviceScaleFactor)
         return;
     m_deviceScaleFactor = deviceScaleFactor;
 
     updateMaxScrollPosition();
 }
@@ skipping 350 matching lines @@
     if (!layerImpl->scrollDelta().isZero()) {
         IntSize scrollDelta = flooredIntSize(layerImpl->scrollDelta());
         CCLayerTreeHostCommon::ScrollUpdateInfo scroll;
         scroll.layerId = layerImpl->id();
         scroll.scrollDelta = scrollDelta;
         scrollInfo->scrolls.append(scroll);
         layerImpl->setSentScrollDelta(scrollDelta);
     }
 
     for (size_t i = 0; i < layerImpl->children().size(); ++i)
-        collectScrollDeltas(scrollInfo, layerImpl->children()[i].get());
+        collectScrollDeltas(scrollInfo, layerImpl->children()[i]);
 }
 
 PassOwnPtr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas()
 {
     OwnPtr<CCScrollAndScaleSet> scrollInfo = adoptPtr(new CCScrollAndScaleSet());
 
     if (m_pinchGestureActive || m_pageScaleAnimation) {
         m_sentPageScaleDelta = scrollInfo->pageScaleDelta = 1;
         if (m_pinchGestureActive)
             computePinchZoomDeltas(scrollInfo.get());
@@ skipping 64 matching lines @@
 
 void CCLayerTreeHostImpl::sendDidLoseContextRecursive(CCLayerImpl* current)
 {
     ASSERT(current);
     current->didLoseContext();
     if (current->maskLayer())
         sendDidLoseContextRecursive(current->maskLayer());
     if (current->replicaLayer())
         sendDidLoseContextRecursive(current->replicaLayer());
     for (size_t i = 0; i < current->children().size(); ++i)
-        sendDidLoseContextRecursive(current->children()[i].get());
+        sendDidLoseContextRecursive(current->children()[i]);
 }
 
 static void clearRenderSurfacesOnCCLayerImplRecursive(CCLayerImpl* current)
 {
     ASSERT(current);
     for (size_t i = 0; i < current->children().size(); ++i)
-        clearRenderSurfacesOnCCLayerImplRecursive(current->children()[i].get());
+        clearRenderSurfacesOnCCLayerImplRecursive(current->children()[i]);
     current->clearRenderSurface();
 }
 
 void CCLayerTreeHostImpl::clearRenderSurfaces()
 {
     clearRenderSurfacesOnCCLayerImplRecursive(m_rootLayerImpl.get());
     m_renderSurfaceLayerList.clear();
 }
 
 std::string CCLayerTreeHostImpl::layerTreeAsText() const
 {
     std::string str;
     if (m_rootLayerImpl) {
         str = m_rootLayerImpl->layerTreeAsText();
         str +=  "RenderSurfaces:\n";
         dumpRenderSurfaces(&str, 1, m_rootLayerImpl.get());
     }
     return str;
 }
 
 void CCLayerTreeHostImpl::dumpRenderSurfaces(std::string* str, int indent, const CCLayerImpl* layer) const
 {
     if (layer->renderSurface())
         layer->renderSurface()->dumpSurface(str, indent);
 
     for (size_t i = 0; i < layer->children().size(); ++i)
-        dumpRenderSurfaces(str, indent, layer->children()[i].get());
+        dumpRenderSurfaces(str, indent, layer->children()[i]);
 }
 
 int CCLayerTreeHostImpl::sourceAnimationFrameNumber() const
 {
     return fpsCounter()->currentFrameNumber();
 }
 
 void CCLayerTreeHostImpl::renderingStats(CCRenderingStats& stats) const
 {
     stats.numFramesSentToScreen = fpsCounter()->currentFrameNumber();
     stats.droppedFrameCount = fpsCounter()->droppedFrameCount();
 }
 
 void CCLayerTreeHostImpl::animateScrollbars(double monotonicTime)
 {
     animateScrollbarsRecursive(m_rootLayerImpl.get(), monotonicTime);
 }
 
 void CCLayerTreeHostImpl::animateScrollbarsRecursive(CCLayerImpl* layer, double monotonicTime)
 {
     if (!layer)
         return;
 
     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].get(), monotonicTime);
+        animateScrollbarsRecursive(layer->children()[i], monotonicTime);
 }
 
 } // namespace cc