cc: Remove references to managed resources (and cleanup)

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/atomic_sequence_num.h"
@@ skipping 381 matching lines @@
                              format);
     case RESOURCE_TYPE_BITMAP:
       DCHECK_EQ(RGBA_8888, format);
       return CreateBitmap(size);
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
-ResourceId ResourceProvider::CreateManagedResource(const gfx::Size& size,
-                                                   GLenum target,
-                                                   TextureHint hint,
-                                                   ResourceFormat format) {
+ResourceId ResourceProvider::CreateResourceWithTextureTarget(
+    const gfx::Size& size,
+    GLenum target,
+    TextureHint hint,
+    ResourceFormat format) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case RESOURCE_TYPE_GL_TEXTURE:
       return CreateGLTexture(size,
                              target,
                              hint,
                              format);
     case RESOURCE_TYPE_BITMAP:
       DCHECK_EQ(RGBA_8888, format);
       return CreateBitmap(size);
@@ skipping 200 matching lines @@
 
 void ResourceProvider::CopyToResource(ResourceId id,
                                       const uint8_t* image,
                                       const gfx::Size& image_size) {
   Resource* resource = GetResource(id);
   DCHECK(!resource->locked_for_write);
   DCHECK(!resource->lock_for_read_count);
   DCHECK(resource->origin == Resource::INTERNAL);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(ReadLockFenceHasPassed(resource));
-  LazyAllocate(resource);
 
   DCHECK_EQ(image_size.width(), resource->size.width());
   DCHECK_EQ(image_size.height(), resource->size.height());
 
   if (resource->type == RESOURCE_TYPE_BITMAP) {
     DCHECK_EQ(RESOURCE_TYPE_BITMAP, resource->type);
     DCHECK(resource->allocated);
     DCHECK_EQ(RGBA_8888, resource->format);
     SkImageInfo source_info =
         SkImageInfo::MakeN32Premul(image_size.width(), image_size.height());
     size_t image_stride = image_size.width() * 4;
 
     ScopedWriteLockSoftware lock(this, id);
     SkCanvas dest(lock.sk_bitmap());
     dest.writePixels(source_info, image, image_stride, 0, 0);
   } else {
-    DCHECK(resource->gl_id);
-    DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
+    ScopedWriteLockGL lock(this, id);
+    DCHECK(lock.texture_id());
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
-    gl->BindTexture(GL_TEXTURE_2D, resource->gl_id);
-
+    gl->BindTexture(resource->target, lock.texture_id());
     if (resource->format == ETC1) {
+      DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
       int image_bytes = ResourceUtil::CheckedSizeInBytes<int>(image_size, ETC1);
-      gl->CompressedTexImage2D(GL_TEXTURE_2D, 0, GLInternalFormat(ETC1),
+      gl->CompressedTexImage2D(resource->target, 0, GLInternalFormat(ETC1),
                                image_size.width(), image_size.height(), 0,
                                image_bytes, image);
     } else {
-      gl->TexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, image_size.width(),
+      gl->TexSubImage2D(resource->target, 0, 0, 0, image_size.width(),
                         image_size.height(), GLDataFormat(resource->format),
                         GLDataType(resource->format), image);
     }
   }
 }
 
 ResourceProvider::Resource* ResourceProvider::InsertResource(
     ResourceId id,
     const Resource& resource) {
   std::pair<ResourceMap::iterator, bool> result =
@@ skipping 974 matching lines @@
       const int kImportance = 2;
       pmd->CreateSharedGlobalAllocatorDump(guid);
       pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
     }
   }
 
   return true;
 }
 
 }  // namespace cc