cc/CCOcclusionTrackerTest.cpp - Issue 11108020: [cc] Change cc_tests.gyp filenames to Chromium style

Unified Diff: cc/CCOcclusionTrackerTest.cpp

Issue 11108020: [cc] Change cc_tests.gyp filenames to Chromium style (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Rebase Created 8 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: cc/CCOcclusionTrackerTest.cpp

diff --git a/cc/CCOcclusionTrackerTest.cpp b/cc/CCOcclusionTrackerTest.cpp

deleted file mode 100644

index d3385a3aa35ac9e1b36e4411016a65cc1cb392bd..0000000000000000000000000000000000000000

--- a/cc/CCOcclusionTrackerTest.cpp

+++ /dev/null

@@ -1,3043 +0,0 @@

-// Use of this source code is governed by a BSD-style license that can be

-// found in the LICENSE file.

-#include "config.h"

-#include "CCOcclusionTracker.h"

-#include "CCAnimationTestCommon.h"

-#include "CCGeometryTestUtils.h"

-#include "CCLayerAnimationController.h"

-#include "CCLayerImpl.h"

-#include "CCLayerTreeHostCommon.h"

-#include "CCMathUtil.h"

-#include "CCOcclusionTrackerTestCommon.h"

-#include "CCOverdrawMetrics.h"

-#include "CCSingleThreadProxy.h"

-#include "LayerChromium.h"

-#include "Region.h"

-#include "testing/gmock/include/gmock/gmock.h"

-#include "testing/gtest/include/gtest/gtest.h"

-#include <public/WebFilterOperation.h>

-#include <public/WebFilterOperations.h>

-#include <public/WebTransformationMatrix.h>

-using namespace cc;

-using namespace WebKit;

-using namespace WebKitTests;

-namespace {

-class TestContentLayerChromium : public LayerChromium {

-public:

- TestContentLayerChromium()

- : LayerChromium()

- , m_overrideOpaqueContentsRect(false)

- {

- }

- virtual bool drawsContent() const OVERRIDE { return true; }

- virtual Region visibleContentOpaqueRegion() const OVERRIDE

- {

- if (m_overrideOpaqueContentsRect)

- return intersection(m_opaqueContentsRect, visibleContentRect());

- return LayerChromium::visibleContentOpaqueRegion();

- }

- void setOpaqueContentsRect(const IntRect& opaqueContentsRect)

- {

- m_overrideOpaqueContentsRect = true;

- m_opaqueContentsRect = opaqueContentsRect;

- }

-private:

- virtual ~TestContentLayerChromium()

- {

- }

- bool m_overrideOpaqueContentsRect;

- IntRect m_opaqueContentsRect;

-};

-class TestContentLayerImpl : public CCLayerImpl {

-public:

- TestContentLayerImpl(int id)

- : CCLayerImpl(id)

- , m_overrideOpaqueContentsRect(false)

- {

- setDrawsContent(true);

- }

- virtual Region visibleContentOpaqueRegion() const OVERRIDE

- {

- if (m_overrideOpaqueContentsRect)

- return intersection(m_opaqueContentsRect, visibleContentRect());

- return CCLayerImpl::visibleContentOpaqueRegion();

- }

- void setOpaqueContentsRect(const IntRect& opaqueContentsRect)

- {

- m_overrideOpaqueContentsRect = true;

- m_opaqueContentsRect = opaqueContentsRect;

- }

-private:

- bool m_overrideOpaqueContentsRect;

- IntRect m_opaqueContentsRect;

-};

-template<typename LayerType, typename RenderSurfaceType>

-class TestCCOcclusionTrackerWithClip : public TestCCOcclusionTrackerBase<LayerType, RenderSurfaceType> {

-public:

- TestCCOcclusionTrackerWithClip(IntRect viewportRect, bool recordMetricsForFrame = false)

- : TestCCOcclusionTrackerBase<LayerType, RenderSurfaceType>(viewportRect, recordMetricsForFrame)

- , m_overrideLayerClipRect(false)

- {

- }

- void setLayerClipRect(const IntRect& rect) { m_overrideLayerClipRect = true; m_layerClipRect = rect;}

- void useDefaultLayerClipRect() { m_overrideLayerClipRect = false; }

-protected:

- virtual IntRect layerClipRectInTarget(const LayerType* layer) const { return m_overrideLayerClipRect ? m_layerClipRect : CCOcclusionTrackerBase<LayerType, RenderSurfaceType>::layerClipRectInTarget(layer); }

-private:

- bool m_overrideLayerClipRect;

- IntRect m_layerClipRect;

-};

-struct CCOcclusionTrackerTestMainThreadTypes {

- typedef LayerChromium LayerType;

- typedef RenderSurfaceChromium RenderSurfaceType;

- typedef TestContentLayerChromium ContentLayerType;

- typedef scoped_refptr<LayerChromium> LayerPtrType;

- typedef scoped_refptr<ContentLayerType> ContentLayerPtrType;

- typedef CCLayerIterator<LayerChromium, std::vector<scoped_refptr<LayerChromium> >, RenderSurfaceChromium, CCLayerIteratorActions::FrontToBack> LayerIterator;

- typedef CCOcclusionTracker OcclusionTrackerType;

- static LayerPtrType createLayer()

- {

- return LayerChromium::create();

- }

- static ContentLayerPtrType createContentLayer() { return make_scoped_refptr(new ContentLayerType()); }

- static LayerPtrType passLayerPtr(ContentLayerPtrType& layer)

- {

- return layer.release();

- }

- static LayerPtrType passLayerPtr(LayerPtrType& layer)

- {

- return layer.release();

- }

- static void destroyLayer(LayerPtrType& layer)

- {

- layer = NULL;

- }

-};

-struct CCOcclusionTrackerTestImplThreadTypes {

- typedef CCLayerImpl LayerType;

- typedef CCRenderSurface RenderSurfaceType;

- typedef TestContentLayerImpl ContentLayerType;

- typedef scoped_ptr<CCLayerImpl> LayerPtrType;

- typedef scoped_ptr<ContentLayerType> ContentLayerPtrType;

- typedef CCLayerIterator<CCLayerImpl, std::vector<CCLayerImpl*>, CCRenderSurface, CCLayerIteratorActions::FrontToBack> LayerIterator;

- typedef CCOcclusionTrackerImpl OcclusionTrackerType;

- static LayerPtrType createLayer() { return CCLayerImpl::create(nextCCLayerImplId++); }

- static ContentLayerPtrType createContentLayer() { return make_scoped_ptr(new ContentLayerType(nextCCLayerImplId++)); }

- static int nextCCLayerImplId;

- static LayerPtrType passLayerPtr(LayerPtrType& layer)

- {

- return layer.Pass();

- }

- static LayerPtrType passLayerPtr(ContentLayerPtrType& layer)

- {

- return layer.PassAs<LayerType>();

- }

- static void destroyLayer(LayerPtrType& layer)

- {

- layer.reset();

- }

-};

-int CCOcclusionTrackerTestImplThreadTypes::nextCCLayerImplId = 1;

-template<typename Types, bool opaqueLayers>

-class CCOcclusionTrackerTest : public testing::Test {

-protected:

- CCOcclusionTrackerTest()

- : testing::Test()

- { }

- virtual void runMyTest() = 0;

- virtual void TearDown()

- {

- Types::destroyLayer(m_root);

- m_renderSurfaceLayerListChromium.clear();

- m_renderSurfaceLayerListImpl.clear();

- m_replicaLayers.clear();

- m_maskLayers.clear();

- CCLayerTreeHost::setNeedsFilterContext(false);

- }

- typename Types::ContentLayerType* createRoot(const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds)

- {

- typename Types::ContentLayerPtrType layer(Types::createContentLayer());

- typename Types::ContentLayerType* layerPtr = layer.get();

- setProperties(layerPtr, transform, position, bounds);

- ASSERT(!m_root);

- m_root = Types::passLayerPtr(layer);

- return layerPtr;

- }

- typename Types::LayerType* createLayer(typename Types::LayerType* parent, const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds)

- {

- typename Types::LayerPtrType layer(Types::createLayer());

- typename Types::LayerType* layerPtr = layer.get();

- setProperties(layerPtr, transform, position, bounds);

- parent->addChild(Types::passLayerPtr(layer));

- return layerPtr;

- }

- typename Types::LayerType* createSurface(typename Types::LayerType* parent, const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds)

- {

- typename Types::LayerType* layer = createLayer(parent, transform, position, bounds);

- WebFilterOperations filters;

- filters.append(WebFilterOperation::createGrayscaleFilter(0.5));

- layer->setFilters(filters);

- return layer;

- }

- typename Types::ContentLayerType* createDrawingLayer(typename Types::LayerType* parent, const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds, bool opaque)

- {

- typename Types::ContentLayerPtrType layer(Types::createContentLayer());

- typename Types::ContentLayerType* layerPtr = layer.get();

- setProperties(layerPtr, transform, position, bounds);

- if (opaqueLayers)

- layerPtr->setContentsOpaque(opaque);

- else {

- layerPtr->setContentsOpaque(false);

- if (opaque)

- layerPtr->setOpaqueContentsRect(IntRect(IntPoint(), bounds));

- else

- layerPtr->setOpaqueContentsRect(IntRect());

- }

- parent->addChild(Types::passLayerPtr(layer));

- return layerPtr;

- }

- typename Types::LayerType* createReplicaLayer(typename Types::LayerType* owningLayer, const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds)

- {

- typename Types::ContentLayerPtrType layer(Types::createContentLayer());

- typename Types::ContentLayerType* layerPtr = layer.get();

- setProperties(layerPtr, transform, position, bounds);

- setReplica(owningLayer, Types::passLayerPtr(layer));

- return layerPtr;

- }

- typename Types::LayerType* createMaskLayer(typename Types::LayerType* owningLayer, const IntSize& bounds)

- {

- typename Types::ContentLayerPtrType layer(Types::createContentLayer());

- typename Types::ContentLayerType* layerPtr = layer.get();

- setProperties(layerPtr, identityMatrix, FloatPoint(), bounds);

- setMask(owningLayer, Types::passLayerPtr(layer));

- return layerPtr;

- }

- typename Types::ContentLayerType* createDrawingSurface(typename Types::LayerType* parent, const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds, bool opaque)

- {

- typename Types::ContentLayerType* layer = createDrawingLayer(parent, transform, position, bounds, opaque);

- WebFilterOperations filters;

- filters.append(WebFilterOperation::createGrayscaleFilter(0.5));

- layer->setFilters(filters);

- return layer;

- }

- void calcDrawEtc(TestContentLayerImpl* root)

- {

- ASSERT(root == m_root.get());

- int dummyMaxTextureSize = 512;

- CCLayerSorter layerSorter;

- ASSERT(!root->renderSurface());

- CCLayerTreeHostCommon::calculateDrawTransforms(root, root->bounds(), 1, &layerSorter, dummyMaxTextureSize, m_renderSurfaceLayerListImpl);

- m_layerIterator = m_layerIteratorBegin = Types::LayerIterator::begin(&m_renderSurfaceLayerListImpl);

- }

- void calcDrawEtc(TestContentLayerChromium* root)

- {

- ASSERT(root == m_root.get());

- int dummyMaxTextureSize = 512;

- ASSERT(!root->renderSurface());

- CCLayerTreeHostCommon::calculateDrawTransforms(root, root->bounds(), 1, dummyMaxTextureSize, m_renderSurfaceLayerListChromium);

- m_layerIterator = m_layerIteratorBegin = Types::LayerIterator::begin(&m_renderSurfaceLayerListChromium);

- }

- void enterLayer(typename Types::LayerType* layer, typename Types::OcclusionTrackerType& occlusion)

- {

- ASSERT_EQ(layer, *m_layerIterator);

- ASSERT_TRUE(m_layerIterator.representsItself());

- occlusion.enterLayer(m_layerIterator);

- }

- void leaveLayer(typename Types::LayerType* layer, typename Types::OcclusionTrackerType& occlusion)

- {

- ASSERT_EQ(layer, *m_layerIterator);

- ASSERT_TRUE(m_layerIterator.representsItself());

- occlusion.leaveLayer(m_layerIterator);

- ++m_layerIterator;

- }

- void visitLayer(typename Types::LayerType* layer, typename Types::OcclusionTrackerType& occlusion)

- {

- enterLayer(layer, occlusion);

- leaveLayer(layer, occlusion);

- }

- void enterContributingSurface(typename Types::LayerType* layer, typename Types::OcclusionTrackerType& occlusion)

- {

- ASSERT_EQ(layer, *m_layerIterator);

- ASSERT_TRUE(m_layerIterator.representsTargetRenderSurface());

- occlusion.enterLayer(m_layerIterator);

- occlusion.leaveLayer(m_layerIterator);

- ++m_layerIterator;

- ASSERT_TRUE(m_layerIterator.representsContributingRenderSurface());

- occlusion.enterLayer(m_layerIterator);

- }

- void leaveContributingSurface(typename Types::LayerType* layer, typename Types::OcclusionTrackerType& occlusion)

- {

- ASSERT_EQ(layer, *m_layerIterator);

- ASSERT_TRUE(m_layerIterator.representsContributingRenderSurface());

- occlusion.leaveLayer(m_layerIterator);

- ++m_layerIterator;

- }

- void visitContributingSurface(typename Types::LayerType* layer, typename Types::OcclusionTrackerType& occlusion)

- {

- enterContributingSurface(layer, occlusion);

- leaveContributingSurface(layer, occlusion);

- }

- void resetLayerIterator()

- {

- m_layerIterator = m_layerIteratorBegin;

- }

- const WebTransformationMatrix identityMatrix;

-private:

- void setBaseProperties(typename Types::LayerType* layer, const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds)

- {

- layer->setTransform(transform);

- layer->setSublayerTransform(WebTransformationMatrix());

- layer->setAnchorPoint(FloatPoint(0, 0));

- layer->setPosition(position);

- layer->setBounds(bounds);

- }

- void setProperties(LayerChromium* layer, const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds)

- {

- setBaseProperties(layer, transform, position, bounds);

- }

- void setProperties(CCLayerImpl* layer, const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds)

- {

- setBaseProperties(layer, transform, position, bounds);

- layer->setContentBounds(layer->bounds());

- }

- void setReplica(LayerChromium* owningLayer, scoped_refptr<LayerChromium> layer)

- {

- owningLayer->setReplicaLayer(layer.get());

- m_replicaLayers.push_back(layer);

- }

- void setReplica(CCLayerImpl* owningLayer, scoped_ptr<CCLayerImpl> layer)

- {

- owningLayer->setReplicaLayer(layer.Pass());

- }

- void setMask(LayerChromium* owningLayer, scoped_refptr<LayerChromium> layer)

- {

- owningLayer->setMaskLayer(layer.get());

- m_maskLayers.push_back(layer);

- }

- void setMask(CCLayerImpl* owningLayer, scoped_ptr<CCLayerImpl> layer)

- {

- owningLayer->setMaskLayer(layer.Pass());

- }

- // These hold ownership of the layers for the duration of the test.

- typename Types::LayerPtrType m_root;

- std::vector<scoped_refptr<LayerChromium> > m_renderSurfaceLayerListChromium;

- std::vector<CCLayerImpl*> m_renderSurfaceLayerListImpl;

- typename Types::LayerIterator m_layerIteratorBegin;

- typename Types::LayerIterator m_layerIterator;

- typename Types::LayerType* m_lastLayerVisited;

- std::vector<scoped_refptr<LayerChromium> > m_replicaLayers;

- std::vector<scoped_refptr<LayerChromium> > m_maskLayers;

-};

-#define RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \

- class ClassName##MainThreadOpaqueLayers : public ClassName<CCOcclusionTrackerTestMainThreadTypes, true> { \

- public: \

- ClassName##MainThreadOpaqueLayers() : ClassName<CCOcclusionTrackerTestMainThreadTypes, true>() { } \

- }; \

- TEST_F(ClassName##MainThreadOpaqueLayers, runTest) { runMyTest(); }

-#define RUN_TEST_MAIN_THREAD_OPAQUE_PAINTS(ClassName) \

- class ClassName##MainThreadOpaquePaints : public ClassName<CCOcclusionTrackerTestMainThreadTypes, false> { \

- public: \

- ClassName##MainThreadOpaquePaints() : ClassName<CCOcclusionTrackerTestMainThreadTypes, false>() { } \

- }; \

- TEST_F(ClassName##MainThreadOpaquePaints, runTest) { runMyTest(); }

-#define RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName) \

- class ClassName##ImplThreadOpaqueLayers : public ClassName<CCOcclusionTrackerTestImplThreadTypes, true> { \

- DebugScopedSetImplThread impl; \

- public: \

- ClassName##ImplThreadOpaqueLayers() : ClassName<CCOcclusionTrackerTestImplThreadTypes, true>() { } \

- }; \

- TEST_F(ClassName##ImplThreadOpaqueLayers, runTest) { runMyTest(); }

-#define RUN_TEST_IMPL_THREAD_OPAQUE_PAINTS(ClassName) \

- class ClassName##ImplThreadOpaquePaints : public ClassName<CCOcclusionTrackerTestImplThreadTypes, false> { \

- DebugScopedSetImplThread impl; \

- public: \

- ClassName##ImplThreadOpaquePaints() : ClassName<CCOcclusionTrackerTestImplThreadTypes, false>() { } \

- }; \

- TEST_F(ClassName##ImplThreadOpaquePaints, runTest) { runMyTest(); }

-#define ALL_CCOCCLUSIONTRACKER_TEST(ClassName) \

- RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \

- RUN_TEST_MAIN_THREAD_OPAQUE_PAINTS(ClassName) \

- RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName) \

- RUN_TEST_IMPL_THREAD_OPAQUE_PAINTS(ClassName)

-#define MAIN_THREAD_TEST(ClassName) \

- RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName)

-#define IMPL_THREAD_TEST(ClassName) \

- RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName)

-#define MAIN_AND_IMPL_THREAD_TEST(ClassName) \

- RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \

- RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName)

-template<class Types, bool opaqueLayers>

-class CCOcclusionTrackerTestIdentityTransforms : public CCOcclusionTrackerTest<Types, opaqueLayers> {

-protected:

- void runMyTest()

- {

- typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, FloatPoint(0, 0), IntSize(100, 100));

- typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, this->identityMatrix, FloatPoint(30, 30), IntSize(500, 500), true);

- this->calcDrawEtc(parent);

- TestCCOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(IntRect(0, 0, 1000, 1000));

- occlusion.setLayerClipRect(IntRect(0, 0, 1000, 1000));

- this->visitLayer(layer, occlusion);

- this->enterLayer(parent, occlusion);

- EXPECT_RECT_EQ(IntRect(30, 30, 70, 70), occlusion.occlusionInScreenSpace().bounds());

- EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size());

- EXPECT_RECT_EQ(IntRect(30, 30, 70, 70), occlusion.occlusionInTargetSurface().bounds());

- EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size());

- EXPECT_TRUE(occlusion.occluded(parent, IntRect(30, 30, 70, 70)));

- EXPECT_FALSE(occlusion.occluded(parent, IntRect(29, 30, 70, 70)));

