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

cc/layers/tiled_layer_impl.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layers/tiled_layer_impl.h"
 
 #include "base/basictypes.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/math_util.h"
@@ skipping 11 matching lines @@
 #include "ui/gfx/geometry/quad_f.h"
 
 namespace cc {
 
 class DrawableTile : public LayerTilingData::Tile {
  public:
   static scoped_ptr<DrawableTile> Create() {
     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;
   }
 
  private:
   DrawableTile() : resource_id_(0), contents_swizzled_(false) {}
 
-  ResourceProvider::ResourceId resource_id_;
+  ResourceId resource_id_;
   bool contents_swizzled_;
 
   DISALLOW_COPY_AND_ASSIGN(DrawableTile);
 };
 
 TiledLayerImpl::TiledLayerImpl(LayerTreeImpl* tree_impl, int id)
     : TiledLayerImpl(tree_impl, id, new LayerImpl::SyncedScrollOffset) {
 }
 
 TiledLayerImpl::TiledLayerImpl(
     LayerTreeImpl* tree_impl,
     int id,
     scoped_refptr<LayerImpl::SyncedScrollOffset> synced_scroll_offset)
     : LayerImpl(tree_impl, id, synced_scroll_offset), skips_draw_(true) {
 }
 
 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
   // can't draw.
   if (tiler_->num_tiles_x() == 0 || tiler_->num_tiles_y() == 0) {
     *resource_id = 0;
     return;
   }
 
   // Any other number of tiles other than 0 or 1 is incorrect for masks.
@@ skipping 203 matching lines @@
     tiler_->reset();
   } else {
     tiler_ = LayerTilingData::Create(tiler.tile_size(),
                                      tiler.has_border_texels()
                                          ? LayerTilingData::HAS_BORDER_TEXELS
                                          : LayerTilingData::NO_BORDER_TEXELS);
   }
   *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);
   tile->set_resource_id(resource_id);
   tile->set_contents_swizzled(contents_swizzled);
 }
 
 void TiledLayerImpl::PushInvalidTile(int i, int j) {
   DrawableTile* tile = TileAt(i, j);
   if (!tile)
@@ skipping 10 matching lines @@
 
 void TiledLayerImpl::ReleaseResources() {
   tiler_->reset();
 }
 
 const char* TiledLayerImpl::LayerTypeAsString() const {
   return "cc::TiledLayerImpl";
 }
 
 }  // namespace cc