A speculative Revert for r165872 - Remove static thread pointers from CC, attempt 2

cc/tiled_layer_impl_unittest.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 "config.h"
 
 #include "cc/tiled_layer_impl.h"
 
 #include "cc/append_quads_data.h"
 #include "cc/layer_tiling_data.h"
@@ skipping 28 matching lines @@
     ResourceProvider::ResourceId resourceId = 1;
     for (int i = 0; i < tiler->numTilesX(); ++i)
         for (int j = 0; j < tiler->numTilesY(); ++j)
             layer->pushTileProperties(i, j, resourceId++, gfx::Rect(0, 0, 1, 1), false);
 
     return layer.Pass();
 }
 
 TEST(TiledLayerImplTest, emptyQuadList)
 {
+    DebugScopedSetImplThread scopedImplThread;
+
     const gfx::Size tileSize(90, 90);
     const int numTilesX = 8;
     const int numTilesY = 4;
     const gfx::Size layerSize(tileSize.width() * numTilesX, tileSize.height() * numTilesY);
 
     // Verify default layer does creates quads
     {
         scoped_ptr<TiledLayerImpl> layer = createLayer(tileSize, layerSize, LayerTilingData::NoBorderTexels);
         MockQuadCuller quadCuller;
         AppendQuadsData data;
@@ skipping 33 matching lines @@
 
         MockQuadCuller quadCuller;
         AppendQuadsData data;
         layer->appendQuads(quadCuller, data);
         EXPECT_EQ(quadCuller.quadList().size(), 0u);
     }
 }
 
 TEST(TiledLayerImplTest, checkerboarding)
 {
+    DebugScopedSetImplThread scopedImplThread;
+
     const gfx::Size tileSize(10, 10);
     const int numTilesX = 2;
     const int numTilesY = 2;
     const gfx::Size layerSize(tileSize.width() * numTilesX, tileSize.height() * numTilesY);
 
     scoped_ptr<TiledLayerImpl> layer = createLayer(tileSize, layerSize, LayerTilingData::NoBorderTexels);
 
     // No checkerboarding
     {
         MockQuadCuller quadCuller;
@@ skipping 39 matching lines @@
     {                                                       \
         testFixtureName(LayerTilingData::NoBorderTexels); \
     }                                                       \
     TEST(TiledLayerImplTest, testFixtureName##HasBorders) \
     {                                                       \
         testFixtureName(LayerTilingData::HasBorderTexels);\
     }
 
 static void coverageVisibleRectOnTileBoundaries(LayerTilingData::BorderTexelOption borders)
 {
+    DebugScopedSetImplThread scopedImplThread;
+
     gfx::Size layerSize(1000, 1000);
     QuadList quads;
     SharedQuadStateList sharedStates;
     getQuads(quads, sharedStates, gfx::Size(100, 100), layerSize, borders, gfx::Rect(gfx::Point(), layerSize));
     verifyQuadsExactlyCoverRect(quads, gfx::Rect(gfx::Point(), layerSize));
 }
 WITH_AND_WITHOUT_BORDER_TEST(coverageVisibleRectOnTileBoundaries);
 
 static void coverageVisibleRectIntersectsTiles(LayerTilingData::BorderTexelOption borders)
 {
+    DebugScopedSetImplThread scopedImplThread;
+
     // This rect intersects the middle 3x3 of the 5x5 tiles.
     gfx::Point topLeft(65, 73);
     gfx::Point bottomRight(182, 198);
     gfx::Rect visibleContentRect = gfx::BoundingRect(topLeft, bottomRight);
 
     gfx::Size layerSize(250, 250);
     QuadList quads;
     SharedQuadStateList sharedStates;
     getQuads(quads, sharedStates, gfx::Size(50, 50), gfx::Size(250, 250), LayerTilingData::NoBorderTexels, visibleContentRect);
     verifyQuadsExactlyCoverRect(quads, visibleContentRect);
 }
 WITH_AND_WITHOUT_BORDER_TEST(coverageVisibleRectIntersectsTiles);
 
 static void coverageVisibleRectIntersectsBounds(LayerTilingData::BorderTexelOption borders)
 {
+    DebugScopedSetImplThread scopedImplThread;
+
     gfx::Size layerSize(220, 210);
     gfx::Rect visibleContentRect(gfx::Point(), layerSize);
     QuadList quads;
     SharedQuadStateList sharedStates;
     getQuads(quads, sharedStates, gfx::Size(100, 100), layerSize, LayerTilingData::NoBorderTexels, visibleContentRect);
     verifyQuadsExactlyCoverRect(quads, visibleContentRect);
 }
 WITH_AND_WITHOUT_BORDER_TEST(coverageVisibleRectIntersectsBounds);
 
 TEST(TiledLayerImplTest, textureInfoForLayerNoBorders)
 {
+    DebugScopedSetImplThread scopedImplThread;
+
     gfx::Size tileSize(50, 50);
     gfx::Size layerSize(250, 250);
     QuadList quads;
     SharedQuadStateList sharedStates;
     getQuads(quads, sharedStates, tileSize, layerSize, LayerTilingData::NoBorderTexels, gfx::Rect(gfx::Point(), layerSize));
 
     for (size_t i = 0; i < quads.size(); ++i) {
         ASSERT_EQ(quads[i]->material(), DrawQuad::TiledContent) << quadString << i;
         TileDrawQuad* quad = static_cast<TileDrawQuad*>(quads[i]);
 
         EXPECT_NE(quad->resourceId(), 0u) << quadString << i;
         EXPECT_EQ(quad->textureOffset(), gfx::Vector2d()) << quadString << i;
         EXPECT_EQ(quad->textureSize(), tileSize) << quadString << i;
         EXPECT_EQ(gfx::Rect(0, 0, 1, 1), quad->opaqueRect()) << quadString << i;
     }
 }
 
 TEST(TiledLayerImplTest, tileOpaqueRectForLayerNoBorders)
 {
+    DebugScopedSetImplThread scopedImplThread;
+
     gfx::Size tileSize(50, 50);
     gfx::Size layerSize(250, 250);
     QuadList quads;
     SharedQuadStateList sharedStates;
     getQuads(quads, sharedStates, tileSize, layerSize, LayerTilingData::NoBorderTexels, gfx::Rect(gfx::Point(), layerSize));
 
     for (size_t i = 0; i < quads.size(); ++i) {
         ASSERT_EQ(quads[i]->material(), DrawQuad::TiledContent) << quadString << i;
         TileDrawQuad* quad = static_cast<TileDrawQuad*>(quads[i]);
 
         EXPECT_EQ(gfx::Rect(0, 0, 1, 1), quad->opaqueRect()) << quadString << i;
     }
 }
 
 } // namespace