- EXPECT_FALSE(occlusion.occluded(parent, IntRect(30, 29, 70, 70)));

- EXPECT_FALSE(occlusion.occluded(parent, IntRect(31, 30, 70, 70)));

- EXPECT_FALSE(occlusion.occluded(parent, IntRect(30, 31, 70, 70)));

- occlusion.useDefaultLayerClipRect();

- EXPECT_TRUE(occlusion.occluded(parent, IntRect(30, 30, 70, 70)));

- EXPECT_FALSE(occlusion.occluded(parent, IntRect(29, 30, 70, 70)));

- EXPECT_FALSE(occlusion.occluded(parent, IntRect(30, 29, 70, 70)));

- EXPECT_TRUE(occlusion.occluded(parent, IntRect(31, 30, 70, 70)));

- EXPECT_TRUE(occlusion.occluded(parent, IntRect(30, 31, 70, 70)));

- occlusion.setLayerClipRect(IntRect(0, 0, 1000, 1000));

- EXPECT_TRUE(occlusion.unoccludedContentRect(parent, IntRect(30, 30, 70, 70)).isEmpty());

- EXPECT_RECT_EQ(IntRect(29, 30, 1, 70), occlusion.unoccludedContentRect(parent, IntRect(29, 30, 70, 70)));

- EXPECT_RECT_EQ(IntRect(29, 29, 70, 70), occlusion.unoccludedContentRect(parent, IntRect(29, 29, 70, 70)));

- EXPECT_RECT_EQ(IntRect(30, 29, 70, 1), occlusion.unoccludedContentRect(parent, IntRect(30, 29, 70, 70)));

- EXPECT_RECT_EQ(IntRect(31, 29, 70, 70), occlusion.unoccludedContentRect(parent, IntRect(31, 29, 70, 70)));

- EXPECT_RECT_EQ(IntRect(100, 30, 1, 70), occlusion.unoccludedContentRect(parent, IntRect(31, 30, 70, 70)));

- EXPECT_RECT_EQ(IntRect(31, 31, 70, 70), occlusion.unoccludedContentRect(parent, IntRect(31, 31, 70, 70)));

- EXPECT_RECT_EQ(IntRect(30, 100, 70, 1), occlusion.unoccludedContentRect(parent, IntRect(30, 31, 70, 70)));

- EXPECT_RECT_EQ(IntRect(29, 31, 70, 70), occlusion.unoccludedContentRect(parent, IntRect(29, 31, 70, 70)));

- }

-};

-ALL_CCOCCLUSIONTRACKER_TEST(CCOcclusionTrackerTestIdentityTransforms);

-template<class Types, bool opaqueLayers>

-class CCOcclusionTrackerTestRotatedChild : public CCOcclusionTrackerTest<Types, opaqueLayers> {

-protected:

- void runMyTest()

- {

- WebTransformationMatrix layerTransform;

- layerTransform.translate(250, 250);

- layerTransform.rotate(90);

- layerTransform.translate(-250, -250);

- typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, FloatPoint(0, 0), IntSize(100, 100));

- typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, layerTransform, FloatPoint(30, 30), IntSize(500, 500), true);