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

This allows files like surface_resource_holder.h and transferable_resource.h to depend on the typedef without depending on resource_provider.h

Review URL: https://codereview.chromium.org/1144523003

Cr-Commit-Position: refs/heads/master@{#330459}

63 files changed, 400 insertions, 450 deletions

diff --git a/cc/base/BUILD.gn b/cc/base/BUILD.gn
index e41c74f..4f210eb 100644
--- a/cc/base/BUILD.gn
+++ b/cc/base/BUILD.gn
@@ -15,6 +15,7 @@ source_set("base") {
     "math_util.h",
     "region.cc",
     "region.h",
+    "resource_id.h",
     "rolling_time_delta_history.cc",
     "rolling_time_delta_history.h",
     "scoped_ptr_algorithm.h",
diff --git a/cc/base/resource_id.h b/cc/base/resource_id.h
new file mode 100644
index 0000000..84d00ad
--- /dev/null
+++ b/cc/base/resource_id.h
@@ -0,0 +1,16 @@
+// Copyright 2015 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.
+
+#ifndef CC_BASE_RESOURCE_ID_H_
+#define CC_BASE_RESOURCE_ID_H_
+
+#include <stdint.h>
+
+namespace cc {
+
+using ResourceId = uint32_t;
+
+}  // namespace cc
+
+#endif  // CC_BASE_RESOURCE_ID_H_
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 2a4d66a..9cc68f9 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -74,6 +74,7 @@
         'base/math_util.h',
         'base/region.cc',
         'base/region.h',
+        'base/resource_id.h',
         'base/rolling_time_delta_history.cc',
         'base/rolling_time_delta_history.h',
         'base/scoped_ptr_algorithm.h',
diff --git a/cc/layers/delegated_frame_provider_unittest.cc b/cc/layers/delegated_frame_provider_unittest.cc
index fe8117e..b54b9d4 100644
--- a/cc/layers/delegated_frame_provider_unittest.cc
+++ b/cc/layers/delegated_frame_provider_unittest.cc
@@ -35,15 +35,14 @@ class DelegatedFrameProviderTest
   }
 
   void AddTransferableResource(DelegatedFrameData* frame,
-                               ResourceProvider::ResourceId resource_id) {
+                               ResourceId resource_id) {
     TransferableResource resource;
     resource.id = resource_id;
     resource.mailbox_holder.texture_target = GL_TEXTURE_2D;
     frame->resource_list.push_back(resource);
   }
 
-  void AddTextureQuad(DelegatedFrameData* frame,
-                      ResourceProvider::ResourceId resource_id) {
+  void AddTextureQuad(DelegatedFrameData* frame, ResourceId resource_id) {
     SharedQuadState* sqs =
         frame->render_pass_list[0]->CreateAndAppendSharedQuadState();
     TextureDrawQuad* quad =
diff --git a/cc/layers/delegated_renderer_layer_impl.cc b/cc/layers/delegated_renderer_layer_impl.cc
index a99cd17..5b6bc6c 100644
--- a/cc/layers/delegated_renderer_layer_impl.cc
+++ b/cc/layers/delegated_renderer_layer_impl.cc
@@ -44,11 +44,11 @@ bool DelegatedRendererLayerImpl::HasContributingDelegatedRenderPasses() const {
   return render_passes_in_draw_order_.size() > 1;
 }
 
-static ResourceProvider::ResourceId ResourceRemapHelper(
+static ResourceId ResourceRemapHelper(
     bool* invalid_frame,
     const ResourceProvider::ResourceIdMap& child_to_parent_map,
     ResourceProvider::ResourceIdSet* resources_in_frame,
-    ResourceProvider::ResourceId id) {
+    ResourceId id) {
   ResourceProvider::ResourceIdMap::const_iterator it =
       child_to_parent_map.find(id);
   if (it == child_to_parent_map.end()) {
@@ -57,7 +57,7 @@ static ResourceProvider::ResourceId ResourceRemapHelper(
   }
 
   DCHECK_EQ(it->first, id);
-  ResourceProvider::ResourceId remapped_id = it->second;
+  ResourceId remapped_id = it->second;
   resources_in_frame->insert(id);
   return remapped_id;
 }
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index f0d54ff..88885f0 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -379,7 +379,7 @@ RenderPassId LayerImpl::NextContributingRenderPassId(RenderPassId id) const {
   return RenderPassId(0, 0);
 }
 
-void LayerImpl::GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
+void LayerImpl::GetContentsResourceId(ResourceId* resource_id,
                                       gfx::Size* resource_size) const {
   NOTREACHED();
   *resource_id = 0;
@@ -749,9 +749,8 @@ void LayerImpl::NoteLayerPropertyChangedForDescendants() {
 
 #if DCHECK_IS_ON()
 // Verify that the resource id is valid.
-static ResourceProvider::ResourceId ValidateResource(
-    const ResourceProvider* provider,
-    ResourceProvider::ResourceId id) {
+static ResourceId ValidateResource(const ResourceProvider* provider,
+                                   ResourceId id) {
   provider->ValidateResource(id);
   return id;
 }
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 84bff48..9a089a5 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -255,7 +255,7 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
 #endif
   }
 
-  virtual void GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
+  virtual void GetContentsResourceId(ResourceId* resource_id,
                                      gfx::Size* resource_size) const;
 
   virtual bool HasDelegatedContent() const;
diff --git a/cc/layers/nine_patch_layer_impl.cc b/cc/layers/nine_patch_layer_impl.cc
index fc2f457..117056a 100644
--- a/cc/layers/nine_patch_layer_impl.cc
+++ b/cc/layers/nine_patch_layer_impl.cc
@@ -94,7 +94,7 @@ void NinePatchLayerImpl::AppendQuads(
   if (!ui_resource_id_)
     return;
 
-  ResourceProvider::ResourceId resource =
+  ResourceId resource =
       layer_tree_impl()->ResourceIdForUIResource(ui_resource_id_);
 
   if (!resource)
diff --git a/cc/layers/painted_scrollbar_layer_impl.cc b/cc/layers/painted_scrollbar_layer_impl.cc
index 005e087..7cbe36e 100644
--- a/cc/layers/painted_scrollbar_layer_impl.cc
+++ b/cc/layers/painted_scrollbar_layer_impl.cc
@@ -95,9 +95,9 @@ void PaintedScrollbarLayerImpl::AppendQuads(
   gfx::Rect scaled_visible_thumb_quad_rect = gfx::ScaleToEnclosingRect(
       visible_thumb_quad_rect, internal_contents_scale_);
 
-  ResourceProvider::ResourceId thumb_resource_id =
+  ResourceId thumb_resource_id =
       layer_tree_impl()->ResourceIdForUIResource(thumb_ui_resource_id_);
-  ResourceProvider::ResourceId track_resource_id =
+  ResourceId track_resource_id =
       layer_tree_impl()->ResourceIdForUIResource(track_ui_resource_id_);
 
   if (thumb_resource_id && !visible_thumb_quad_rect.IsEmpty()) {
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 1101440..5c93622 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -746,9 +746,8 @@ gfx::Size PictureLayerImpl::CalculateTileSize(
   return gfx::Size(tile_width, tile_height);
 }
 
-void PictureLayerImpl::GetContentsResourceId(
-    ResourceProvider::ResourceId* resource_id,
-    gfx::Size* resource_size) const {
+void PictureLayerImpl::GetContentsResourceId(ResourceId* resource_id,
+                                             gfx::Size* resource_size) const {
   // The bounds and the pile size may differ if the pile wasn't updated (ie.
   // PictureLayer::Update didn't happen). In that case the pile will be empty.
   DCHECK_IMPLIES(!raster_source_->GetSize().IsEmpty(),
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index bca8224..119b0d4 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -77,7 +77,7 @@ class CC_EXPORT PictureLayerImpl
   WhichTree GetTree() const;
 
   // Mask-related functions.
-  void GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
+  void GetContentsResourceId(ResourceId* resource_id,
                              gfx::Size* resource_size) const override;
 
   void SetNearestNeighbor(bool nearest_neighbor);
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 2bf3696..7572525 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -1370,7 +1370,7 @@ TEST_F(PictureLayerImplTest, HugeMasksGetScaledDown) {
   // Mask layers have a tiling with a single tile in it.
   EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
   // The mask resource exists.
-  ResourceProvider::ResourceId mask_resource_id;
+  ResourceId mask_resource_id;
   gfx::Size mask_texture_size;
   active_mask->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
   EXPECT_NE(0u, mask_resource_id);
@@ -1512,7 +1512,7 @@ TEST_F(PictureLayerImplTest, ScaledMaskLayer) {
   // Mask layers have a tiling with a single tile in it.
   EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
   // The mask resource exists.
-  ResourceProvider::ResourceId mask_resource_id;
+  ResourceId mask_resource_id;
   gfx::Size mask_texture_size;
   active_mask->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
   EXPECT_NE(0u, mask_resource_id);
diff --git a/cc/layers/render_surface_impl.cc b/cc/layers/render_surface_impl.cc
index 2ca1241..7aa4330 100644
--- a/cc/layers/render_surface_impl.cc
+++ b/cc/layers/render_surface_impl.cc
@@ -177,7 +177,7 @@ void RenderSurfaceImpl::AppendQuads(RenderPass* render_pass,
                               debug_border_width);
   }
 
-  ResourceProvider::ResourceId mask_resource_id = 0;
+  ResourceId mask_resource_id = 0;
   gfx::Size mask_texture_size;
   gfx::Vector2dF mask_uv_scale;
   if (mask_layer && mask_layer->DrawsContent() &&
diff --git a/cc/layers/texture_layer_impl.cc b/cc/layers/texture_layer_impl.cc
index 8728b89..63d0549 100644
--- a/cc/layers/texture_layer_impl.cc
+++ b/cc/layers/texture_layer_impl.cc
@@ -165,7 +165,7 @@ void TextureLayerImpl::AppendQuads(RenderPass* render_pass,
 
   TextureDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
-  ResourceProvider::ResourceId id =
+  ResourceId id =
       valid_texture_copy_ ? texture_copy_->id() : external_texture_resource_;
   quad->SetNew(shared_quad_state,
                quad_rect,
diff --git a/cc/layers/texture_layer_impl.h b/cc/layers/texture_layer_impl.h
index 56def7a..acbfbce 100644
--- a/cc/layers/texture_layer_impl.h
+++ b/cc/layers/texture_layer_impl.h
@@ -59,7 +59,7 @@ class CC_EXPORT TextureLayerImpl : public LayerImpl {
   const char* LayerTypeAsString() const override;
   void FreeTextureMailbox();
 
-  ResourceProvider::ResourceId external_texture_resource_;
+  ResourceId external_texture_resource_;
   bool premultiplied_alpha_;
   bool blend_background_color_;
   bool flipped_;
diff --git a/cc/layers/texture_layer_unittest.cc b/cc/layers/texture_layer_unittest.cc
index c33db7c..4a1e76d 100644
--- a/cc/layers/texture_layer_unittest.cc
+++ b/cc/layers/texture_layer_unittest.cc
@@ -1086,7 +1086,7 @@ TEST_F(TextureLayerImplWithMailboxTest,
 
 TEST_F(TextureLayerImplWithMailboxTest, TestCallbackOnInUseResource) {
   ResourceProvider* provider = host_impl_.active_tree()->resource_provider();
-  ResourceProvider::ResourceId id = provider->CreateResourceFromTextureMailbox(
+  ResourceId id = provider->CreateResourceFromTextureMailbox(
       test_data_.mailbox1_,
       SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_));
   provider->AllocateForTesting(id);
diff --git a/cc/layers/tiled_layer_impl.cc b/cc/layers/tiled_layer_impl.cc
index 66aee52..92a3426 100644
--- a/cc/layers/tiled_layer_impl.cc
+++ b/cc/layers/tiled_layer_impl.cc
@@ -29,10 +29,8 @@ class DrawableTile : public LayerTilingData::Tile {
     return make_scoped_ptr(new DrawableTile());
   }
 
-  ResourceProvider::ResourceId resource_id() const { return resource_id_; }
-  void set_resource_id(ResourceProvider::ResourceId resource_id) {
-    resource_id_ = resource_id;
-  }
+  ResourceId resource_id() const { return resource_id_; }
+  void set_resource_id(ResourceId resource_id) { resource_id_ = resource_id; }
   bool contents_swizzled() { return contents_swizzled_; }
   void set_contents_swizzled(bool contents_swizzled) {
     contents_swizzled_ = contents_swizzled;
@@ -41,7 +39,7 @@ class DrawableTile : public LayerTilingData::Tile {
  private:
   DrawableTile() : resource_id_(0), contents_swizzled_(false) {}
 
-  ResourceProvider::ResourceId resource_id_;
+  ResourceId resource_id_;
   bool contents_swizzled_;
 
   DISALLOW_COPY_AND_ASSIGN(DrawableTile);
@@ -61,9 +59,8 @@ TiledLayerImpl::TiledLayerImpl(
 TiledLayerImpl::~TiledLayerImpl() {
 }
 
-void TiledLayerImpl::GetContentsResourceId(
-    ResourceProvider::ResourceId* resource_id,
-    gfx::Size* resource_size) const {
+void TiledLayerImpl::GetContentsResourceId(ResourceId* resource_id,
+                                           gfx::Size* resource_size) const {
   // This function is only valid for single texture layers, e.g. masks.
   DCHECK(tiler_);
   // It's possible the mask layer is created but has no size or otherwise
@@ -287,11 +284,10 @@ void TiledLayerImpl::SetTilingData(const LayerTilingData& tiler) {
   *tiler_ = tiler;
 }
 
-void TiledLayerImpl::PushTileProperties(
-    int i,
-    int j,
-    ResourceProvider::ResourceId resource_id,
-    bool contents_swizzled) {
+void TiledLayerImpl::PushTileProperties(int i,
+                                        int j,
+                                        ResourceId resource_id,
+                                        bool contents_swizzled) {
   DrawableTile* tile = TileAt(i, j);
   if (!tile)
     tile = CreateTile(i, j);
diff --git a/cc/layers/tiled_layer_impl.h b/cc/layers/tiled_layer_impl.h
index c292790..8a7f9f4 100644
--- a/cc/layers/tiled_layer_impl.h
+++ b/cc/layers/tiled_layer_impl.h
@@ -38,14 +38,14 @@ class CC_EXPORT TiledLayerImpl : public LayerImpl {
   void AppendQuads(RenderPass* render_pass,
                    AppendQuadsData* append_quads_data) override;
 
-  void GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
+  void GetContentsResourceId(ResourceId* resource_id,
                              gfx::Size* resource_size) const override;
 
   void set_skips_draw(bool skips_draw) { skips_draw_ = skips_draw; }
   void SetTilingData(const LayerTilingData& tiler);
   void PushTileProperties(int i,
                           int j,
-                          ResourceProvider::ResourceId resource,
+                          ResourceId resource,
                           bool contents_swizzled);
   void PushInvalidTile(int i, int j);
 
diff --git a/cc/layers/tiled_layer_impl_unittest.cc b/cc/layers/tiled_layer_impl_unittest.cc
index 6e66256..79ecfa3 100644
--- a/cc/layers/tiled_layer_impl_unittest.cc
+++ b/cc/layers/tiled_layer_impl_unittest.cc
@@ -58,10 +58,9 @@ class TiledLayerImplTest : public testing::Test {
 
     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);
       }
     }
@@ -291,7 +290,7 @@ TEST_F(TiledLayerImplTest, GPUMemoryUsage) {
 
   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);
@@ -300,7 +299,7 @@ TEST_F(TiledLayerImplTest, GPUMemoryUsage) {
       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);
@@ -314,7 +313,7 @@ TEST_F(TiledLayerImplTest, EmptyMask) {
   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);
@@ -342,10 +341,9 @@ TEST_F(TiledLayerImplTest, Occlusion) {
 
   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);
     }
   }
diff --git a/cc/layers/ui_resource_layer_impl.cc b/cc/layers/ui_resource_layer_impl.cc
index 582ea9e..80fd461 100644
--- a/cc/layers/ui_resource_layer_impl.cc
+++ b/cc/layers/ui_resource_layer_impl.cc
@@ -104,7 +104,7 @@ void UIResourceLayerImpl::AppendQuads(
   if (!ui_resource_id_)
     return;
 
-  ResourceProvider::ResourceId resource =
+  ResourceId resource =
       layer_tree_impl()->ResourceIdForUIResource(ui_resource_id_);
 
   if (!resource)
diff --git a/cc/layers/video_layer_impl.h b/cc/layers/video_layer_impl.h
index aea38b5..5b3d955 100644
--- a/cc/layers/video_layer_impl.h
+++ b/cc/layers/video_layer_impl.h
@@ -62,7 +62,7 @@ class CC_EXPORT VideoLayerImpl : public LayerImpl {
 
   scoped_ptr<VideoResourceUpdater> updater_;
   VideoFrameExternalResources::ResourceType frame_resource_type_;
-  std::vector<ResourceProvider::ResourceId> frame_resources_;
+  std::vector<ResourceId> frame_resources_;
 
   // TODO(danakj): Remove these, hide software path inside ResourceProvider and
   // ExternalResource (aka TextureMailbox) classes.
diff --git a/cc/output/delegating_renderer.cc b/cc/output/delegating_renderer.cc
index 7906afa..5892838 100644
--- a/cc/output/delegating_renderer.cc
+++ b/cc/output/delegating_renderer.cc
@@ -66,9 +66,8 @@ const RendererCapabilitiesImpl& DelegatingRenderer::Capabilities() const {
   return capabilities_;
 }
 
-static ResourceProvider::ResourceId AppendToArray(
-    ResourceProvider::ResourceIdArray* array,
-    ResourceProvider::ResourceId id) {
+static ResourceId AppendToArray(ResourceProvider::ResourceIdArray* array,
+                                ResourceId id) {
   array->push_back(id);
   return id;
 }
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index 69da9a7..c695429 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -452,9 +452,8 @@ void GLRenderer::ClearFramebuffer(DrawingFrame* frame) {
   }
 }
 
-static ResourceProvider::ResourceId WaitOnResourceSyncPoints(
-    ResourceProvider* resource_provider,
-    ResourceProvider::ResourceId resource_id) {
+static ResourceId WaitOnResourceSyncPoints(ResourceProvider* resource_provider,
+                                           ResourceId resource_id) {
   resource_provider->WaitSyncPointIfNeeded(resource_id);
   return resource_id;
 }
@@ -1641,7 +1640,7 @@ void GLRenderer::DrawTileQuad(const DrawingFrame* frame,
 
 void GLRenderer::DrawContentQuad(const DrawingFrame* frame,
                                  const ContentDrawQuadBase* quad,
-                                 ResourceProvider::ResourceId resource_id,
+                                 ResourceId resource_id,
                                  const gfx::QuadF* clip_region) {
   gfx::Transform device_transform =
       frame->window_matrix * frame->projection_matrix * quad->quadTransform();
@@ -1661,7 +1660,7 @@ void GLRenderer::DrawContentQuad(const DrawingFrame* frame,
 
 void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame,
                                    const ContentDrawQuadBase* quad,
-                                   ResourceProvider::ResourceId resource_id,
+                                   ResourceId resource_id,
                                    const gfx::Transform& device_transform,
                                    const gfx::QuadF* clip_region) {
   if (!device_transform.IsInvertible())
@@ -1781,7 +1780,7 @@ void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame,
 
 void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
                                      const ContentDrawQuadBase* quad,
-                                     ResourceProvider::ResourceId resource_id,
+                                     ResourceId resource_id,
                                      const gfx::QuadF* clip_region) {
   gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional(
       quad->tex_coord_rect, quad->rect, quad->visible_rect);
diff --git a/cc/output/gl_renderer.h b/cc/output/gl_renderer.h
index 324a7bd..cba0642 100644
--- a/cc/output/gl_renderer.h
+++ b/cc/output/gl_renderer.h
@@ -198,16 +198,16 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
                     const gfx::QuadF* clip_region);
   void DrawContentQuad(const DrawingFrame* frame,
                        const ContentDrawQuadBase* quad,
-                       ResourceProvider::ResourceId resource_id,
+                       ResourceId resource_id,
                        const gfx::QuadF* clip_region);
   void DrawContentQuadAA(const DrawingFrame* frame,
                          const ContentDrawQuadBase* quad,
-                         ResourceProvider::ResourceId resource_id,
+                         ResourceId resource_id,
                          const gfx::Transform& device_transform,
                          const gfx::QuadF* clip_region);
   void DrawContentQuadNoAA(const DrawingFrame* frame,
                            const ContentDrawQuadBase* quad,
-                           ResourceProvider::ResourceId resource_id,
+                           ResourceId resource_id,
                            const gfx::QuadF* clip_region);
   void DrawYUVVideoQuad(const DrawingFrame* frame,
                         const YUVVideoDrawQuad* quad,
@@ -515,7 +515,7 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
   bool use_blend_equation_advanced_coherent_;
 
   SkBitmap on_demand_tile_raster_bitmap_;
-  ResourceProvider::ResourceId on_demand_tile_raster_resource_id_;
+  ResourceId on_demand_tile_raster_resource_id_;
   BoundGeometry bound_geometry_;
   DISALLOW_COPY_AND_ASSIGN(GLRenderer);
 };
diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc
index 09407f5..31e392c 100644
--- a/cc/output/gl_renderer_unittest.cc
+++ b/cc/output/gl_renderer_unittest.cc
@@ -1558,7 +1558,7 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
   RenderPassId root_pass_id(1, 0);
   TestRenderPass* root_pass;
 
-  ResourceProvider::ResourceId mask = resource_provider_->CreateResource(
+  ResourceId mask = resource_provider_->CreateResource(
       gfx::Size(20, 12), GL_CLAMP_TO_EDGE,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       resource_provider_->best_texture_format());
@@ -2169,9 +2169,8 @@ TEST_F(GLRendererTest, DontOverlayWithCopyRequests) {
   mailbox.set_allow_overlay(true);
   scoped_ptr<SingleReleaseCallbackImpl> release_callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased));
-  ResourceProvider::ResourceId resource_id =
-      resource_provider->CreateResourceFromTextureMailbox(
-          mailbox, release_callback.Pass());
+  ResourceId resource_id = resource_provider->CreateResourceFromTextureMailbox(
+      mailbox, release_callback.Pass());
   bool premultiplied_alpha = false;
   bool flipped = false;
   bool nearest_neighbor = false;
@@ -2296,9 +2295,8 @@ TEST_F(GLRendererTest, OverlaySyncPointsAreProcessed) {
   mailbox.set_allow_overlay(true);
   scoped_ptr<SingleReleaseCallbackImpl> release_callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased));
-  ResourceProvider::ResourceId resource_id =
-      resource_provider->CreateResourceFromTextureMailbox(
-          mailbox, release_callback.Pass());
+  ResourceId resource_id = resource_provider->CreateResourceFromTextureMailbox(
+      mailbox, release_callback.Pass());
   bool premultiplied_alpha = false;
   bool flipped = false;
   bool nearest_neighbor = false;
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index c9a2ae0..5e63246 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -152,8 +152,7 @@ scoped_ptr<RenderPass> CreateRenderPass() {
   return pass.Pass();
 }
 
-ResourceProvider::ResourceId CreateResource(
-    ResourceProvider* resource_provider) {
+ResourceId CreateResource(ResourceProvider* resource_provider) {
   unsigned sync_point = 0;
   TextureMailbox mailbox =
       TextureMailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point);
@@ -180,7 +179,7 @@ TextureDrawQuad* CreateCandidateQuadAt(ResourceProvider* resource_provider,
                                        const SharedQuadState* shared_quad_state,
                                        RenderPass* render_pass,
                                        const gfx::Rect& rect) {
-  ResourceProvider::ResourceId resource_id = CreateResource(resource_provider);
+  ResourceId resource_id = CreateResource(resource_provider);
   bool premultiplied_alpha = false;
   bool flipped = false;
   bool nearest_neighbor = false;
@@ -210,7 +209,7 @@ StreamVideoDrawQuad* CreateCandidateVideoQuadAt(
     RenderPass* render_pass,
     const gfx::Rect& rect,
     const gfx::Transform& transform) {
-  ResourceProvider::ResourceId resource_id = CreateResource(resource_provider);
+  ResourceId resource_id = CreateResource(resource_provider);
 
   StreamVideoDrawQuad* overlay_quad =
       render_pass->CreateAndAppendDrawQuad<StreamVideoDrawQuad>();
@@ -1104,10 +1103,8 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturned) {
   Init(use_validator);
   renderer_->set_expect_overlays(true);
 
-  ResourceProvider::ResourceId resource1 =
-      CreateResource(resource_provider_.get());
-  ResourceProvider::ResourceId resource2 =
-      CreateResource(resource_provider_.get());
+  ResourceId resource1 = CreateResource(resource_provider_.get());
+  ResourceId resource2 = CreateResource(resource_provider_.get());
 
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   RenderPassList pass_list;
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index 330c8bf..02e341b 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -137,7 +137,7 @@ void CreateTestTwoColoredTextureDrawQuad(const gfx::Rect& rect,
       pixels[i * rect.width() + k] = pixel_stripe_color;
     }
   }
-  ResourceProvider::ResourceId resource = resource_provider->CreateResource(
+  ResourceId resource = resource_provider->CreateResource(
       rect.size(), GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       RGBA_8888);
   resource_provider->SetPixels(resource,
@@ -172,7 +172,7 @@ void CreateTestTextureDrawQuad(const gfx::Rect& rect,
   size_t num_pixels = static_cast<size_t>(rect.width()) * rect.height();
   std::vector<uint32_t> pixels(num_pixels, pixel_color);
 
-  ResourceProvider::ResourceId resource = resource_provider->CreateResource(
+  ResourceId resource = resource_provider->CreateResource(
       rect.size(), GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       RGBA_8888);
   resource_provider->CopyToResource(
@@ -224,22 +224,19 @@ void CreateTestYUVVideoDrawQuad_FromVideoFrame(
   EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
             resources.release_callbacks.size());
 
-  ResourceProvider::ResourceId y_resource =
-      resource_provider->CreateResourceFromTextureMailbox(
-          resources.mailboxes[media::VideoFrame::kYPlane],
-          SingleReleaseCallbackImpl::Create(
-              resources.release_callbacks[media::VideoFrame::kYPlane]));
-  ResourceProvider::ResourceId u_resource =
-      resource_provider->CreateResourceFromTextureMailbox(
-          resources.mailboxes[media::VideoFrame::kUPlane],
-          SingleReleaseCallbackImpl::Create(
-              resources.release_callbacks[media::VideoFrame::kUPlane]));
-  ResourceProvider::ResourceId v_resource =
-      resource_provider->CreateResourceFromTextureMailbox(
-          resources.mailboxes[media::VideoFrame::kVPlane],
-          SingleReleaseCallbackImpl::Create(
-              resources.release_callbacks[media::VideoFrame::kVPlane]));
-  ResourceProvider::ResourceId a_resource = 0;
+  ResourceId y_resource = resource_provider->CreateResourceFromTextureMailbox(
+      resources.mailboxes[media::VideoFrame::kYPlane],
+      SingleReleaseCallbackImpl::Create(
+          resources.release_callbacks[media::VideoFrame::kYPlane]));
+  ResourceId u_resource = resource_provider->CreateResourceFromTextureMailbox(
+      resources.mailboxes[media::VideoFrame::kUPlane],
+      SingleReleaseCallbackImpl::Create(
+          resources.release_callbacks[media::VideoFrame::kUPlane]));
+  ResourceId v_resource = resource_provider->CreateResourceFromTextureMailbox(
+      resources.mailboxes[media::VideoFrame::kVPlane],
+      SingleReleaseCallbackImpl::Create(
+          resources.release_callbacks[media::VideoFrame::kVPlane]));
+  ResourceId a_resource = 0;
   if (with_alpha) {
     a_resource = resource_provider->CreateResourceFromTextureMailbox(
         resources.mailboxes[media::VideoFrame::kAPlane],
@@ -1679,10 +1676,9 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) {
     rect.Inset(6, 6, 4, 4);
   }
 
-  ResourceProvider::ResourceId mask_resource_id =
-      this->resource_provider_->CreateResource(
-          mask_rect.size(), GL_CLAMP_TO_EDGE,
-          ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
+  ResourceId mask_resource_id = this->resource_provider_->CreateResource(
+      mask_rect.size(), GL_CLAMP_TO_EDGE,
+      ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
   {
     SkAutoLockPixels lock(bitmap);
     this->resource_provider_->CopyToResource(
@@ -2464,10 +2460,9 @@ TYPED_TEST(RendererPixelTest, TileDrawQuadNearestNeighbor) {
   }
 
   gfx::Size tile_size(2, 2);
-  ResourceProvider::ResourceId resource =
-      this->resource_provider_->CreateResource(
-          tile_size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
-          RGBA_8888);
+  ResourceId resource = this->resource_provider_->CreateResource(
+      tile_size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      RGBA_8888);
 
   {
     SkAutoLockPixels lock(bitmap);
@@ -2516,10 +2511,9 @@ TYPED_TEST(SoftwareRendererPixelTest, TextureDrawQuadNearestNeighbor) {
   }
 
   gfx::Size tile_size(2, 2);
-  ResourceProvider::ResourceId resource =
-      this->resource_provider_->CreateResource(
-          tile_size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
-          RGBA_8888);
+  ResourceId resource = this->resource_provider_->CreateResource(
+      tile_size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      RGBA_8888);
 
   {
     SkAutoLockPixels lock(bitmap);
@@ -2569,10 +2563,9 @@ TYPED_TEST(SoftwareRendererPixelTest, TextureDrawQuadLinear) {
   }
 
   gfx::Size tile_size(2, 2);
-  ResourceProvider::ResourceId resource =
-      this->resource_provider_->CreateResource(
-          tile_size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
-          RGBA_8888);
+  ResourceId resource = this->resource_provider_->CreateResource(
+      tile_size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      RGBA_8888);
 
   {
     SkAutoLockPixels lock(bitmap);
@@ -2929,10 +2922,9 @@ TYPED_TEST(RendererPixelTest, WrapModeRepeat) {
     colors[2], colors[2], colors[3], colors[3],
     colors[2], colors[2], colors[3], colors[3],
   };
-  ResourceProvider::ResourceId resource =
-      this->resource_provider_->CreateResource(
-          texture_size, GL_REPEAT, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
-          RGBA_8888);
+  ResourceId resource = this->resource_provider_->CreateResource(
+      texture_size, GL_REPEAT, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      RGBA_8888);
   this->resource_provider_->CopyToResource(
       resource, reinterpret_cast<uint8_t*>(pixels), texture_size);
 
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index 80a5f0e..3381ab1 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -229,8 +229,7 @@ void SoftwareRenderer::PrepareSurfaceForPass(
   }
 }
 
-bool SoftwareRenderer::IsSoftwareResource(
-    ResourceProvider::ResourceId resource_id) const {
+bool SoftwareRenderer::IsSoftwareResource(ResourceId resource_id) const {
   switch (resource_provider_->GetResourceType(resource_id)) {
     case ResourceProvider::RESOURCE_TYPE_GL_TEXTURE:
       return false;
diff --git a/cc/output/software_renderer.h b/cc/output/software_renderer.h
index 74f328ed..c309042 100644
--- a/cc/output/software_renderer.h
+++ b/cc/output/software_renderer.h
@@ -74,7 +74,7 @@ class CC_EXPORT SoftwareRenderer : public DirectRenderer {
   void ClearCanvas(SkColor color);
   void ClearFramebuffer(DrawingFrame* frame);
   void SetClipRect(const gfx::Rect& rect);
-  bool IsSoftwareResource(ResourceProvider::ResourceId resource_id) const;
+  bool IsSoftwareResource(ResourceId resource_id) const;
 
   void DrawCheckerboardQuad(const DrawingFrame* frame,
                             const CheckerboardDrawQuad* quad);
diff --git a/cc/output/software_renderer_unittest.cc b/cc/output/software_renderer_unittest.cc
index 3b2c4bc..741b096 100644
--- a/cc/output/software_renderer_unittest.cc
+++ b/cc/output/software_renderer_unittest.cc
@@ -153,14 +153,12 @@ TEST_F(SoftwareRendererTest, TileQuad) {
   gfx::Rect inner_rect(gfx::Point(1, 1), inner_size);
   InitializeRenderer(make_scoped_ptr(new SoftwareOutputDevice));
 
-  ResourceProvider::ResourceId resource_yellow =
-      resource_provider()->CreateResource(
-          outer_size, GL_CLAMP_TO_EDGE,
-          ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
-  ResourceProvider::ResourceId resource_cyan =
-      resource_provider()->CreateResource(
-          inner_size, GL_CLAMP_TO_EDGE,
-          ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
+  ResourceId resource_yellow = resource_provider()->CreateResource(
+      outer_size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      RGBA_8888);
+  ResourceId resource_cyan = resource_provider()->CreateResource(
+      inner_size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      RGBA_8888);
 
   SkBitmap yellow_tile;
   yellow_tile.allocN32Pixels(outer_size.width(), outer_size.height());
@@ -240,10 +238,9 @@ TEST_F(SoftwareRendererTest, TileQuadVisibleRect) {
   visible_rect.Inset(1, 2, 3, 4);
   InitializeRenderer(make_scoped_ptr(new SoftwareOutputDevice));
 
-  ResourceProvider::ResourceId resource_cyan =
-      resource_provider()->CreateResource(
-          tile_size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
-          RGBA_8888);
+  ResourceId resource_cyan = resource_provider()->CreateResource(
+      tile_size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      RGBA_8888);
 
   SkBitmap cyan_tile;  // The lowest five rows are yellow.
   cyan_tile.allocN32Pixels(tile_size.width(), tile_size.height());
diff --git a/cc/quads/draw_quad.h b/cc/quads/draw_quad.h
index 3897d1d..0e26b63 100644
--- a/cc/quads/draw_quad.h
+++ b/cc/quads/draw_quad.h
@@ -96,7 +96,6 @@ class CC_EXPORT DrawQuad {
     return !opaque_rect.Contains(visible_rect);
   }
 
-  typedef ResourceProvider::ResourceId ResourceId;
   typedef base::Callback<ResourceId(ResourceId)> ResourceIteratorCallback;
   virtual void IterateResources(const ResourceIteratorCallback& callback) = 0;
 
diff --git a/cc/quads/draw_quad_unittest.cc b/cc/quads/draw_quad_unittest.cc
index 968a1d0..e66bcdf 100644
--- a/cc/quads/draw_quad_unittest.cc
+++ b/cc/quads/draw_quad_unittest.cc
@@ -404,7 +404,7 @@ TEST(DrawQuadTest, CopyIOSurfaceDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
   gfx::Rect visible_rect(40, 50, 30, 20);
   gfx::Size size(58, 95);
-  ResourceProvider::ResourceId resource_id = 72;
+  ResourceId resource_id = 72;
   IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
   CREATE_SHARED_STATE();
 
@@ -431,7 +431,7 @@ TEST(DrawQuadTest, CopyIOSurfaceDrawQuad) {
 TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
   gfx::Rect visible_rect(40, 50, 30, 20);
   RenderPassId render_pass_id(22, 64);
-  ResourceProvider::ResourceId mask_resource_id = 78;
+  ResourceId mask_resource_id = 78;
   gfx::Vector2dF mask_uv_scale(33.f, 19.f);
   gfx::Size mask_texture_size(128, 134);
   FilterOperations filters;
@@ -507,7 +507,7 @@ TEST(DrawQuadTest, CopySolidColorDrawQuad) {
 TEST(DrawQuadTest, CopyStreamVideoDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
   gfx::Rect visible_rect(40, 50, 30, 20);
-  ResourceProvider::ResourceId resource_id = 64;
+  ResourceId resource_id = 64;
   gfx::Transform matrix = gfx::Transform(0.5, 0.25, 1, 0.75, 0, 1);
   CREATE_SHARED_STATE();
 
@@ -642,10 +642,10 @@ TEST(DrawQuadTest, CopyYUVVideoDrawQuad) {
   gfx::RectF uv_tex_coord_rect(20, 25, 15, 10);
   gfx::Size ya_tex_size(32, 68);
   gfx::Size uv_tex_size(41, 51);
-  ResourceProvider::ResourceId y_plane_resource_id = 45;
-  ResourceProvider::ResourceId u_plane_resource_id = 532;
-  ResourceProvider::ResourceId v_plane_resource_id = 4;
-  ResourceProvider::ResourceId a_plane_resource_id = 63;
+  ResourceId y_plane_resource_id = 45;
+  ResourceId u_plane_resource_id = 532;
+  ResourceId v_plane_resource_id = 4;
+  ResourceId a_plane_resource_id = 63;
   YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::JPEG;
   CREATE_SHARED_STATE();
 
@@ -725,8 +725,7 @@ TEST(DrawQuadTest, CopyPictureDrawQuad) {
 
 class DrawQuadIteratorTest : public testing::Test {
  protected:
-  ResourceProvider::ResourceId IncrementResourceId(
-      ResourceProvider::ResourceId id) {
+  ResourceId IncrementResourceId(ResourceId id) {
     ++num_resources_;
     return id + 1;
   }
@@ -766,7 +765,7 @@ TEST_F(DrawQuadIteratorTest, IOSurfaceDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
   gfx::Rect visible_rect(40, 50, 30, 20);
   gfx::Size size(58, 95);
-  ResourceProvider::ResourceId resource_id = 72;
+  ResourceId resource_id = 72;
   IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
 
   CREATE_SHARED_STATE();
@@ -784,7 +783,7 @@ TEST_F(DrawQuadIteratorTest, IOSurfaceDrawQuad) {
 TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
   gfx::Rect visible_rect(40, 50, 30, 20);
   RenderPassId render_pass_id(22, 64);
-  ResourceProvider::ResourceId mask_resource_id = 78;
+  ResourceId mask_resource_id = 78;
   gfx::Vector2dF mask_uv_scale(33.f, 19.f);
   gfx::Size mask_texture_size(128, 134);
   FilterOperations filters;
@@ -829,7 +828,7 @@ TEST_F(DrawQuadIteratorTest, SolidColorDrawQuad) {
 TEST_F(DrawQuadIteratorTest, StreamVideoDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
   gfx::Rect visible_rect(40, 50, 30, 20);
-  ResourceProvider::ResourceId resource_id = 64;
+  ResourceId resource_id = 64;
   gfx::Transform matrix = gfx::Transform(0.5, 0.25, 1, 0.75, 0, 1);
 
   CREATE_SHARED_STATE();
@@ -907,10 +906,10 @@ TEST_F(DrawQuadIteratorTest, YUVVideoDrawQuad) {
   gfx::RectF uv_tex_coord_rect(0.0f, 0.0f, 0.375f, 0.25f);
   gfx::Size ya_tex_size(32, 68);
   gfx::Size uv_tex_size(41, 51);
-  ResourceProvider::ResourceId y_plane_resource_id = 45;
-  ResourceProvider::ResourceId u_plane_resource_id = 532;
-  ResourceProvider::ResourceId v_plane_resource_id = 4;
-  ResourceProvider::ResourceId a_plane_resource_id = 63;
+  ResourceId y_plane_resource_id = 45;
+  ResourceId u_plane_resource_id = 532;
+  ResourceId v_plane_resource_id = 4;
+  ResourceId a_plane_resource_id = 63;
   YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::JPEG;
 
   CREATE_SHARED_STATE();
diff --git a/cc/quads/render_pass_draw_quad.cc b/cc/quads/render_pass_draw_quad.cc
index 963a190..ee9c748 100644
--- a/cc/quads/render_pass_draw_quad.cc
+++ b/cc/quads/render_pass_draw_quad.cc
@@ -14,7 +14,7 @@ namespace cc {
 
 RenderPassDrawQuad::RenderPassDrawQuad()
     : render_pass_id(RenderPassId(-1, -1)),
-      mask_resource_id(static_cast<ResourceProvider::ResourceId>(-1)) {
+      mask_resource_id(static_cast<ResourceId>(-1)) {
 }
 
 RenderPassDrawQuad::~RenderPassDrawQuad() {
@@ -24,7 +24,7 @@ void RenderPassDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                                 const gfx::Rect& rect,
                                 const gfx::Rect& visible_rect,
                                 RenderPassId render_pass_id,
-                                ResourceProvider::ResourceId mask_resource_id,
+                                ResourceId mask_resource_id,
                                 const gfx::Vector2dF& mask_uv_scale,
                                 const gfx::Size& mask_texture_size,
                                 const FilterOperations& filters,
@@ -55,7 +55,7 @@ void RenderPassDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                                 const gfx::Rect& visible_rect,
                                 bool needs_blending,
                                 RenderPassId render_pass_id,
-                                ResourceProvider::ResourceId mask_resource_id,
+                                ResourceId mask_resource_id,
                                 const gfx::Vector2dF& mask_uv_scale,
                                 const gfx::Size& mask_texture_size,
                                 const FilterOperations& filters,
diff --git a/cc/quads/render_pass_draw_quad.h b/cc/quads/render_pass_draw_quad.h
index 758b8e8..7e989d4 100644
--- a/cc/quads/render_pass_draw_quad.h
+++ b/cc/quads/render_pass_draw_quad.h
@@ -24,7 +24,7 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
               const gfx::Rect& rect,
               const gfx::Rect& visible_rect,
               RenderPassId render_pass_id,
-              ResourceProvider::ResourceId mask_resource_id,
+              ResourceId mask_resource_id,
               const gfx::Vector2dF& mask_uv_scale,
               const gfx::Size& mask_texture_size,
               const FilterOperations& filters,
@@ -37,7 +37,7 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
               const gfx::Rect& visible_rect,
               bool needs_blending,
               RenderPassId render_pass_id,
-              ResourceProvider::ResourceId mask_resource_id,
+              ResourceId mask_resource_id,
               const gfx::Vector2dF& mask_uv_scale,
               const gfx::Size& mask_texture_size,
               const FilterOperations& filters,
@@ -45,7 +45,7 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
               const FilterOperations& background_filters);
 
   RenderPassId render_pass_id;
-  ResourceProvider::ResourceId mask_resource_id;
+  ResourceId mask_resource_id;
   gfx::Vector2dF mask_uv_scale;
   gfx::Size mask_texture_size;
 
diff --git a/cc/resources/prioritized_resource.h b/cc/resources/prioritized_resource.h
index 3b6ecc0..e8d9a60 100644
--- a/cc/resources/prioritized_resource.h
+++ b/cc/resources/prioritized_resource.h
@@ -82,9 +82,7 @@ class CC_EXPORT PrioritizedResource {
                  const gfx::Rect& source_rect,
                  const gfx::Vector2d& dest_offset);
 
-  ResourceProvider::ResourceId resource_id() const {
-    return backing_ ? backing_->id() : 0;
-  }
+  ResourceId resource_id() const { return backing_ ? backing_->id() : 0; }
 
   // Self-managed textures are accounted for when prioritizing other textures,
   // but they are not allocated/recycled/deleted, so this needs to be done
diff --git a/cc/resources/prioritized_resource_manager.cc b/cc/resources/prioritized_resource_manager.cc
index 236377b..dc17862 100644
--- a/cc/resources/prioritized_resource_manager.cc
+++ b/cc/resources/prioritized_resource_manager.cc
@@ -449,10 +449,9 @@ PrioritizedResource::Backing* PrioritizedResourceManager::CreateBacking(
     ResourceProvider* resource_provider) {
   DCHECK(proxy_->IsImplThread() && proxy_->IsMainThreadBlocked());
   DCHECK(resource_provider);
-  ResourceProvider::ResourceId resource_id =
-      resource_provider->CreateManagedResource(
-          size, GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
-          ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
+  ResourceId resource_id = resource_provider->CreateManagedResource(
+      size, GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
+      ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   PrioritizedResource::Backing* backing = new PrioritizedResource::Backing(
       resource_id, resource_provider, size, format);
   memory_use_bytes_ += backing->bytes();
diff --git a/cc/resources/resource.h b/cc/resources/resource.h
index edafaef..e94b121 100644
--- a/cc/resources/resource.h
+++ b/cc/resources/resource.h
@@ -19,7 +19,7 @@ class CC_EXPORT Resource {
         size_(size),
         format_(format) {}
 
-  ResourceProvider::ResourceId id() const { return id_; }
+  ResourceId id() const { return id_; }
   gfx::Size size() const { return size_; }
   ResourceFormat format() const { return format_; }
   size_t bytes() const;
@@ -31,14 +31,14 @@ class CC_EXPORT Resource {
   }
 
  protected:
-  void set_id(ResourceProvider::ResourceId id) { id_ = id; }
+  void set_id(ResourceId id) { id_ = id; }
   void set_dimensions(const gfx::Size& size, ResourceFormat format) {
     size_ = size;
     format_ = format;
   }
 
  private:
-  ResourceProvider::ResourceId id_;
+  ResourceId id_;
   gfx::Size size_;
   ResourceFormat format_;
 
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index eb774fe..db1b35e 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -461,11 +461,10 @@ bool ResourceProvider::AllowOverlay(ResourceId id) {
   return resource->allow_overlay;
 }
 
-ResourceProvider::ResourceId ResourceProvider::CreateResource(
-    const gfx::Size& size,
-    GLint wrap_mode,
-    TextureHint hint,
-    ResourceFormat format) {
+ResourceId ResourceProvider::CreateResource(const gfx::Size& size,
+                                            GLint wrap_mode,
+                                            TextureHint hint,
+                                            ResourceFormat format) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case RESOURCE_TYPE_GL_TEXTURE:
@@ -484,12 +483,11 @@ ResourceProvider::ResourceId ResourceProvider::CreateResource(
   return 0;
 }
 
-ResourceProvider::ResourceId ResourceProvider::CreateManagedResource(
-    const gfx::Size& size,
-    GLenum target,
-    GLint wrap_mode,
-    TextureHint hint,
-    ResourceFormat format) {
+ResourceId ResourceProvider::CreateManagedResource(const gfx::Size& size,
+                                                   GLenum target,
+                                                   GLint wrap_mode,
+                                                   TextureHint hint,
+                                                   ResourceFormat format) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case RESOURCE_TYPE_GL_TEXTURE:
@@ -508,13 +506,12 @@ ResourceProvider::ResourceId ResourceProvider::CreateManagedResource(
   return 0;
 }
 
-ResourceProvider::ResourceId ResourceProvider::CreateGLTexture(
-    const gfx::Size& size,
-    GLenum target,
-    GLenum texture_pool,
-    GLint wrap_mode,
-    TextureHint hint,
-    ResourceFormat format) {
+ResourceId ResourceProvider::CreateGLTexture(const gfx::Size& size,
+                                             GLenum target,
+                                             GLenum texture_pool,
+                                             GLint wrap_mode,
+                                             TextureHint hint,
+                                             ResourceFormat format) {
   DCHECK_LE(size.width(), max_texture_size_);
   DCHECK_LE(size.height(), max_texture_size_);
   DCHECK(thread_checker_.CalledOnValidThread());
@@ -527,8 +524,8 @@ ResourceProvider::ResourceId ResourceProvider::CreateGLTexture(
   return id;
 }
 
-ResourceProvider::ResourceId ResourceProvider::CreateBitmap(
-    const gfx::Size& size, GLint wrap_mode) {
+ResourceId ResourceProvider::CreateBitmap(const gfx::Size& size,
+                                          GLint wrap_mode) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_ptr<SharedBitmap> bitmap =
@@ -544,7 +541,7 @@ ResourceProvider::ResourceId ResourceProvider::CreateBitmap(
   return id;
 }
 
-ResourceProvider::ResourceId ResourceProvider::CreateResourceFromIOSurface(
+ResourceId ResourceProvider::CreateResourceFromIOSurface(
     const gfx::Size& size,
     unsigned io_surface_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ -564,7 +561,7 @@ ResourceProvider::ResourceId ResourceProvider::CreateResourceFromIOSurface(
   return id;
 }
 
-ResourceProvider::ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
+ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox,
     scoped_ptr<SingleReleaseCallbackImpl> release_callback_impl) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ -963,7 +960,7 @@ void ResourceProvider::UnlockForWrite(ResourceProvider::Resource* resource) {
 
 ResourceProvider::ScopedReadLockGL::ScopedReadLockGL(
     ResourceProvider* resource_provider,
-    ResourceProvider::ResourceId resource_id)
+    ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_id_(resource_id),
       resource_(resource_provider->LockForRead(resource_id)) {
@@ -976,7 +973,7 @@ ResourceProvider::ScopedReadLockGL::~ScopedReadLockGL() {
 
 ResourceProvider::ScopedSamplerGL::ScopedSamplerGL(
     ResourceProvider* resource_provider,
-    ResourceProvider::ResourceId resource_id,
+    ResourceId resource_id,
     GLenum filter)
     : ScopedReadLockGL(resource_provider, resource_id),
       unit_(GL_TEXTURE0),
@@ -985,7 +982,7 @@ ResourceProvider::ScopedSamplerGL::ScopedSamplerGL(
 
 ResourceProvider::ScopedSamplerGL::ScopedSamplerGL(
     ResourceProvider* resource_provider,
-    ResourceProvider::ResourceId resource_id,
+    ResourceId resource_id,
     GLenum unit,
     GLenum filter)
     : ScopedReadLockGL(resource_provider, resource_id),
@@ -998,7 +995,7 @@ ResourceProvider::ScopedSamplerGL::~ScopedSamplerGL() {
 
 ResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL(
     ResourceProvider* resource_provider,
-    ResourceProvider::ResourceId resource_id)
+    ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_(resource_provider->LockForWrite(resource_id)) {
   resource_provider_->LazyAllocate(resource_);
@@ -1020,9 +1017,8 @@ void ResourceProvider::PopulateSkBitmapWithResource(
 
 ResourceProvider::ScopedReadLockSoftware::ScopedReadLockSoftware(
     ResourceProvider* resource_provider,
-    ResourceProvider::ResourceId resource_id)
-    : resource_provider_(resource_provider),
-      resource_id_(resource_id) {
+    ResourceId resource_id)
+    : resource_provider_(resource_provider), resource_id_(resource_id) {
   const Resource* resource = resource_provider->LockForRead(resource_id);
   wrap_mode_ = resource->wrap_mode;
   ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource);
@@ -1034,7 +1030,7 @@ ResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware() {
 
 ResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware(
     ResourceProvider* resource_provider,
-    ResourceProvider::ResourceId resource_id)
+    ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_(resource_provider->LockForWrite(resource_id)) {
   ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource_);
@@ -1048,7 +1044,7 @@ ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() {
 
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
     ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider,
-                                   ResourceProvider::ResourceId resource_id)
+                                   ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_(resource_provider->LockForWrite(resource_id)),
       gpu_memory_buffer_manager_(resource_provider->gpu_memory_buffer_manager_),
@@ -1106,7 +1102,7 @@ ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
 
 ResourceProvider::ScopedWriteLockGr::ScopedWriteLockGr(
     ResourceProvider* resource_provider,
-    ResourceProvider::ResourceId resource_id)
+    ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_(resource_provider->LockForWrite(resource_id)) {
   DCHECK(thread_checker_.CalledOnValidThread());
diff --git a/cc/resources/resource_provider.h b/cc/resources/resource_provider.h
index f7baac1..393751e 100644
--- a/cc/resources/resource_provider.h
+++ b/cc/resources/resource_provider.h
@@ -18,6 +18,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "cc/base/cc_export.h"
+#include "cc/base/resource_id.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/resources/release_callback_impl.h"
@@ -62,7 +63,6 @@ class CC_EXPORT ResourceProvider {
   struct Resource;
 
  public:
-  typedef unsigned ResourceId;
   typedef std::vector<ResourceId> ResourceIdArray;
   typedef base::hash_set<ResourceId> ResourceIdSet;
   typedef base::hash_map<ResourceId, ResourceId> ResourceIdMap;
@@ -220,7 +220,7 @@ class CC_EXPORT ResourceProvider {
   class CC_EXPORT ScopedReadLockGL {
    public:
     ScopedReadLockGL(ResourceProvider* resource_provider,
-                     ResourceProvider::ResourceId resource_id);
+                     ResourceId resource_id);
     virtual ~ScopedReadLockGL();
 
     unsigned texture_id() const { return resource_->gl_id; }
@@ -228,7 +228,7 @@ class CC_EXPORT ResourceProvider {
 
    protected:
     ResourceProvider* resource_provider_;
-    ResourceProvider::ResourceId resource_id_;
+    ResourceId resource_id_;
 
    private:
     const ResourceProvider::Resource* resource_;
@@ -239,10 +239,10 @@ class CC_EXPORT ResourceProvider {
   class CC_EXPORT ScopedSamplerGL : public ScopedReadLockGL {
    public:
     ScopedSamplerGL(ResourceProvider* resource_provider,
-                    ResourceProvider::ResourceId resource_id,
+                    ResourceId resource_id,
                     GLenum filter);
     ScopedSamplerGL(ResourceProvider* resource_provider,
-                    ResourceProvider::ResourceId resource_id,
+                    ResourceId resource_id,
                     GLenum unit,
                     GLenum filter);
     ~ScopedSamplerGL() override;
@@ -259,7 +259,7 @@ class CC_EXPORT ResourceProvider {
   class CC_EXPORT ScopedWriteLockGL {
    public:
     ScopedWriteLockGL(ResourceProvider* resource_provider,
-                      ResourceProvider::ResourceId resource_id);
+                      ResourceId resource_id);
     ~ScopedWriteLockGL();
 
     unsigned texture_id() const { return texture_id_; }
@@ -275,7 +275,7 @@ class CC_EXPORT ResourceProvider {
   class CC_EXPORT ScopedReadLockSoftware {
    public:
     ScopedReadLockSoftware(ResourceProvider* resource_provider,
-                           ResourceProvider::ResourceId resource_id);
+                           ResourceId resource_id);
     ~ScopedReadLockSoftware();
 
     const SkBitmap* sk_bitmap() const {
@@ -288,7 +288,7 @@ class CC_EXPORT ResourceProvider {
 
    private:
     ResourceProvider* resource_provider_;
-    ResourceProvider::ResourceId resource_id_;
+    ResourceId resource_id_;
     SkBitmap sk_bitmap_;
     GLint wrap_mode_;
 
@@ -298,7 +298,7 @@ class CC_EXPORT ResourceProvider {
   class CC_EXPORT ScopedWriteLockSoftware {
    public:
     ScopedWriteLockSoftware(ResourceProvider* resource_provider,
-                            ResourceProvider::ResourceId resource_id);
+                            ResourceId resource_id);
     ~ScopedWriteLockSoftware();
 
     SkBitmap& sk_bitmap() { return sk_bitmap_; }
@@ -316,7 +316,7 @@ class CC_EXPORT ResourceProvider {
   class CC_EXPORT ScopedWriteLockGpuMemoryBuffer {
    public:
     ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider,
-                                   ResourceProvider::ResourceId resource_id);
+                                   ResourceId resource_id);
     ~ScopedWriteLockGpuMemoryBuffer();
 
     gfx::GpuMemoryBuffer* GetGpuMemoryBuffer();
@@ -336,7 +336,7 @@ class CC_EXPORT ResourceProvider {
   class CC_EXPORT ScopedWriteLockGr {
    public:
     ScopedWriteLockGr(ResourceProvider* resource_provider,
-                      ResourceProvider::ResourceId resource_id);
+                      ResourceId resource_id);
     ~ScopedWriteLockGr();
 
     void InitSkSurface(bool use_distance_field_text,
diff --git a/cc/resources/resource_provider_unittest.cc b/cc/resources/resource_provider_unittest.cc
index 3ca1ab4..f42f647 100644
--- a/cc/resources/resource_provider_unittest.cc
+++ b/cc/resources/resource_provider_unittest.cc
@@ -350,7 +350,7 @@ class ResourceProviderContext : public TestWebGraphicsContext3D {
 
 void GetResourcePixels(ResourceProvider* resource_provider,
                        ResourceProviderContext* context,
-                       ResourceProvider::ResourceId id,
+                       ResourceId id,
                        const gfx::Size& size,
                        ResourceFormat format,
                        uint8_t* pixels) {
@@ -449,7 +449,7 @@ class ResourceProviderTest
   }
 
   static void SetResourceFilter(ResourceProvider* resource_provider,
-                                ResourceProvider::ResourceId id,
+                                ResourceId id,
                                 GLenum filter) {
     ResourceProvider::ScopedSamplerGL sampler(
         resource_provider, id, GL_TEXTURE_2D, filter);
@@ -457,10 +457,10 @@ class ResourceProviderTest
 
   ResourceProviderContext* context() { return context3d_; }
 
-  ResourceProvider::ResourceId CreateChildMailbox(uint32* release_sync_point,
-                                                  bool* lost_resource,
-                                                  bool* release_called,
-                                                  uint32* sync_point) {
+  ResourceId CreateChildMailbox(uint32* release_sync_point,
+                                bool* lost_resource,
+                                bool* release_called,
+                                uint32* sync_point) {
     if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) {
       unsigned texture = child_context_->createTexture();
       gpu::Mailbox gpu_mailbox;
@@ -518,7 +518,7 @@ void CheckCreateResource(ResourceProvider::ResourceType expected_default_type,
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
-  ResourceProvider::ResourceId id = resource_provider->CreateResource(
+  ResourceId id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   EXPECT_EQ(1, static_cast<int>(resource_provider->num_resources()));
   if (expected_default_type == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
@@ -549,7 +549,7 @@ TEST_P(ResourceProviderTest, Upload) {
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(16U, pixel_size);
 
-  ResourceProvider::ResourceId id = resource_provider_->CreateResource(
+  ResourceId id = resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
 
   uint8_t image[16] = { 0 };
@@ -616,7 +616,7 @@ TEST_P(ResourceProviderTest, SimpleUpload) {
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(16U, pixel_size);
 
-  ResourceProvider::ResourceId id = resource_provider_->CreateResource(
+  ResourceId id = resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
 
   uint8_t image[16] = {0};
@@ -650,17 +650,17 @@ TEST_P(ResourceProviderTest, TransferGLResources) {
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
-  ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
+  ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   child_resource_provider_->CopyToResource(id1, data1, size);
 
-  ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
+  ResourceId id2 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data2[4] = { 5, 5, 5, 5 };
   child_resource_provider_->CopyToResource(id2, data2, size);
 
-  ResourceProvider::ResourceId id3 = child_resource_provider_->CreateResource(
+  ResourceId id3 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   {
     ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock(
@@ -675,11 +675,10 @@ TEST_P(ResourceProviderTest, TransferGLResources) {
   child_context_->produceTextureDirectCHROMIUM(
       external_texture_id, GL_TEXTURE_EXTERNAL_OES, external_mailbox.name);
   const GLuint external_sync_point = child_context_->insertSyncPoint();
-  ResourceProvider::ResourceId id4 =
-      child_resource_provider_->CreateResourceFromTextureMailbox(
-          TextureMailbox(
-              external_mailbox, GL_TEXTURE_EXTERNAL_OES, external_sync_point),
-          SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
+  ResourceId id4 = child_resource_provider_->CreateResourceFromTextureMailbox(
+      TextureMailbox(external_mailbox, GL_TEXTURE_EXTERNAL_OES,
+                     external_sync_point),
+      SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
 
   ReturnedResourceArray returned_to_child;
   int child_id =
@@ -737,10 +736,10 @@ TEST_P(ResourceProviderTest, TransferGLResources) {
   EXPECT_EQ(4u, resource_provider_->num_resources());
   ResourceProvider::ResourceIdMap resource_map =
       resource_provider_->GetChildToParentMap(child_id);
-  ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
-  ResourceProvider::ResourceId mapped_id2 = resource_map[id2];
-  ResourceProvider::ResourceId mapped_id3 = resource_map[id3];
-  ResourceProvider::ResourceId mapped_id4 = resource_map[id4];
+  ResourceId mapped_id1 = resource_map[id1];
+  ResourceId mapped_id2 = resource_map[id2];
+  ResourceId mapped_id3 = resource_map[id3];
+  ResourceId mapped_id4 = resource_map[id4];
   EXPECT_NE(0u, mapped_id1);
   EXPECT_NE(0u, mapped_id2);
   EXPECT_NE(0u, mapped_id3);
@@ -909,12 +908,12 @@ TEST_P(ResourceProviderTestNoSyncPoint, TransferGLResources) {
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
-  ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
+  ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = {1, 2, 3, 4};
   child_resource_provider_->CopyToResource(id1, data1, size);
 
-  ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
+  ResourceId id2 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   {
     // Ensure locking the memory buffer doesn't create an unnecessary sync
@@ -932,11 +931,10 @@ TEST_P(ResourceProviderTestNoSyncPoint, TransferGLResources) {
   child_context_->produceTextureDirectCHROMIUM(
       external_texture_id, GL_TEXTURE_EXTERNAL_OES, external_mailbox.name);
   const GLuint external_sync_point = child_context_->insertSyncPoint();
-  ResourceProvider::ResourceId id3 =
-      child_resource_provider_->CreateResourceFromTextureMailbox(
-          TextureMailbox(external_mailbox, GL_TEXTURE_EXTERNAL_OES,
-                         external_sync_point),
-          SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
+  ResourceId id3 = child_resource_provider_->CreateResourceFromTextureMailbox(
+      TextureMailbox(external_mailbox, GL_TEXTURE_EXTERNAL_OES,
+                     external_sync_point),
+      SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
 
   ReturnedResourceArray returned_to_child;
   int child_id =
@@ -976,7 +974,7 @@ TEST_P(ResourceProviderTestNoSyncPoint, TransferGLResources) {
     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
 
     ASSERT_EQ(3u, returned_to_child.size());
-    std::map<ResourceProvider::ResourceId, unsigned int> returned_sync_points;
+    std::map<ResourceId, unsigned int> returned_sync_points;
     for (const auto& returned : returned_to_child)
       returned_sync_points[returned.id] = returned.sync_point;
 
@@ -1010,7 +1008,7 @@ TEST_P(ResourceProviderTest, ReadLockCountStopsReturnToChildOrDelete) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
 
-  ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
+  ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = {1, 2, 3, 4};
   child_resource_provider_->CopyToResource(id1, data1, size);
@@ -1065,17 +1063,15 @@ TEST_P(ResourceProviderTest, AllowOverlayTransfersToParent) {
   mailbox.set_allow_overlay(true);
   scoped_ptr<SingleReleaseCallbackImpl> release_callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
-  ResourceProvider::ResourceId id1 =
-      child_resource_provider_->CreateResourceFromTextureMailbox(
-          mailbox, release_callback.Pass());
+  ResourceId id1 = child_resource_provider_->CreateResourceFromTextureMailbox(
+      mailbox, release_callback.Pass());
 
   TextureMailbox mailbox2(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point);
   mailbox2.set_allow_overlay(false);
   scoped_ptr<SingleReleaseCallbackImpl> release_callback2 =
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
-  ResourceProvider::ResourceId id2 =
-      child_resource_provider_->CreateResourceFromTextureMailbox(
-          mailbox2, release_callback2.Pass());
+  ResourceId id2 = child_resource_provider_->CreateResourceFromTextureMailbox(
+      mailbox2, release_callback2.Pass());
 
   ReturnedResourceArray returned_to_child;
   int child_id =
@@ -1115,12 +1111,12 @@ TEST_P(ResourceProviderTest, TransferSoftwareResources) {
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
-  ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
+  ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   child_resource_provider_->CopyToResource(id1, data1, size);
 
-  ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
+  ResourceId id2 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data2[4] = { 5, 5, 5, 5 };
   child_resource_provider_->CopyToResource(id2, data2, size);
@@ -1128,11 +1124,10 @@ TEST_P(ResourceProviderTest, TransferSoftwareResources) {
   scoped_ptr<SharedBitmap> shared_bitmap(CreateAndFillSharedBitmap(
       shared_bitmap_manager_.get(), gfx::Size(1, 1), 0));
   SharedBitmap* shared_bitmap_ptr = shared_bitmap.get();
-  ResourceProvider::ResourceId id3 =
-      child_resource_provider_->CreateResourceFromTextureMailbox(
-          TextureMailbox(shared_bitmap_ptr, gfx::Size(1, 1)),
-          SingleReleaseCallbackImpl::Create(base::Bind(
-              &SharedBitmapReleaseCallback, base::Passed(&shared_bitmap))));
+  ResourceId id3 = child_resource_provider_->CreateResourceFromTextureMailbox(
+      TextureMailbox(shared_bitmap_ptr, gfx::Size(1, 1)),
+      SingleReleaseCallbackImpl::Create(base::Bind(
+          &SharedBitmapReleaseCallback, base::Passed(&shared_bitmap))));
 
   ReturnedResourceArray returned_to_child;
   int child_id =
@@ -1165,9 +1160,9 @@ TEST_P(ResourceProviderTest, TransferSoftwareResources) {
   EXPECT_EQ(3u, resource_provider_->num_resources());
   ResourceProvider::ResourceIdMap resource_map =
       resource_provider_->GetChildToParentMap(child_id);
-  ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
-  ResourceProvider::ResourceId mapped_id2 = resource_map[id2];
-  ResourceProvider::ResourceId mapped_id3 = resource_map[id3];
+  ResourceId mapped_id1 = resource_map[id1];
+  ResourceId mapped_id2 = resource_map[id2];
+  ResourceId mapped_id3 = resource_map[id3];
   EXPECT_NE(0u, mapped_id1);
   EXPECT_NE(0u, mapped_id2);
   EXPECT_NE(0u, mapped_id3);
@@ -1216,11 +1211,11 @@ TEST_P(ResourceProviderTest, TransferSoftwareResources) {
     EXPECT_EQ(0u, returned_to_child[0].sync_point);
     EXPECT_EQ(0u, returned_to_child[1].sync_point);
     EXPECT_EQ(0u, returned_to_child[2].sync_point);
-    std::set<ResourceProvider::ResourceId> expected_ids;
+    std::set<ResourceId> expected_ids;
     expected_ids.insert(id1);
     expected_ids.insert(id2);
     expected_ids.insert(id3);
-    std::set<ResourceProvider::ResourceId> returned_ids;
+    std::set<ResourceId> returned_ids;
     for (unsigned i = 0; i < 3; i++)
       returned_ids.insert(returned_to_child[i].id);
     EXPECT_EQ(expected_ids, returned_ids);
@@ -1285,11 +1280,11 @@ TEST_P(ResourceProviderTest, TransferSoftwareResources) {
   EXPECT_EQ(0u, returned_to_child[0].sync_point);
   EXPECT_EQ(0u, returned_to_child[1].sync_point);
   EXPECT_EQ(0u, returned_to_child[2].sync_point);
-  std::set<ResourceProvider::ResourceId> expected_ids;
+  std::set<ResourceId> expected_ids;
   expected_ids.insert(id1);
   expected_ids.insert(id2);
   expected_ids.insert(id3);
-  std::set<ResourceProvider::ResourceId> returned_ids;
+  std::set<ResourceId> returned_ids;
   for (unsigned i = 0; i < 3; i++)
     returned_ids.insert(returned_to_child[i].id);
   EXPECT_EQ(expected_ids, returned_ids);
@@ -1324,7 +1319,7 @@ TEST_P(ResourceProviderTest, TransferGLToSoftware) {
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
-  ResourceProvider::ResourceId id1 = child_resource_provider->CreateResource(
+  ResourceId id1 = child_resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   child_resource_provider->CopyToResource(id1, data1, size);
@@ -1351,7 +1346,7 @@ TEST_P(ResourceProviderTest, TransferGLToSoftware) {
   EXPECT_EQ(returned_to_child[0].id, id1);
   ResourceProvider::ResourceIdMap resource_map =
       resource_provider_->GetChildToParentMap(child_id);
-  ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
+  ResourceId mapped_id1 = resource_map[id1];
   EXPECT_EQ(0u, mapped_id1);
 
   resource_provider_->DestroyChild(child_id);
@@ -1370,7 +1365,7 @@ TEST_P(ResourceProviderTest, TransferInvalidSoftware) {
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
-  ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
+  ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   child_resource_provider_->CopyToResource(id1, data1, size);
@@ -1396,7 +1391,7 @@ TEST_P(ResourceProviderTest, TransferInvalidSoftware) {
 
   ResourceProvider::ResourceIdMap resource_map =
       resource_provider_->GetChildToParentMap(child_id);
-  ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
+  ResourceId mapped_id1 = resource_map[id1];
   EXPECT_NE(0u, mapped_id1);
   {
     ResourceProvider::ScopedReadLockSoftware lock(resource_provider_.get(),
@@ -1417,12 +1412,12 @@ TEST_P(ResourceProviderTest, DeleteExportedResources) {
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
-  ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
+  ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   child_resource_provider_->CopyToResource(id1, data1, size);
 
-  ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
+  ResourceId id2 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data2[4] = {5, 5, 5, 5};
   child_resource_provider_->CopyToResource(id2, data2, size);
@@ -1456,8 +1451,8 @@ TEST_P(ResourceProviderTest, DeleteExportedResources) {
   EXPECT_EQ(2u, resource_provider_->num_resources());
   ResourceProvider::ResourceIdMap resource_map =
       resource_provider_->GetChildToParentMap(child_id);
-  ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
-  ResourceProvider::ResourceId mapped_id2 = resource_map[id2];
+  ResourceId mapped_id1 = resource_map[id1];
+  ResourceId mapped_id2 = resource_map[id2];
   EXPECT_NE(0u, mapped_id1);
   EXPECT_NE(0u, mapped_id2);
   EXPECT_FALSE(resource_provider_->InUseByConsumer(id1));
@@ -1513,12 +1508,12 @@ TEST_P(ResourceProviderTest, DestroyChildWithExportedResources) {
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
-  ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
+  ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = {1, 2, 3, 4};
   child_resource_provider_->CopyToResource(id1, data1, size);
 
-  ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
+  ResourceId id2 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data2[4] = {5, 5, 5, 5};
   child_resource_provider_->CopyToResource(id2, data2, size);
@@ -1552,8 +1547,8 @@ TEST_P(ResourceProviderTest, DestroyChildWithExportedResources) {
   EXPECT_EQ(2u, resource_provider_->num_resources());
   ResourceProvider::ResourceIdMap resource_map =
       resource_provider_->GetChildToParentMap(child_id);
-  ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
-  ResourceProvider::ResourceId mapped_id2 = resource_map[id2];
+  ResourceId mapped_id1 = resource_map[id1];
+  ResourceId mapped_id2 = resource_map[id2];
   EXPECT_NE(0u, mapped_id1);
   EXPECT_NE(0u, mapped_id2);
   EXPECT_FALSE(resource_provider_->InUseByConsumer(id1));
@@ -1626,7 +1621,7 @@ TEST_P(ResourceProviderTest, DeleteTransferredResources) {
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
-  ResourceProvider::ResourceId id = child_resource_provider_->CreateResource(
+  ResourceId id = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data[4] = { 1, 2, 3, 4 };
   child_resource_provider_->CopyToResource(id, data, size);
@@ -1677,7 +1672,7 @@ TEST_P(ResourceProviderTest, UnuseTransferredResources) {
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
-  ResourceProvider::ResourceId id = child_resource_provider_->CreateResource(
+  ResourceId id = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data[4] = {1, 2, 3, 4};
   child_resource_provider_->CopyToResource(id, data, size);
@@ -1705,7 +1700,7 @@ TEST_P(ResourceProviderTest, UnuseTransferredResources) {
   {
     // Parent transfers to top-level.
     ASSERT_TRUE(map.find(id) != map.end());
-    ResourceProvider::ResourceId parent_id = map.find(id)->second;
+    ResourceId parent_id = map.find(id)->second;
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(parent_id);
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
@@ -1743,14 +1738,14 @@ TEST_P(ResourceProviderTest, UnuseTransferredResources) {
     // in the parent.
     EXPECT_TRUE(returned_to_child.empty());
     ASSERT_TRUE(map.find(id) != map.end());
-    ResourceProvider::ResourceId parent_id = map.find(id)->second;
+    ResourceId parent_id = map.find(id)->second;
     EXPECT_FALSE(resource_provider_->InUseByConsumer(parent_id));
   }
   {
     sent_to_top_level.clear();
     // Parent transfers again to top-level.
     ASSERT_TRUE(map.find(id) != map.end());
-    ResourceProvider::ResourceId parent_id = map.find(id)->second;
+    ResourceId parent_id = map.find(id)->second;
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(parent_id);
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
@@ -1766,7 +1761,7 @@ TEST_P(ResourceProviderTest, UnuseTransferredResources) {
     // declared used in the parent.
     EXPECT_TRUE(returned_to_child.empty());
     ASSERT_TRUE(map.find(id) != map.end());
-    ResourceProvider::ResourceId parent_id = map.find(id)->second;
+    ResourceId parent_id = map.find(id)->second;
     EXPECT_FALSE(resource_provider_->InUseByConsumer(parent_id));
   }
   {
@@ -1833,7 +1828,7 @@ class ResourceProviderTestTextureFilters : public ResourceProviderTest {
     size_t pixel_size = TextureSizeBytes(size, format);
     ASSERT_EQ(4U, pixel_size);
 
-    ResourceProvider::ResourceId id = child_resource_provider->CreateResource(
+    ResourceId id = child_resource_provider->CreateResource(
         size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
         format);
 
@@ -1915,7 +1910,7 @@ class ResourceProviderTestTextureFilters : public ResourceProviderTest {
     }
     ResourceProvider::ResourceIdMap resource_map =
         parent_resource_provider->GetChildToParentMap(child_id);
-    ResourceProvider::ResourceId mapped_id = resource_map[id];
+    ResourceId mapped_id = resource_map[id];
     EXPECT_NE(0u, mapped_id);
 
     // The texture is set to |parent_filter| in the parent.
@@ -1997,10 +1992,9 @@ TEST_P(ResourceProviderTest, TransferMailboxResources) {
                                             &release_sync_point,
                                             &lost_resource,
                                             &main_thread_task_runner);
-  ResourceProvider::ResourceId resource =
-      resource_provider_->CreateResourceFromTextureMailbox(
-          TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
-          SingleReleaseCallbackImpl::Create(callback));
+  ResourceId resource = resource_provider_->CreateResourceFromTextureMailbox(
+      TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
+      SingleReleaseCallbackImpl::Create(callback));
   EXPECT_EQ(1u, context()->NumTextures());
   EXPECT_EQ(0u, release_sync_point);
   {
@@ -2107,10 +2101,8 @@ TEST_P(ResourceProviderTest, TransferMailboxResources) {
 TEST_P(ResourceProviderTest, LostResourceInParent) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
-  ResourceProvider::ResourceId resource =
-      child_resource_provider_->CreateResource(
-          size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
-          format);
+  ResourceId resource = child_resource_provider_->CreateResource(
+      size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   child_resource_provider_->AllocateForTesting(resource);
   // Expect a GL resource to be lost.
   bool should_lose_resource =
@@ -2164,10 +2156,8 @@ TEST_P(ResourceProviderTest, LostResourceInParent) {
 TEST_P(ResourceProviderTest, LostResourceInGrandParent) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
-  ResourceProvider::ResourceId resource =
-      child_resource_provider_->CreateResource(
-          size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
-          format);
+  ResourceId resource = child_resource_provider_->CreateResource(
+      size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   child_resource_provider_->AllocateForTesting(resource);
 
   ReturnedResourceArray returned_to_child;
@@ -2192,7 +2182,7 @@ TEST_P(ResourceProviderTest, LostResourceInGrandParent) {
   {
     ResourceProvider::ResourceIdMap resource_map =
         resource_provider_->GetChildToParentMap(child_id);
-    ResourceProvider::ResourceId parent_resource = resource_map[resource];
+    ResourceId parent_resource = resource_map[resource];
     EXPECT_NE(0u, parent_resource);
 
     // Transfer to a grandparent.
@@ -2245,8 +2235,8 @@ TEST_P(ResourceProviderTest, LostMailboxInParent) {
   bool lost_resource = false;
   bool release_called = false;
   uint32 sync_point = 0;
-  ResourceProvider::ResourceId resource = CreateChildMailbox(
-      &release_sync_point, &lost_resource, &release_called, &sync_point);
+  ResourceId resource = CreateChildMailbox(&release_sync_point, &lost_resource,
+                                           &release_called, &sync_point);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
@@ -2298,8 +2288,8 @@ TEST_P(ResourceProviderTest, LostMailboxInGrandParent) {
   bool lost_resource = false;
   bool release_called = false;
   uint32 sync_point = 0;
-  ResourceProvider::ResourceId resource = CreateChildMailbox(
-      &release_sync_point, &lost_resource, &release_called, &sync_point);
+  ResourceId resource = CreateChildMailbox(&release_sync_point, &lost_resource,
+                                           &release_called, &sync_point);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
@@ -2323,7 +2313,7 @@ TEST_P(ResourceProviderTest, LostMailboxInGrandParent) {
   {
     ResourceProvider::ResourceIdMap resource_map =
         resource_provider_->GetChildToParentMap(child_id);
-    ResourceProvider::ResourceId parent_resource = resource_map[resource];
+    ResourceId parent_resource = resource_map[resource];
     EXPECT_NE(0u, parent_resource);
 
     // Transfer to a grandparent.
@@ -2388,8 +2378,8 @@ TEST_P(ResourceProviderTest, ShutdownWithExportedResource) {
   bool lost_resource = false;
   bool release_called = false;
   uint32 sync_point = 0;
-  ResourceProvider::ResourceId resource = CreateChildMailbox(
-      &release_sync_point, &lost_resource, &release_called, &sync_point);
+  ResourceId resource = CreateChildMailbox(&release_sync_point, &lost_resource,
+                                           &release_called, &sync_point);
 
   // Transfer the resource, so we can't release it properly on shutdown.
   ResourceProvider::ResourceIdArray resource_ids_to_transfer;
@@ -2471,7 +2461,7 @@ TEST_P(ResourceProviderTest, ScopedSampler) {
   ResourceFormat format = RGBA_8888;
   int texture_id = 1;
 
-  ResourceProvider::ResourceId id = resource_provider->CreateResource(
+  ResourceId id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
 
   // Check that the texture gets created with the right sampler settings.
@@ -2559,7 +2549,7 @@ TEST_P(ResourceProviderTest, ManagedResource) {
   int texture_id = 1;
 
   // Check that the texture gets created with the right sampler settings.
-  ResourceProvider::ResourceId id = resource_provider->CreateManagedResource(
+  ResourceId id = resource_provider->CreateManagedResource(
       size, GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
@@ -2613,7 +2603,7 @@ TEST_P(ResourceProviderTest, TextureWrapMode) {
   for (int texture_id = 1; texture_id <= 2; ++texture_id) {
     GLint wrap_mode = texture_id == 1 ? GL_CLAMP_TO_EDGE : GL_REPEAT;
     // Check that the texture gets created with the right sampler settings.
-    ResourceProvider::ResourceId id = resource_provider->CreateGLTexture(
+    ResourceId id = resource_provider->CreateGLTexture(
         size, GL_TEXTURE_2D, texture_pool, wrap_mode,
         ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
     EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
@@ -2673,13 +2663,9 @@ TEST_P(ResourceProviderTest, TextureHint) {
   };
   for (GLuint texture_id = 1; texture_id <= arraysize(hints); ++texture_id) {
     // Check that the texture gets created with the right sampler settings.
-    ResourceProvider::ResourceId id =
-        resource_provider->CreateGLTexture(size,
-                                           GL_TEXTURE_2D,
-                                           texture_pool,
-                                           GL_CLAMP_TO_EDGE,
-                                           hints[texture_id - 1],
-                                           format);
+    ResourceId id = resource_provider->CreateGLTexture(
+        size, GL_TEXTURE_2D, texture_pool, GL_CLAMP_TO_EDGE,
+        hints[texture_id - 1], format);
     EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
     EXPECT_CALL(*context,
                 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
@@ -2744,9 +2730,8 @@ TEST_P(ResourceProviderTest, TextureMailbox_SharedMemory) {
                                                    &main_thread_task_runner));
   TextureMailbox mailbox(shared_bitmap.get(), size);
 
-  ResourceProvider::ResourceId id =
-      resource_provider->CreateResourceFromTextureMailbox(
-          mailbox, callback.Pass());
+  ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
+      mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   {
@@ -2813,9 +2798,8 @@ class ResourceProviderTestTextureMailboxGLFilters
     TextureMailbox mailbox(gpu_mailbox, target, sync_point);
     mailbox.set_nearest_neighbor(mailbox_nearest_neighbor);
 
-    ResourceProvider::ResourceId id =
-        resource_provider->CreateResourceFromTextureMailbox(mailbox,
-                                                            callback.Pass());
+    ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
+        mailbox, callback.Pass());
     EXPECT_NE(0u, id);
 
     Mock::VerifyAndClearExpectations(context);
@@ -2954,9 +2938,8 @@ TEST_P(ResourceProviderTest, TextureMailbox_GLTextureExternalOES) {
 
   TextureMailbox mailbox(gpu_mailbox, target, sync_point);
 
-  ResourceProvider::ResourceId id =
-      resource_provider->CreateResourceFromTextureMailbox(
-          mailbox, callback.Pass());
+  ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
+      mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
@@ -3029,9 +3012,8 @@ TEST_P(ResourceProviderTest,
 
   TextureMailbox mailbox(gpu_mailbox, target, sync_point);
 
-  ResourceProvider::ResourceId id =
-      resource_provider->CreateResourceFromTextureMailbox(mailbox,
-                                                          callback.Pass());
+  ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
+      mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
@@ -3088,9 +3070,8 @@ TEST_P(ResourceProviderTest, TextureMailbox_WaitSyncPointIfNeeded_NoSyncPoint) {
 
   TextureMailbox mailbox(gpu_mailbox, target, sync_point);
 
-  ResourceProvider::ResourceId id =
-      resource_provider->CreateResourceFromTextureMailbox(mailbox,
-                                                          callback.Pass());
+  ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
+      mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
@@ -3201,7 +3182,7 @@ TEST_P(ResourceProviderTest, TextureAllocation) {
   gfx::Size size(2, 2);
   gfx::Vector2d offset(0, 0);
   ResourceFormat format = RGBA_8888;
-  ResourceProvider::ResourceId id = 0;
+  ResourceId id = 0;
   uint8_t pixels[16] = { 0 };
   int texture_id = 123;
 
@@ -3289,7 +3270,7 @@ TEST_P(ResourceProviderTest, TextureAllocationHint) {
   for (size_t i = 0; i < arraysize(formats); ++i) {
     for (GLuint texture_id = 1; texture_id <= arraysize(hints); ++texture_id) {
       // Lazy allocation. Don't allocate when creating the resource.
-      ResourceProvider::ResourceId id = resource_provider->CreateResource(
+      ResourceId id = resource_provider->CreateResource(
           size, GL_CLAMP_TO_EDGE, hints[texture_id - 1], formats[i]);
 
       EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
@@ -3349,7 +3330,7 @@ TEST_P(ResourceProviderTest, TextureAllocationHint_BGRA) {
   for (size_t i = 0; i < arraysize(formats); ++i) {
     for (GLuint texture_id = 1; texture_id <= arraysize(hints); ++texture_id) {
       // Lazy allocation. Don't allocate when creating the resource.
-      ResourceProvider::ResourceId id = resource_provider->CreateResource(
+      ResourceId id = resource_provider->CreateResource(
           size, GL_CLAMP_TO_EDGE, hints[texture_id - 1], formats[i]);
 
       EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
@@ -3384,7 +3365,7 @@ TEST_P(ResourceProviderTest, PixelBuffer_GLTexture) {
 
   gfx::Size size(2, 2);
   ResourceFormat format = RGBA_8888;
-  ResourceProvider::ResourceId id = 0;
+  ResourceId id = 0;
   int texture_id = 123;
 
   scoped_ptr<ResourceProvider> resource_provider(
@@ -3431,7 +3412,7 @@ TEST_P(ResourceProviderTest, ForcingAsyncUploadToComplete) {
 
   gfx::Size size(2, 2);
   ResourceFormat format = RGBA_8888;
-  ResourceProvider::ResourceId id = 0;
+  ResourceId id = 0;
   int texture_id = 123;
 
   scoped_ptr<ResourceProvider> resource_provider(
@@ -3478,7 +3459,7 @@ TEST_P(ResourceProviderTest, PixelBufferLostContext) {
 
   gfx::Size size(2, 2);
   ResourceFormat format = RGBA_8888;
-  ResourceProvider::ResourceId id = 0;
+  ResourceId id = 0;
   int texture_id = 123;
 
   scoped_ptr<ResourceProvider> resource_provider(
@@ -3522,7 +3503,7 @@ TEST_P(ResourceProviderTest, Image_GLTexture) {
   const int kHeight = 2;
   gfx::Size size(kWidth, kHeight);
   ResourceFormat format = RGBA_8888;
-  ResourceProvider::ResourceId id = 0;
+  ResourceId id = 0;
   const unsigned kTextureId = 123u;
   const unsigned kImageId = 234u;
 
@@ -3607,8 +3588,8 @@ TEST_P(ResourceProviderTest, CopyResource_GLTexture) {
   const int kHeight = 2;
   gfx::Size size(kWidth, kHeight);
   ResourceFormat format = RGBA_8888;
-  ResourceProvider::ResourceId source_id = 0;
-  ResourceProvider::ResourceId dest_id = 0;
+  ResourceId source_id = 0;
+  ResourceId dest_id = 0;
   const unsigned kSourceTextureId = 123u;
   const unsigned kDestTextureId = 321u;
   const unsigned kImageId = 234u;
@@ -3698,7 +3679,7 @@ TEST_P(ResourceProviderTest, CompressedTextureETC1Allocate) {
                                1));
   int texture_id = 123;
 
-  ResourceProvider::ResourceId id = resource_provider->CreateResource(
+  ResourceId id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, ETC1);
   EXPECT_NE(0u, id);
   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
@@ -3735,7 +3716,7 @@ TEST_P(ResourceProviderTest, CompressedTextureETC1Upload) {
   int texture_id = 123;
   uint8_t pixels[8];
 
-  ResourceProvider::ResourceId id = resource_provider->CreateResource(
+  ResourceId id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, ETC1);
   EXPECT_NE(0u, id);
   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
@@ -3794,7 +3775,7 @@ TEST(ResourceProviderTest, TextureAllocationChunkSize) {
                                  false,
                                  kTextureAllocationChunkSize));
 
-    ResourceProvider::ResourceId id = resource_provider->CreateResource(
+    ResourceId id = resource_provider->CreateResource(
         size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
         format);
     resource_provider->AllocateForTesting(id);
@@ -3815,7 +3796,7 @@ TEST(ResourceProviderTest, TextureAllocationChunkSize) {
                                  false,
                                  kTextureAllocationChunkSize));
 
-    ResourceProvider::ResourceId id = resource_provider->CreateResource(
+    ResourceId id = resource_provider->CreateResource(
         size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
         format);
     resource_provider->AllocateForTesting(id);
diff --git a/cc/resources/returned_resource.h b/cc/resources/returned_resource.h
index e2008b4..767d16f 100644
--- a/cc/resources/returned_resource.h
+++ b/cc/resources/returned_resource.h
@@ -9,12 +9,13 @@
 
 #include "base/basictypes.h"
 #include "cc/base/cc_export.h"
+#include "cc/base/resource_id.h"
 
 namespace cc {
 
 struct CC_EXPORT ReturnedResource {
   ReturnedResource() : id(0), sync_point(0), count(0), lost(false) {}
-  unsigned id;
+  ResourceId id;
   unsigned sync_point;
   int count;
   bool lost;
diff --git a/cc/resources/transferable_resource.h b/cc/resources/transferable_resource.h
index 03b47e6..7bb0b8f 100644
--- a/cc/resources/transferable_resource.h
+++ b/cc/resources/transferable_resource.h
@@ -9,6 +9,7 @@
 
 #include "base/basictypes.h"
 #include "cc/base/cc_export.h"
+#include "cc/base/resource_id.h"
 #include "cc/resources/resource_format.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "ui/gfx/geometry/size.h"
@@ -28,7 +29,7 @@ struct CC_EXPORT TransferableResource {
   static void ReturnResources(const TransferableResourceArray& input,
                               ReturnedResourceArray* output);
 
-  unsigned id;
+  ResourceId id;
   ResourceFormat format;
   uint32 filter;
   gfx::Size size;
diff --git a/cc/resources/video_resource_updater.cc b/cc/resources/video_resource_updater.cc
index 06fb692..427fb2d 100644
--- a/cc/resources/video_resource_updater.cc
+++ b/cc/resources/video_resource_updater.cc
@@ -106,10 +106,9 @@ VideoResourceUpdater::AllocateResource(const gfx::Size& plane_size,
                                        bool has_mailbox) {
   // TODO(danakj): Abstract out hw/sw resource create/delete from
   // ResourceProvider and stop using ResourceProvider in this class.
-  const ResourceProvider::ResourceId resource_id =
-      resource_provider_->CreateResource(
-          plane_size, GL_CLAMP_TO_EDGE,
-          ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
+  const ResourceId resource_id = resource_provider_->CreateResource(
+      plane_size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      format);
   if (resource_id == 0)
     return all_resources_.end();
 
@@ -455,7 +454,7 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
 // static
 void VideoResourceUpdater::RecycleResource(
     base::WeakPtr<VideoResourceUpdater> updater,
-    ResourceProvider::ResourceId resource_id,
+    ResourceId resource_id,
     uint32 sync_point,
     bool lost_resource,
     BlockingTaskRunner* main_thread_task_runner) {
diff --git a/cc/surfaces/surface_aggregator.cc b/cc/surfaces/surface_aggregator.cc
index 941e2d8..f2d5c27 100644
--- a/cc/surfaces/surface_aggregator.cc
+++ b/cc/surfaces/surface_aggregator.cc
@@ -131,23 +131,23 @@ int SurfaceAggregator::ChildIdForSurface(Surface* surface) {
   }
 }
 
-static ResourceProvider::ResourceId ResourceRemapHelper(
+static ResourceId ResourceRemapHelper(
     const ResourceProvider::ResourceIdMap& child_to_parent_map,
-    ResourceProvider::ResourceId id) {
+    ResourceId id) {
   ResourceProvider::ResourceIdMap::const_iterator it =
       child_to_parent_map.find(id);
   DCHECK(it != child_to_parent_map.end());
 
   DCHECK_EQ(it->first, id);
-  ResourceProvider::ResourceId remapped_id = it->second;
+  ResourceId remapped_id = it->second;
   return remapped_id;
 }
 
-static ResourceProvider::ResourceId ValidateResourceHelper(
+static ResourceId ValidateResourceHelper(
     bool* invalid_frame,
     const ResourceProvider::ResourceIdMap& child_to_parent_map,
     ResourceProvider::ResourceIdSet* resources_in_frame,
-    ResourceProvider::ResourceId id) {
+    ResourceId id) {
   ResourceProvider::ResourceIdMap::const_iterator it =
       child_to_parent_map.find(id);
   if (it == child_to_parent_map.end()) {
diff --git a/cc/surfaces/surface_aggregator_unittest.cc b/cc/surfaces/surface_aggregator_unittest.cc
index 40a3d57..12619b5 100644
--- a/cc/surfaces/surface_aggregator_unittest.cc
+++ b/cc/surfaces/surface_aggregator_unittest.cc
@@ -1320,7 +1320,7 @@ class ResourceTrackingSurfaceFactoryClient : public SurfaceFactoryClient {
   DISALLOW_COPY_AND_ASSIGN(ResourceTrackingSurfaceFactoryClient);
 };
 
-void SubmitFrameWithResources(ResourceProvider::ResourceId* resource_ids,
+void SubmitFrameWithResources(ResourceId* resource_ids,
                               size_t num_resource_ids,
                               bool valid,
                               SurfaceId child_id,
@@ -1383,7 +1383,7 @@ TEST_F(SurfaceAggregatorWithResourcesTest, TakeResourcesOneSurface) {
   SurfaceId surface_id(7u);
   factory.Create(surface_id);
 
-  ResourceProvider::ResourceId ids[] = {11, 12, 13};
+  ResourceId ids[] = {11, 12, 13};
   SubmitFrameWithResources(ids, arraysize(ids), true, SurfaceId(), &factory,
                            surface_id);
 
@@ -1397,7 +1397,7 @@ TEST_F(SurfaceAggregatorWithResourcesTest, TakeResourcesOneSurface) {
   frame = aggregator_->Aggregate(surface_id);
 
   ASSERT_EQ(3u, client.returned_resources().size());
-  ResourceProvider::ResourceId returned_ids[3];
+  ResourceId returned_ids[3];
   for (size_t i = 0; i < 3; ++i) {
     returned_ids[i] = client.returned_resources()[i].id;
   }
@@ -1447,10 +1447,10 @@ TEST_F(SurfaceAggregatorWithResourcesTest, TwoSurfaces) {
   SurfaceId surface_id2(8u);
   factory.Create(surface_id2);
 
-  ResourceProvider::ResourceId ids[] = {11, 12, 13};
+  ResourceId ids[] = {11, 12, 13};
   SubmitFrameWithResources(ids, arraysize(ids), true, SurfaceId(), &factory,
                            surface_id);
-  ResourceProvider::ResourceId ids2[] = {14, 15, 16};
+  ResourceId ids2[] = {14, 15, 16};
   SubmitFrameWithResources(ids2, arraysize(ids2), true, SurfaceId(), &factory,
                            surface_id2);
 
@@ -1465,7 +1465,7 @@ TEST_F(SurfaceAggregatorWithResourcesTest, TwoSurfaces) {
 
   // surface_id wasn't referenced, so its resources should be returned.
   ASSERT_EQ(3u, client.returned_resources().size());
-  ResourceProvider::ResourceId returned_ids[3];
+  ResourceId returned_ids[3];
   for (size_t i = 0; i < 3; ++i) {
     returned_ids[i] = client.returned_resources()[i].id;
   }
@@ -1488,15 +1488,15 @@ TEST_F(SurfaceAggregatorWithResourcesTest, InvalidChildSurface) {
   SurfaceId child_surface_id(9u);
   factory.Create(child_surface_id);
 
-  ResourceProvider::ResourceId ids[] = {14, 15, 16};
+  ResourceId ids[] = {14, 15, 16};
   SubmitFrameWithResources(ids, arraysize(ids), true, SurfaceId(), &factory,
                            child_surface_id);
 
-  ResourceProvider::ResourceId ids2[] = {17, 18, 19};
+  ResourceId ids2[] = {17, 18, 19};
   SubmitFrameWithResources(ids2, arraysize(ids2), false, child_surface_id,
                            &factory, middle_surface_id);
 
-  ResourceProvider::ResourceId ids3[] = {20, 21, 22};
+  ResourceId ids3[] = {20, 21, 22};
   SubmitFrameWithResources(ids3, arraysize(ids3), true, middle_surface_id,
                            &factory, root_surface_id);
 
diff --git a/cc/surfaces/surface_factory_unittest.cc b/cc/surfaces/surface_factory_unittest.cc
index b9c6bf5..af97f91 100644
--- a/cc/surfaces/surface_factory_unittest.cc
+++ b/cc/surfaces/surface_factory_unittest.cc
@@ -5,6 +5,7 @@
 #include "base/bind.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
+#include "cc/resources/resource_provider.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_factory_client.h"
@@ -48,7 +49,7 @@ class SurfaceFactoryTest : public testing::Test {
       factory_.Destroy(surface_id_);
   }
 
-  void SubmitFrameWithResources(ResourceProvider::ResourceId* resource_ids,
+  void SubmitFrameWithResources(ResourceId* resource_ids,
                                 size_t num_resource_ids) {
     scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     for (size_t i = 0u; i < num_resource_ids; ++i) {
@@ -63,7 +64,7 @@ class SurfaceFactoryTest : public testing::Test {
                          SurfaceFactory::DrawCallback());
   }
 
-  void UnrefResources(ResourceProvider::ResourceId* ids_to_unref,
+  void UnrefResources(ResourceId* ids_to_unref,
                       int* counts_to_unref,
                       size_t num_ids_to_unref) {
     ReturnedResourceArray unref_array;
@@ -76,10 +77,9 @@ class SurfaceFactoryTest : public testing::Test {
     factory_.UnrefResources(unref_array);
   }
 
-  void CheckReturnedResourcesMatchExpected(
-      ResourceProvider::ResourceId* expected_returned_ids,
-      int* expected_returned_counts,
-      size_t expected_resources) {
+  void CheckReturnedResourcesMatchExpected(ResourceId* expected_returned_ids,
+                                           int* expected_returned_counts,
+                                           size_t expected_resources) {
     const ReturnedResourceArray& actual_resources =
         client_.returned_resources();
     ASSERT_EQ(expected_resources, actual_resources.size());
@@ -107,7 +107,7 @@ class SurfaceFactoryTest : public testing::Test {
 // Tests submitting a frame with resources followed by one with no resources
 // with no resource provider action in between.
 TEST_F(SurfaceFactoryTest, ResourceLifetimeSimple) {
-  ResourceProvider::ResourceId first_frame_ids[] = {1, 2, 3};
+  ResourceId first_frame_ids[] = {1, 2, 3};
   SubmitFrameWithResources(first_frame_ids, arraysize(first_frame_ids));
 
   // All of the resources submitted in the first frame are still in use at this
@@ -120,7 +120,7 @@ TEST_F(SurfaceFactoryTest, ResourceLifetimeSimple) {
   // available to be returned.
   SubmitFrameWithResources(NULL, 0);
 
-  ResourceProvider::ResourceId expected_returned_ids[] = {1, 2, 3};
+  ResourceId expected_returned_ids[] = {1, 2, 3};
   int expected_returned_counts[] = {1, 1, 1};
   CheckReturnedResourcesMatchExpected(expected_returned_ids,
                                       expected_returned_counts,
@@ -130,7 +130,7 @@ TEST_F(SurfaceFactoryTest, ResourceLifetimeSimple) {
 // Tests submitting a frame with resources followed by one with no resources
 // with the resource provider holding everything alive.
 TEST_F(SurfaceFactoryTest, ResourceLifetimeSimpleWithProviderHoldingAlive) {
-  ResourceProvider::ResourceId first_frame_ids[] = {1, 2, 3};
+  ResourceId first_frame_ids[] = {1, 2, 3};
   SubmitFrameWithResources(first_frame_ids, arraysize(first_frame_ids));
 
   // All of the resources submitted in the first frame are still in use at this
@@ -152,7 +152,7 @@ TEST_F(SurfaceFactoryTest, ResourceLifetimeSimpleWithProviderHoldingAlive) {
   int release_counts[] = {1, 1, 1};
   UnrefResources(first_frame_ids, release_counts, arraysize(first_frame_ids));
 
-  ResourceProvider::ResourceId expected_returned_ids[] = {1, 2, 3};
+  ResourceId expected_returned_ids[] = {1, 2, 3};
   int expected_returned_counts[] = {1, 1, 1};
   CheckReturnedResourcesMatchExpected(expected_returned_ids,
                                       expected_returned_counts,
@@ -162,7 +162,7 @@ TEST_F(SurfaceFactoryTest, ResourceLifetimeSimpleWithProviderHoldingAlive) {
 // Tests referencing a resource, unref'ing it to zero, then using it again
 // before returning it to the client.
 TEST_F(SurfaceFactoryTest, ResourceReusedBeforeReturn) {
-  ResourceProvider::ResourceId first_frame_ids[] = {7};
+  ResourceId first_frame_ids[] = {7};
   SubmitFrameWithResources(first_frame_ids, arraysize(first_frame_ids));
 
   // This removes all references to resource id 7.
@@ -189,14 +189,14 @@ TEST_F(SurfaceFactoryTest, ResourceReusedBeforeReturn) {
 // Tests having resources referenced multiple times, as if referenced by
 // multiple providers.
 TEST_F(SurfaceFactoryTest, ResourceRefMultipleTimes) {
-  ResourceProvider::ResourceId first_frame_ids[] = {3, 4};
+  ResourceId first_frame_ids[] = {3, 4};
   SubmitFrameWithResources(first_frame_ids, arraysize(first_frame_ids));
 
   // Ref resources from the first frame twice.
   RefCurrentFrameResources();
   RefCurrentFrameResources();
 
-  ResourceProvider::ResourceId second_frame_ids[] = {4, 5};
+  ResourceId second_frame_ids[] = {4, 5};
   SubmitFrameWithResources(second_frame_ids, arraysize(second_frame_ids));
 
   // Ref resources from the second frame 3 times.
@@ -217,7 +217,7 @@ TEST_F(SurfaceFactoryTest, ResourceRefMultipleTimes) {
   //  5 -> 3
   {
     SCOPED_TRACE("unref all 3");
-    ResourceProvider::ResourceId ids_to_unref[] = {3, 4, 5};
+    ResourceId ids_to_unref[] = {3, 4, 5};
     int counts[] = {1, 1, 1};
     UnrefResources(ids_to_unref, counts, arraysize(ids_to_unref));
 
@@ -226,7 +226,7 @@ TEST_F(SurfaceFactoryTest, ResourceRefMultipleTimes) {
 
     UnrefResources(ids_to_unref, counts, arraysize(ids_to_unref));
 
-    ResourceProvider::ResourceId expected_returned_ids[] = {3};
+    ResourceId expected_returned_ids[] = {3};
     int expected_returned_counts[] = {1};
     CheckReturnedResourcesMatchExpected(expected_returned_ids,
                                         expected_returned_counts,
@@ -238,11 +238,11 @@ TEST_F(SurfaceFactoryTest, ResourceRefMultipleTimes) {
   //  5 -> 1
   {
     SCOPED_TRACE("unref 4 and 5");
-    ResourceProvider::ResourceId ids_to_unref[] = {4, 5};
+    ResourceId ids_to_unref[] = {4, 5};
     int counts[] = {1, 1};
     UnrefResources(ids_to_unref, counts, arraysize(ids_to_unref));
 
-    ResourceProvider::ResourceId expected_returned_ids[] = {5};
+    ResourceId expected_returned_ids[] = {5};
     int expected_returned_counts[] = {1};
     CheckReturnedResourcesMatchExpected(expected_returned_ids,
                                         expected_returned_counts,
@@ -253,11 +253,11 @@ TEST_F(SurfaceFactoryTest, ResourceRefMultipleTimes) {
   // the returned count is correct.
   {
     SCOPED_TRACE("unref only 4");
-    ResourceProvider::ResourceId ids_to_unref[] = {4};
+    ResourceId ids_to_unref[] = {4};
     int counts[] = {2};
     UnrefResources(ids_to_unref, counts, arraysize(ids_to_unref));
 
-    ResourceProvider::ResourceId expected_returned_ids[] = {4};
+    ResourceId expected_returned_ids[] = {4};
     int expected_returned_counts[] = {2};
     CheckReturnedResourcesMatchExpected(expected_returned_ids,
                                         expected_returned_counts,
@@ -266,7 +266,7 @@ TEST_F(SurfaceFactoryTest, ResourceRefMultipleTimes) {
 }
 
 TEST_F(SurfaceFactoryTest, ResourceLifetime) {
-  ResourceProvider::ResourceId first_frame_ids[] = {1, 2, 3};
+  ResourceId first_frame_ids[] = {1, 2, 3};
   SubmitFrameWithResources(first_frame_ids, arraysize(first_frame_ids));
 
   // All of the resources submitted in the first frame are still in use at this
@@ -278,12 +278,12 @@ TEST_F(SurfaceFactoryTest, ResourceLifetime) {
   // The second frame references some of the same resources, but some different
   // ones. We expect to receive back resource 1 with a count of 1 since it was
   // only referenced by the first frame.
-  ResourceProvider::ResourceId second_frame_ids[] = {2, 3, 4};
+  ResourceId second_frame_ids[] = {2, 3, 4};
   SubmitFrameWithResources(second_frame_ids, arraysize(second_frame_ids));
 
   {
     SCOPED_TRACE("second frame");
-    ResourceProvider::ResourceId expected_returned_ids[] = {1};
+    ResourceId expected_returned_ids[] = {1};
     int expected_returned_counts[] = {1};
     CheckReturnedResourcesMatchExpected(expected_returned_ids,
                                         expected_returned_counts,
@@ -294,12 +294,12 @@ TEST_F(SurfaceFactoryTest, ResourceLifetime) {
   // receive back all resources from the first and second frames. Resource IDs 2
   // and 3 will have counts of 2, since they were used in both frames, and
   // resource ID 4 will have a count of 1.
-  ResourceProvider::ResourceId third_frame_ids[] = {10, 11, 12, 13};
+  ResourceId third_frame_ids[] = {10, 11, 12, 13};
   SubmitFrameWithResources(third_frame_ids, arraysize(third_frame_ids));
 
   {
     SCOPED_TRACE("third frame");
-    ResourceProvider::ResourceId expected_returned_ids[] = {2, 3, 4};
+    ResourceId expected_returned_ids[] = {2, 3, 4};
     int expected_returned_counts[] = {2, 2, 1};
     CheckReturnedResourcesMatchExpected(expected_returned_ids,
                                         expected_returned_counts,
@@ -309,7 +309,7 @@ TEST_F(SurfaceFactoryTest, ResourceLifetime) {
   // Simulate a ResourceProvider taking a ref on all of the resources.
   RefCurrentFrameResources();
 
-  ResourceProvider::ResourceId fourth_frame_ids[] = {12, 13};
+  ResourceId fourth_frame_ids[] = {12, 13};
   SubmitFrameWithResources(fourth_frame_ids, arraysize(fourth_frame_ids));
 
   EXPECT_EQ(0u, client_.returned_resources().size());
@@ -323,14 +323,14 @@ TEST_F(SurfaceFactoryTest, ResourceLifetime) {
   // Release resources associated with the first RefCurrentFrameResources() call
   // first.
   {
-    ResourceProvider::ResourceId ids_to_unref[] = {10, 11, 12, 13};
+    ResourceId ids_to_unref[] = {10, 11, 12, 13};
     int counts[] = {1, 1, 1, 1};
     UnrefResources(ids_to_unref, counts, arraysize(ids_to_unref));
   }
 
   {
     SCOPED_TRACE("fourth frame, first unref");
-    ResourceProvider::ResourceId expected_returned_ids[] = {10, 11};
+    ResourceId expected_returned_ids[] = {10, 11};
     int expected_returned_counts[] = {1, 1};
     CheckReturnedResourcesMatchExpected(expected_returned_ids,
                                         expected_returned_counts,
@@ -338,7 +338,7 @@ TEST_F(SurfaceFactoryTest, ResourceLifetime) {
   }
 
   {
-    ResourceProvider::ResourceId ids_to_unref[] = {12, 13};
+    ResourceId ids_to_unref[] = {12, 13};
     int counts[] = {1, 1};
     UnrefResources(ids_to_unref, counts, arraysize(ids_to_unref));
   }
@@ -352,7 +352,7 @@ TEST_F(SurfaceFactoryTest, ResourceLifetime) {
 
   {
     SCOPED_TRACE("fourth frame, second unref");
-    ResourceProvider::ResourceId expected_returned_ids[] = {12, 13};
+    ResourceId expected_returned_ids[] = {12, 13};
     int expected_returned_counts[] = {2, 2};
     CheckReturnedResourcesMatchExpected(expected_returned_ids,
                                         expected_returned_counts,
diff --git a/cc/surfaces/surface_resource_holder.cc b/cc/surfaces/surface_resource_holder.cc
index 50d31a5..c257b60 100644
--- a/cc/surfaces/surface_resource_holder.cc
+++ b/cc/surfaces/surface_resource_holder.cc
@@ -49,7 +49,7 @@ void SurfaceResourceHolder::UnrefResources(
   for (ReturnedResourceArray::const_iterator it = resources.begin();
        it != resources.end();
        ++it) {
-    ResourceProvider::ResourceId id = it->id;
+    unsigned id = it->id;
     ResourceIdCountMap::iterator count_it = resource_id_use_count_map_.find(id);
     if (count_it == resource_id_use_count_map_.end())
       continue;
diff --git a/cc/surfaces/surface_resource_holder.h b/cc/surfaces/surface_resource_holder.h
index 20c9f29..95cdb82 100644
--- a/cc/surfaces/surface_resource_holder.h
+++ b/cc/surfaces/surface_resource_holder.h
@@ -7,8 +7,9 @@
 
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
-#include "cc/resources/resource_provider.h"
+#include "cc/base/resource_id.h"
 #include "cc/resources/returned_resource.h"
+#include "cc/resources/transferable_resource.h"
 #include "cc/surfaces/surfaces_export.h"
 
 namespace cc {
@@ -39,8 +40,7 @@ class CC_SURFACES_EXPORT SurfaceResourceHolder {
   // Keeps track of the number of users currently in flight for each resource
   // ID we've received from the client. When this counter hits zero for a
   // particular resource, that ID is available to return to the client.
-  typedef base::hash_map<ResourceProvider::ResourceId, ResourceRefs>
-      ResourceIdCountMap;
+  typedef base::hash_map<ResourceId, ResourceRefs> ResourceIdCountMap;
   ResourceIdCountMap resource_id_use_count_map_;
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceResourceHolder);
diff --git a/cc/test/fake_delegated_renderer_layer_impl.cc b/cc/test/fake_delegated_renderer_layer_impl.cc
index 1154a0e..5a9bcd5 100644
--- a/cc/test/fake_delegated_renderer_layer_impl.cc
+++ b/cc/test/fake_delegated_renderer_layer_impl.cc
@@ -25,10 +25,9 @@ scoped_ptr<LayerImpl> FakeDelegatedRendererLayerImpl::CreateLayerImpl(
   return FakeDelegatedRendererLayerImpl::Create(tree_impl, id());
 }
 
-static ResourceProvider::ResourceId AddResourceToFrame(
-    ResourceProvider* resource_provider,
-    DelegatedFrameData* frame,
-    ResourceProvider::ResourceId resource_id) {
+static ResourceId AddResourceToFrame(ResourceProvider* resource_provider,
+                                     DelegatedFrameData* frame,
+                                     ResourceId resource_id) {
   TransferableResource resource;
   resource.id = resource_id;
   resource.mailbox_holder.texture_target =
diff --git a/cc/test/fake_ui_resource_layer_tree_host_impl.cc b/cc/test/fake_ui_resource_layer_tree_host_impl.cc
index 3dbea52..e48ef38 100644
--- a/cc/test/fake_ui_resource_layer_tree_host_impl.cc
+++ b/cc/test/fake_ui_resource_layer_tree_host_impl.cc
@@ -34,14 +34,13 @@ void FakeUIResourceLayerTreeHostImpl::CreateUIResource(
 }
 
 void FakeUIResourceLayerTreeHostImpl::DeleteUIResource(UIResourceId uid) {
-  ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
+  ResourceId id = ResourceIdForUIResource(uid);
   if (id)
     fake_ui_resource_map_.erase(uid);
 }
 
-ResourceProvider::ResourceId
-    FakeUIResourceLayerTreeHostImpl::ResourceIdForUIResource(
-        UIResourceId uid) const {
+ResourceId FakeUIResourceLayerTreeHostImpl::ResourceIdForUIResource(
+    UIResourceId uid) const {
   UIResourceMap::const_iterator iter = fake_ui_resource_map_.find(uid);
   if (iter != fake_ui_resource_map_.end())
     return iter->second.resource_id;
diff --git a/cc/test/fake_ui_resource_layer_tree_host_impl.h b/cc/test/fake_ui_resource_layer_tree_host_impl.h
index e5fad82..19746a1 100644
--- a/cc/test/fake_ui_resource_layer_tree_host_impl.h
+++ b/cc/test/fake_ui_resource_layer_tree_host_impl.h
@@ -21,8 +21,7 @@ class FakeUIResourceLayerTreeHostImpl : public FakeLayerTreeHostImpl {
 
   void DeleteUIResource(UIResourceId uid) override;
 
-  ResourceProvider::ResourceId ResourceIdForUIResource(
-      UIResourceId uid) const override;
+  ResourceId ResourceIdForUIResource(UIResourceId uid) const override;
 
   bool IsUIResourceOpaque(UIResourceId uid) const override;
 
diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc
index 6895297..3789efc 100644
--- a/cc/test/render_pass_test_common.cc
+++ b/cc/test/render_pass_test_common.cc
@@ -34,38 +34,38 @@ void TestRenderPass::AppendOneOfEveryQuadType(
   gfx::Rect visible_rect(0, 0, 100, 100);
   const float vertex_opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
 
-  ResourceProvider::ResourceId resource1 = resource_provider->CreateResource(
+  ResourceId resource1 = resource_provider->CreateResource(
       gfx::Size(45, 5), GL_CLAMP_TO_EDGE,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       resource_provider->best_texture_format());
   resource_provider->AllocateForTesting(resource1);
-  ResourceProvider::ResourceId resource2 = resource_provider->CreateResource(
+  ResourceId resource2 = resource_provider->CreateResource(
       gfx::Size(346, 61), GL_CLAMP_TO_EDGE,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       resource_provider->best_texture_format());
   resource_provider->AllocateForTesting(resource2);
-  ResourceProvider::ResourceId resource3 = resource_provider->CreateResource(
+  ResourceId resource3 = resource_provider->CreateResource(
       gfx::Size(12, 134), GL_CLAMP_TO_EDGE,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       resource_provider->best_texture_format());
   resource_provider->AllocateForTesting(resource3);
-  ResourceProvider::ResourceId resource4 = resource_provider->CreateResource(
+  ResourceId resource4 = resource_provider->CreateResource(
       gfx::Size(56, 12), GL_CLAMP_TO_EDGE,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       resource_provider->best_texture_format());
   resource_provider->AllocateForTesting(resource4);
   gfx::Size resource5_size(73, 26);
-  ResourceProvider::ResourceId resource5 = resource_provider->CreateResource(
+  ResourceId resource5 = resource_provider->CreateResource(
       resource5_size, GL_CLAMP_TO_EDGE,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       resource_provider->best_texture_format());
   resource_provider->AllocateForTesting(resource5);
-  ResourceProvider::ResourceId resource6 = resource_provider->CreateResource(
+  ResourceId resource6 = resource_provider->CreateResource(
       gfx::Size(64, 92), GL_CLAMP_TO_EDGE,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       resource_provider->best_texture_format());
   resource_provider->AllocateForTesting(resource6);
-  ResourceProvider::ResourceId resource7 = resource_provider->CreateResource(
+  ResourceId resource7 = resource_provider->CreateResource(
       gfx::Size(9, 14), GL_CLAMP_TO_EDGE,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       resource_provider->best_texture_format());
@@ -77,9 +77,8 @@ void TestRenderPass::AppendOneOfEveryQuadType(
   scoped_ptr<SingleReleaseCallbackImpl> callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
   TextureMailbox mailbox(gpu_mailbox, target, kSyncPointForMailboxTextureQuad);
-  ResourceProvider::ResourceId resource8 =
-      resource_provider->CreateResourceFromTextureMailbox(mailbox,
-                                                          callback.Pass());
+  ResourceId resource8 = resource_provider->CreateResourceFromTextureMailbox(
+      mailbox, callback.Pass());
   resource_provider->AllocateForTesting(resource8);
 
   SharedQuadState* shared_state = this->CreateAndAppendSharedQuadState();
@@ -233,7 +232,7 @@ void TestRenderPass::AppendOneOfEveryQuadType(
                     false,
                     false);
 
-  ResourceProvider::ResourceId plane_resources[4];
+  ResourceId plane_resources[4];
   for (int i = 0; i < 4; ++i) {
     plane_resources[i] = resource_provider->CreateResource(
         gfx::Size(20, 12), GL_CLAMP_TO_EDGE,
diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc
index f9def0f..e6cdf53 100644
--- a/cc/test/render_pass_test_utils.cc
+++ b/cc/test/render_pass_test_utils.cc
@@ -109,7 +109,7 @@ void AddRenderPassQuad(TestRenderPass* to_pass,
 
 void AddRenderPassQuad(TestRenderPass* to_pass,
                        TestRenderPass* contributing_pass,
-                       ResourceProvider::ResourceId mask_resource_id,
+                       ResourceId mask_resource_id,
                        const FilterOperations& filters,
                        gfx::Transform transform,
                        SkXfermode::Mode blend_mode) {
diff --git a/cc/test/render_pass_test_utils.h b/cc/test/render_pass_test_utils.h
index 49ea113..b353644 100644
--- a/cc/test/render_pass_test_utils.h
+++ b/cc/test/render_pass_test_utils.h
@@ -51,7 +51,7 @@ void AddRenderPassQuad(TestRenderPass* to_pass,
 // Adds a render pass quad with the given mask resource, filter, and transform.
 void AddRenderPassQuad(TestRenderPass* toPass,
                        TestRenderPass* contributing_pass,
-                       ResourceProvider::ResourceId mask_resource_id,
+                       ResourceId mask_resource_id,
                        const FilterOperations& filters,
                        gfx::Transform transform,
                        SkXfermode::Mode blend_mode);
diff --git a/cc/tiles/tile_draw_info.h b/cc/tiles/tile_draw_info.h
index f094efd..9ba8f24 100644
--- a/cc/tiles/tile_draw_info.h
+++ b/cc/tiles/tile_draw_info.h
@@ -48,7 +48,7 @@ class CC_EXPORT TileDrawInfo {
     return false;
   }
 
-  ResourceProvider::ResourceId resource_id() const {
+  ResourceId resource_id() const {
     DCHECK(mode_ == RESOURCE_MODE);
     DCHECK(resource_);
     return resource_->id();
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index a399d5e..f75077d 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -3286,7 +3286,7 @@ void LayerTreeHostImpl::CreateUIResource(UIResourceId uid,
 
   // Allow for multiple creation requests with the same UIResourceId.  The
   // previous resource is simply deleted.
-  ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
+  ResourceId id = ResourceIdForUIResource(uid);
   if (id)
     DeleteUIResource(uid);
 
@@ -3319,7 +3319,7 @@ void LayerTreeHostImpl::CreateUIResource(UIResourceId uid,
 }
 
 void LayerTreeHostImpl::DeleteUIResource(UIResourceId uid) {
-  ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
+  ResourceId id = ResourceIdForUIResource(uid);
   if (id) {
     resource_provider_->DeleteResource(id);
     ui_resource_map_.erase(uid);
@@ -3344,8 +3344,7 @@ void LayerTreeHostImpl::EvictAllUIResources() {
   client_->RenewTreePriority();
 }
 
-ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
-    UIResourceId uid) const {
+ResourceId LayerTreeHostImpl::ResourceIdForUIResource(UIResourceId uid) const {
   UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
   if (iter != ui_resource_map_.end())
     return iter->second.resource_id;
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 42454a6..5c0babe 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -473,13 +473,12 @@ class CC_EXPORT LayerTreeHostImpl
   void EvictAllUIResources();
   bool EvictedUIResourcesExist() const;
 
-  virtual ResourceProvider::ResourceId ResourceIdForUIResource(
-      UIResourceId uid) const;
+  virtual ResourceId ResourceIdForUIResource(UIResourceId uid) const;
 
   virtual bool IsUIResourceOpaque(UIResourceId uid) const;
 
   struct UIResourceData {
-    ResourceProvider::ResourceId resource_id;
+    ResourceId resource_id;
     gfx::Size size;
     bool opaque;
   };
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 6b45ae4..e38cc03 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -4495,7 +4495,7 @@ class BlendStateCheckLayer : public LayerImpl {
   gfx::Rect quad_rect_;
   gfx::Rect opaque_content_rect_;
   gfx::Rect quad_visible_rect_;
-  ResourceProvider::ResourceId resource_id_;
+  ResourceId resource_id_;
 };
 
 TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
@@ -5682,7 +5682,7 @@ class FakeMaskLayerImpl : public LayerImpl {
     return make_scoped_ptr(new FakeMaskLayerImpl(tree_impl, id));
   }
 
-  void GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
+  void GetContentsResourceId(ResourceId* resource_id,
                              gfx::Size* resource_size) const override {
     *resource_id = 0;
   }
@@ -6032,16 +6032,14 @@ TEST_F(LayerTreeHostImplTest, UIResourceManagement) {
   UIResourceBitmap bitmap(gfx::Size(1, 1), is_opaque);
   host_impl_->CreateUIResource(ui_resource_id, bitmap);
   EXPECT_EQ(1u, context3d->NumTextures());
-  ResourceProvider::ResourceId id1 =
-      host_impl_->ResourceIdForUIResource(ui_resource_id);
+  ResourceId id1 = host_impl_->ResourceIdForUIResource(ui_resource_id);
   EXPECT_NE(0u, id1);
 
   // Multiple requests with the same id is allowed.  The previous texture is
   // deleted.
   host_impl_->CreateUIResource(ui_resource_id, bitmap);
   EXPECT_EQ(1u, context3d->NumTextures());
-  ResourceProvider::ResourceId id2 =
-      host_impl_->ResourceIdForUIResource(ui_resource_id);
+  ResourceId id2 = host_impl_->ResourceIdForUIResource(ui_resource_id);
   EXPECT_NE(0u, id2);
   EXPECT_NE(id1, id2);
 
@@ -6084,8 +6082,7 @@ TEST_F(LayerTreeHostImplTest, CreateETC1UIResource) {
   UIResourceId ui_resource_id = 1;
   host_impl_->CreateUIResource(ui_resource_id, bitmap);
   EXPECT_EQ(1u, context3d->NumTextures());
-  ResourceProvider::ResourceId id1 =
-      host_impl_->ResourceIdForUIResource(ui_resource_id);
+  ResourceId id1 = host_impl_->ResourceIdForUIResource(ui_resource_id);
   EXPECT_NE(0u, id1);
 }
 
diff --git a/cc/trees/layer_tree_host_unittest_context.cc b/cc/trees/layer_tree_host_unittest_context.cc
index a2f0611..670ae8a 100644
--- a/cc/trees/layer_tree_host_unittest_context.cc
+++ b/cc/trees/layer_tree_host_unittest_context.cc
@@ -1004,10 +1004,9 @@ class LayerTreeHostContextTestDontUseLostResources
     delegated_frame_provider_ = new DelegatedFrameProvider(
         delegated_resource_collection_.get(), frame_data.Pass());
 
-    ResourceProvider::ResourceId resource =
-        child_resource_provider_->CreateResource(
-            gfx::Size(4, 4), GL_CLAMP_TO_EDGE,
-            ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
+    ResourceId resource = child_resource_provider_->CreateResource(
+        gfx::Size(4, 4), GL_CLAMP_TO_EDGE,
+        ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
     ResourceProvider::ScopedWriteLockGL lock(child_resource_provider_.get(),
                                              resource);
 
diff --git a/cc/trees/layer_tree_host_unittest_delegated.cc b/cc/trees/layer_tree_host_unittest_delegated.cc
index 2864eb8..7455318 100644
--- a/cc/trees/layer_tree_host_unittest_delegated.cc
+++ b/cc/trees/layer_tree_host_unittest_delegated.cc
@@ -135,7 +135,7 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest {
   }
 
   void AddTransferableResource(DelegatedFrameData* frame,
-                               ResourceProvider::ResourceId resource_id) {
+                               ResourceId resource_id) {
     TransferableResource resource;
     resource.id = resource_id;
     resource.mailbox_holder.texture_target = GL_TEXTURE_2D;
@@ -147,8 +147,7 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest {
     frame->resource_list.push_back(resource);
   }
 
-  void AddTextureQuad(DelegatedFrameData* frame,
-                      ResourceProvider::ResourceId resource_id) {
+  void AddTextureQuad(DelegatedFrameData* frame, ResourceId resource_id) {
     RenderPass* render_pass = frame->render_pass_list[0];
     SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();
     TextureDrawQuad* quad =
@@ -201,9 +200,9 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest {
                  background_filters);
   }
 
-  static ResourceProvider::ResourceId AppendResourceId(
-      std::vector<ResourceProvider::ResourceId>* resources_in_last_sent_frame,
-      ResourceProvider::ResourceId resource_id) {
+  static ResourceId AppendResourceId(
+      std::vector<ResourceId>* resources_in_last_sent_frame,
+      ResourceId resource_id) {
     resources_in_last_sent_frame->push_back(resource_id);
     return resource_id;
   }
@@ -214,19 +213,18 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest {
     if (!delegated_frame_data)
       return;
 
-    std::vector<ResourceProvider::ResourceId> resources_in_last_sent_frame;
+    std::vector<ResourceId> resources_in_last_sent_frame;
     for (size_t i = 0; i < delegated_frame_data->resource_list.size(); ++i) {
       resources_in_last_sent_frame.push_back(
           delegated_frame_data->resource_list[i].id);
     }
 
-    std::vector<ResourceProvider::ResourceId> resources_to_return;
+    std::vector<ResourceId> resources_to_return;
 
     const TransferableResourceArray& resources_held_by_parent =
         output_surface()->resources_held_by_parent();
     for (size_t i = 0; i < resources_held_by_parent.size(); ++i) {
-      ResourceProvider::ResourceId resource_in_parent =
-          resources_held_by_parent[i].id;
+      ResourceId resource_in_parent = resources_held_by_parent[i].id;
       bool resource_in_parent_is_not_part_of_frame =
           std::find(resources_in_last_sent_frame.begin(),
                     resources_in_last_sent_frame.end(),
@@ -804,9 +802,9 @@ class LayerTreeHostDelegatedTestRemapResourcesInQuads
     EXPECT_EQ(1u, map.count(999));
     EXPECT_EQ(1u, map.count(555));
 
-    ResourceProvider::ResourceId parent_resource_id1 = map.find(999)->second;
+    ResourceId parent_resource_id1 = map.find(999)->second;
     EXPECT_NE(parent_resource_id1, 999u);
-    ResourceProvider::ResourceId parent_resource_id2 = map.find(555)->second;
+    ResourceId parent_resource_id2 = map.find(555)->second;
     EXPECT_NE(parent_resource_id2, 555u);
 
     // The resources in the quads should be remapped to the parent's namespace.
diff --git a/cc/trees/layer_tree_host_unittest_no_message_loop.cc b/cc/trees/layer_tree_host_unittest_no_message_loop.cc
index ef948f7..7d49fff 100644
--- a/cc/trees/layer_tree_host_unittest_no_message_loop.cc
+++ b/cc/trees/layer_tree_host_unittest_no_message_loop.cc
@@ -210,7 +210,7 @@ class LayerTreeHostNoMessageLoopDelegatedLayer
 
  private:
   scoped_ptr<DelegatedFrameData> CreateFrameDataWithResource(
-      ResourceProvider::ResourceId resource_id) {
+      ResourceId resource_id) {
     scoped_ptr<DelegatedFrameData> frame(new DelegatedFrameData);
     gfx::Rect frame_rect(size_);
 
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 01a4cfd..948a805 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -1101,8 +1101,7 @@ void LayerTreeImpl::set_ui_resource_request_queue(
   ui_resource_request_queue_ = queue;
 }
 
-ResourceProvider::ResourceId LayerTreeImpl::ResourceIdForUIResource(
-    UIResourceId uid) const {
+ResourceId LayerTreeImpl::ResourceIdForUIResource(UIResourceId uid) const {
   return layer_tree_host_impl_->ResourceIdForUIResource(uid);
 }
 
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 9c1b5b9..c5d6724 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -286,7 +286,7 @@ class CC_EXPORT LayerTreeImpl {
 
   void DidModifyTilePriorities();
 
-  ResourceProvider::ResourceId ResourceIdForUIResource(UIResourceId uid) const;
+  ResourceId ResourceIdForUIResource(UIResourceId uid) const;
   void ProcessUIResourceRequestQueue();
 
   bool IsUIResourceOpaque(UIResourceId uid) const;