Rename cc::ResourceProvider::ResourceId to cc::ResourceId and move it to its own file.

cc/layers/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 "cc/layers/tiled_layer_impl.h"
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/layer_tiling_data.h"
 #include "cc/test/fake_impl_proxy.h"
@@ skipping 40 matching lines @@
   // visibility of the entire layer size.
   scoped_ptr<TiledLayerImpl> CreateLayer(
       const gfx::Size& tile_size,
       const gfx::Size& layer_size,
       LayerTilingData::BorderTexelOption border_texels) {
     scoped_ptr<TiledLayerImpl> layer =
         CreateLayerNoTiles(tile_size, layer_size, border_texels);
 
     for (int i = 0; i < layer->TilingForTesting()->num_tiles_x(); ++i) {
       for (int j = 0; j < layer->TilingForTesting()->num_tiles_y(); ++j) {
-        ResourceProvider::ResourceId resource_id =
-            host_impl_.resource_provider()->CreateResource(
-                gfx::Size(1, 1), GL_CLAMP_TO_EDGE,
-                ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
+        ResourceId resource_id = host_impl_.resource_provider()->CreateResource(
+            gfx::Size(1, 1), GL_CLAMP_TO_EDGE,
+            ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
         layer->PushTileProperties(i, j, resource_id, false);
       }
     }
 
     return layer.Pass();
   }
 
   void GetQuads(RenderPass* render_pass,
                 const gfx::Size& tile_size,
                 const gfx::Size& layer_size,
@@ skipping 209 matching lines @@
   int num_tiles_x = 12;
   int num_tiles_y = 32;
   gfx::Size layer_size(tile_size.width() * num_tiles_x,
                        tile_size.height() * num_tiles_y);
 
   scoped_ptr<TiledLayerImpl> layer = CreateLayerNoTiles(
       tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
 
   EXPECT_EQ(layer->GPUMemoryUsageInBytes(), 0u);
 
-  ResourceProvider::ResourceId resource_id = 1;
+  ResourceId resource_id = 1;
   layer->PushTileProperties(0, 1, resource_id++, false);
   layer->PushTileProperties(2, 3, resource_id++, false);
   layer->PushTileProperties(2, 0, resource_id++, false);
 
   EXPECT_EQ(
       layer->GPUMemoryUsageInBytes(),
       static_cast<size_t>(3 * 4 * tile_size.width() * tile_size.height()));
 
-  ResourceProvider::ResourceId empty_resource(0);
+  ResourceId empty_resource(0);
   layer->PushTileProperties(0, 1, empty_resource, false);
   layer->PushTileProperties(2, 3, empty_resource, false);
   layer->PushTileProperties(2, 0, empty_resource, false);
 
   EXPECT_EQ(layer->GPUMemoryUsageInBytes(), 0u);
 }
 
 TEST_F(TiledLayerImplTest, EmptyMask) {
   gfx::Size tile_size(20, 20);
   gfx::Size layer_size(0, 0);
   scoped_ptr<TiledLayerImpl> layer =
       CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
 
-  ResourceProvider::ResourceId mask_resource_id;
+  ResourceId mask_resource_id;
   gfx::Size mask_texture_size;
   layer->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
   EXPECT_EQ(0u, mask_resource_id);
   EXPECT_EQ(0, layer->TilingForTesting()->num_tiles_x());
   EXPECT_EQ(0, layer->TilingForTesting()->num_tiles_y());
 }
 
 TEST_F(TiledLayerImplTest, Occlusion) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
   gfx::Size viewport_size(1000, 1000);
 
   LayerTestCommon::LayerImplTest impl;
 
   TiledLayerImpl* tiled_layer = impl.AddChildToRoot<TiledLayerImpl>();
   tiled_layer->SetBounds(layer_bounds);
   tiled_layer->SetContentBounds(layer_bounds);
   tiled_layer->SetDrawsContent(true);
   tiled_layer->set_skips_draw(false);
 
   scoped_ptr<LayerTilingData> tiler =
       LayerTilingData::Create(tile_size, LayerTilingData::NO_BORDER_TEXELS);
   tiler->SetTilingSize(layer_bounds);
   tiled_layer->SetTilingData(*tiler);
 
   for (int i = 0; i < tiled_layer->TilingForTesting()->num_tiles_x(); ++i) {
     for (int j = 0; j < tiled_layer->TilingForTesting()->num_tiles_y(); ++j) {
-      ResourceProvider::ResourceId resource_id =
-          impl.resource_provider()->CreateResource(
-              gfx::Size(1, 1), GL_CLAMP_TO_EDGE,
-              ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
+      ResourceId resource_id = impl.resource_provider()->CreateResource(
+          gfx::Size(1, 1), GL_CLAMP_TO_EDGE,
+          ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
       tiled_layer->PushTileProperties(i, j, resource_id, false);
     }
   }
 
   impl.CalcDrawProps(viewport_size);
 
   {
     SCOPED_TRACE("No occlusion");
     gfx::Rect occluded;
     impl.AppendQuadsWithOcclusion(tiled_layer, occluded);
@@ skipping 21 matching lines @@
     LayerTestCommon::VerifyQuadsAreOccluded(
         impl.quad_list(), occluded, &partially_occluded_count);
     // The layer outputs one quad, which is partially occluded.
     EXPECT_EQ(100u - 10u, impl.quad_list().size());
     EXPECT_EQ(10u + 10u, partially_occluded_count);
   }
 }
 
 }  // namespace
 }  // namespace cc