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

cc/resources/resource_provider.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 443 matching lines @@
 bool ResourceProvider::IsLost(ResourceId id) {
   Resource* resource = GetResource(id);
   return resource->lost;
 }
 
 bool ResourceProvider::AllowOverlay(ResourceId id) {
   Resource* resource = GetResource(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:
       return CreateGLTexture(size,
                              GL_TEXTURE_2D,
                              GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
                              wrap_mode,
                              hint,
                              format);
     case RESOURCE_TYPE_BITMAP:
       DCHECK_EQ(RGBA_8888, format);
       return CreateBitmap(size, wrap_mode);
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   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:
       return CreateGLTexture(size,
                              target,
                              GL_TEXTURE_POOL_MANAGED_CHROMIUM,
                              wrap_mode,
                              hint,
                              format);
     case RESOURCE_TYPE_BITMAP:
       DCHECK_EQ(RGBA_8888, format);
       return CreateBitmap(size, wrap_mode);
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   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());
 
   ResourceId id = next_id_++;
   Resource* resource = InsertResource(
       id, Resource(0, size, Resource::INTERNAL, target, GL_LINEAR, texture_pool,
                    wrap_mode, hint, format));
   resource->allocated = false;
   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 =
       shared_bitmap_manager_->AllocateSharedBitmap(size);
   uint8_t* pixels = bitmap->pixels();
   DCHECK(pixels);
 
   ResourceId id = next_id_++;
   Resource* resource =
       InsertResource(id, Resource(pixels, bitmap.release(), size,
                                   Resource::INTERNAL, GL_LINEAR, wrap_mode));
   resource->allocated = true;
   return id;
 }
 
-ResourceProvider::ResourceId ResourceProvider::CreateResourceFromIOSurface(
+ResourceId ResourceProvider::CreateResourceFromIOSurface(
     const gfx::Size& size,
     unsigned io_surface_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   ResourceId id = next_id_++;
   Resource* resource = InsertResource(
       id, Resource(0, gfx::Size(), Resource::INTERNAL, GL_TEXTURE_RECTANGLE_ARB,
                    GL_LINEAR, GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
                    GL_CLAMP_TO_EDGE, TEXTURE_HINT_IMMUTABLE, RGBA_8888));
   LazyCreate(resource);
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
   gl->BindTexture(GL_TEXTURE_RECTANGLE_ARB, resource->gl_id);
   gl->TexImageIOSurface2DCHROMIUM(
       GL_TEXTURE_RECTANGLE_ARB, size.width(), size.height(), io_surface_id, 0);
   resource->allocated = true;
   return id;
 }
 
-ResourceProvider::ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
+ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox,
     scoped_ptr<SingleReleaseCallbackImpl> release_callback_impl) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Just store the information. Mailbox will be consumed in LockForRead().
   ResourceId id = next_id_++;
   DCHECK(mailbox.IsValid());
   Resource* resource = nullptr;
   if (mailbox.IsTexture()) {
     resource = InsertResource(
         id, Resource(0, gfx::Size(), Resource::EXTERNAL, mailbox.target(),
@@ skipping 378 matching lines @@
 
 void ResourceProvider::UnlockForWrite(ResourceProvider::Resource* resource) {
   DCHECK(resource->locked_for_write);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(resource->origin == Resource::INTERNAL);
   resource->locked_for_write = false;
 }
 
 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)) {
   DCHECK(resource_);
 }
 
 ResourceProvider::ScopedReadLockGL::~ScopedReadLockGL() {
   resource_provider_->UnlockForRead(resource_id_);
 }
 
 ResourceProvider::ScopedSamplerGL::ScopedSamplerGL(
     ResourceProvider* resource_provider,
-    ResourceProvider::ResourceId resource_id,
+    ResourceId resource_id,
     GLenum filter)
     : ScopedReadLockGL(resource_provider, resource_id),
       unit_(GL_TEXTURE0),
       target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {
 }
 
 ResourceProvider::ScopedSamplerGL::ScopedSamplerGL(
     ResourceProvider* resource_provider,
-    ResourceProvider::ResourceId resource_id,
+    ResourceId resource_id,
     GLenum unit,
     GLenum filter)
     : ScopedReadLockGL(resource_provider, resource_id),
       unit_(unit),
       target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {
 }
 
 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_);
   texture_id_ = resource_->gl_id;
   DCHECK(texture_id_);
 }
 
 ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL() {
   resource_provider_->UnlockForWrite(resource_);
 }
 
 void ResourceProvider::PopulateSkBitmapWithResource(
     SkBitmap* sk_bitmap, const Resource* resource) {
   DCHECK_EQ(RGBA_8888, resource->format);
   SkImageInfo info = SkImageInfo::MakeN32Premul(resource->size.width(),
                                                 resource->size.height());
   sk_bitmap->installPixels(info, resource->pixels, info.minRowBytes());
 }
 
 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);
 }
 
 ResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware() {
   resource_provider_->UnlockForRead(resource_id_);
 }
 
 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_);
   DCHECK(valid());
 }
 
 ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() {
   DCHECK(thread_checker_.CalledOnValidThread());
   resource_provider_->UnlockForWrite(resource_);
 }
 
 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_),
       gpu_memory_buffer_(nullptr),
       size_(resource_->size),
       format_(resource_->format) {
   DCHECK_EQ(RESOURCE_TYPE_GL_TEXTURE, resource_->type);
   std::swap(gpu_memory_buffer_, resource_->gpu_memory_buffer);
 }
 
@@ skipping 37 matching lines @@
         gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
             size_, ToGpuMemoryBufferFormat(format_), gfx::GpuMemoryBuffer::MAP);
     gpu_memory_buffer_ = gpu_memory_buffer.release();
   }
 
   return gpu_memory_buffer_;
 }
 
 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());
   resource_provider_->LazyAllocate(resource_);
 }
 
 ResourceProvider::ScopedWriteLockGr::~ScopedWriteLockGr() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(resource_->locked_for_write);
   resource_provider_->UnlockForWrite(resource_);
@@ skipping 936 matching lines @@
 }
 
 class GrContext* ResourceProvider::GrContext(bool worker_context) const {
   ContextProvider* context_provider =
       worker_context ? output_surface_->worker_context_provider()
                      : output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc