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

cc/trees/layer_tree_host_unittest_delegated.cc

 // Copyright 2013 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/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 117 matching lines @@
                               background_color,
                               vertex_opacity,
                               flipped,
                               nearest_neighbor);
 
     frame->render_pass_list.push_back(root_pass.Pass());
     return frame.Pass();
   }
 
   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;
     GLbyte arbitrary_mailbox[GL_MAILBOX_SIZE_CHROMIUM] = {
         1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
         3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4,
         5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4};
     resource.mailbox_holder.mailbox.SetName(arbitrary_mailbox);
     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 =
         render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     float vertex_opacity[4] = { 1.f, 1.f, 1.f, 1.f };
     quad->SetNew(sqs,
                  gfx::Rect(0, 0, 10, 10),
                  gfx::Rect(0, 0, 10, 10),
                  gfx::Rect(0, 0, 10, 10),
                  resource_id,
@@ skipping 32 matching lines @@
                  output_rect,
                  id,
                  0,
                  gfx::Vector2dF(),
                  gfx::Size(),
                  filters,
                  gfx::Vector2dF(),
                  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;
   }
 
   void ReturnUnusedResourcesFromParent(LayerTreeHostImpl* host_impl) {
     DelegatedFrameData* delegated_frame_data =
         output_surface()->last_sent_frame().delegated_frame_data.get();
     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(),
                     resource_in_parent) == resources_in_last_sent_frame.end();
       if (resource_in_parent_is_not_part_of_frame)
         resources_to_return.push_back(resource_in_parent);
     }
 
     if (resources_to_return.empty())
       return;
@@ skipping 526 matching lines @@
 
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // The frame's resource should be in the parent's resource provider.
     EXPECT_EQ(2u, map.size());
     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.
     const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
         delegated_impl->RenderPassesInDrawOrder()[0]->quad_list.ElementAt(0));
     EXPECT_EQ(parent_resource_id1, quad1->resource_id);
     const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast(
         delegated_impl->RenderPassesInDrawOrder()[0]->quad_list.ElementAt(1));
     EXPECT_EQ(parent_resource_id2, quad2->resource_id);
 
@@ skipping 1465 matching lines @@
     ReturnAllResourcesFromParent(host_impl);
   }
 
   bool drew_with_pending_tree_;
 };
 
 MULTI_THREAD_IMPL_TEST_F(LayerTreeHostDelegatedTestActiveFrameIsValid);
 
 }  // namespace
 }  // namespace cc