Change cc files from namespace WebCore to cc

cc/CCOcclusionTracker.cpp

 // 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"
 
 #if USE(ACCELERATED_COMPOSITING)
 
 #include "CCOcclusionTracker.h"
 
 #include "CCLayerImpl.h"
 #include "CCMathUtil.h"
 #include "CCOverdrawMetrics.h"
 #include "LayerChromium.h"
 #include <algorithm>
 
 using namespace std;
 using WebKit::WebTransformationMatrix;
 
-namespace WebCore {
+namespace cc {
 
 template<typename LayerType, typename RenderSurfaceType>
 CCOcclusionTrackerBase<LayerType, RenderSurfaceType>::CCOcclusionTrackerBase(IntRect rootTargetRect, bool recordMetricsForFrame)
     : m_rootTargetRect(rootTargetRect)
     , m_overdrawMetrics(CCOverdrawMetrics::create(recordMetricsForFrame))
     , m_occludingScreenSpaceRects(0)
 {
 }
 
 template<typename LayerType, typename RenderSurfaceType>
@@ skipping 89 matching lines @@
     // apply |transform| to each rect within |region| in order to transform the entire Region.
 
     bool clipped;
     FloatQuad transformedBoundsQuad = CCMathUtil::mapQuad(transform, FloatQuad(region.bounds()), clipped);
     // FIXME: Find a rect interior to each transformed quad.
     if (clipped || !transformedBoundsQuad.isRectilinear())
         return Region();
 
     Region transformedRegion;
 
-    Vector<IntRect> rects = region.rects();
+    Vector<WebCore::IntRect> rects = region.rects();
     for (size_t i = 0; i < rects.size(); ++i) {
         // We've already checked for clipping in the mapQuad call above, these calls should not clip anything further.
         IntRect transformedRect = enclosedIntRect(CCMathUtil::mapClippedRect(transform, FloatRect(rects[i])));
         if (!surface->clipRect().isEmpty())
             transformedRect.intersect(surface->clipRect());
         transformedRegion.unite(transformedRect);
     }
     return transformedRegion;
 }
 
 static inline void reduceOcclusion(const IntRect& affectedArea, const IntRect& expandedPixel, Region& occlusion)
 {
     if (affectedArea.isEmpty())
         return;
 
     Region affectedOcclusion = intersect(occlusion, affectedArea);
-    Vector<IntRect> affectedOcclusionRects = affectedOcclusion.rects();
+    Vector<WebCore::IntRect> affectedOcclusionRects = affectedOcclusion.rects();
 
     occlusion.subtract(affectedArea);
     for (size_t j = 0; j < affectedOcclusionRects.size(); ++j) {
-        IntRect& occlusionRect = affectedOcclusionRects[j];
+        WebCore::IntRect& occlusionRect = affectedOcclusionRects[j];
 
         // Shrink the rect by expanding the non-opaque pixels outside the rect.
 
         // The expandedPixel is the IntRect for a single pixel after being
         // expanded by filters on the layer. The original pixel would be
         // IntRect(0, 0, 1, 1), and the expanded pixel is the rect, relative
         // to this original rect, that the original pixel can influence after
         // being filtered.
         // To convert the expandedPixel IntRect back to filter outsets:
         // x = -leftOutset
@@ skipping 86 matching lines @@
 static inline void addOcclusionBehindLayer(Region& region, const LayerType* layer, const WebTransformationMatrix& transform, const Region& opaqueContents, const IntRect& clipRectInTarget, const IntSize& minimumTrackingSize, Vector<IntRect>* occludingScreenSpaceRects)
 {
     ASSERT(layer->visibleContentRect().contains(opaqueContents.bounds()));
 
     bool clipped;
     FloatQuad visibleTransformedQuad = CCMathUtil::mapQuad(transform, FloatQuad(layer->visibleContentRect()), clipped);
     // FIXME: Find a rect interior to each transformed quad.
     if (clipped || !visibleTransformedQuad.isRectilinear())
         return;
 
-    Vector<IntRect> contentRects = opaqueContents.rects();
+    Vector<WebCore::IntRect> contentRects = opaqueContents.rects();
     for (size_t i = 0; i < contentRects.size(); ++i) {
         // We've already checked for clipping in the mapQuad call above, these calls should not clip anything further.
         IntRect transformedRect = enclosedIntRect(CCMathUtil::mapClippedRect(transform, FloatRect(contentRects[i])));
         transformedRect.intersect(clipRectInTarget);
         if (transformedRect.width() >= minimumTrackingSize.width() || transformedRect.height() >= minimumTrackingSize.height()) {
             if (occludingScreenSpaceRects)
                 occludingScreenSpaceRects->append(transformedRect);
             region.unite(transformedRect);
         }
     }
@@ skipping 202 matching lines @@
 template void CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::enterRenderTarget(const CCLayerImpl* newTarget);
 template void CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::finishedRenderTarget(const CCLayerImpl* finishedTarget);
 template void CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::leaveToRenderTarget(const CCLayerImpl* newTarget);
 template void CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::markOccludedBehindLayer(const CCLayerImpl*);
 template bool CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::occluded(const CCLayerImpl*, const IntRect& contentRect, bool* hasOcclusionFromOutsideTargetSurface) const;
 template IntRect CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::unoccludedContentRect(const CCLayerImpl*, const IntRect& contentRect, bool* hasOcclusionFromOutsideTargetSurface) const;
 template IntRect CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::unoccludedContributingSurfaceContentRect(const CCLayerImpl*, bool forReplica, const IntRect& contentRect, bool* hasOcclusionFromOutsideTargetSurface) const;
 template IntRect CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::layerClipRectInTarget(const CCLayerImpl*) const;
 
 
-} // namespace WebCore
+} // namespace cc
 #endif // USE(ACCELERATED_COMPOSITING)