cc: Allow TEXTURE_RECTANGLE_ARB to be used for tile textures.

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 321 matching lines @@
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateResource(
     gfx::Size size,
     GLint wrap_mode,
     TextureUsageHint hint,
     ResourceFormat format) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case GLTexture:
-      return CreateGLTexture(
-          size, GL_TEXTURE_POOL_UNMANAGED_CHROMIUM, wrap_mode, hint, format);
+      return CreateGLTexture(size,
+                             GL_TEXTURE_2D,
+                             GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
+                             wrap_mode,
+                             hint,
+                             format);
     case Bitmap:
       DCHECK_EQ(RGBA_8888, format);
       return CreateBitmap(size, wrap_mode);
     case InvalidType:
       break;
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateManagedResource(
     gfx::Size size,
+    GLenum target,
     GLint wrap_mode,
     TextureUsageHint hint,
     ResourceFormat format) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case GLTexture:
-      return CreateGLTexture(
-          size, GL_TEXTURE_POOL_MANAGED_CHROMIUM, wrap_mode, hint, format);
+      return CreateGLTexture(size,
+                             target,
+                             GL_TEXTURE_POOL_MANAGED_CHROMIUM,
+                             wrap_mode,
+                             hint,
+                             format);
     case Bitmap:
       DCHECK_EQ(RGBA_8888, format);
       return CreateBitmap(size, wrap_mode);
     case InvalidType:
       break;
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateGLTexture(
     gfx::Size size,
+    GLenum target,
     GLenum texture_pool,
     GLint wrap_mode,
     TextureUsageHint 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(
-      0, size, GL_TEXTURE_2D, GL_LINEAR, texture_pool, wrap_mode, hint, format);
+      0, size, target, GL_LINEAR, texture_pool, wrap_mode, hint, format);
   resource.allocated = false;
   resources_[id] = resource;
   return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateBitmap(
     gfx::Size size, GLint wrap_mode) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_ptr<SharedBitmap> bitmap;
@@ skipping 383 matching lines @@
   DCHECK(texture_id_);
 }
 
 ResourceProvider::ScopedReadLockGL::~ScopedReadLockGL() {
   resource_provider_->UnlockForRead(resource_id_);
 }
 
 ResourceProvider::ScopedSamplerGL::ScopedSamplerGL(
     ResourceProvider* resource_provider,
     ResourceProvider::ResourceId resource_id,
-    GLenum target,
     GLenum filter)
     : ScopedReadLockGL(resource_provider, resource_id),
-      target_(target),
-      unit_(GL_TEXTURE0) {
-  resource_provider->BindForSampling(resource_id, target, unit_, filter);
+      unit_(GL_TEXTURE0),
+      target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {
 }
 
 ResourceProvider::ScopedSamplerGL::ScopedSamplerGL(
     ResourceProvider* resource_provider,
     ResourceProvider::ResourceId resource_id,
-    GLenum target,
     GLenum unit,
     GLenum filter)
     : ScopedReadLockGL(resource_provider, resource_id),
-      target_(target),
-      unit_(unit) {
-  resource_provider->BindForSampling(resource_id, target, unit, filter);
+      unit_(unit),
+      target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {
 }
 
 ResourceProvider::ScopedSamplerGL::~ScopedSamplerGL() {
 }
 
 ResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL(
     ResourceProvider* resource_provider,
     ResourceProvider::ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_id_(resource_id),
@@ skipping 660 matching lines @@
     DCHECK(context3d);
     DCHECK(resource->gl_pixel_buffer_id);
     context3d->bindBuffer(
         GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
         resource->gl_pixel_buffer_id);
     context3d->unmapBufferCHROMIUM(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM);
     context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
   }
 }
 
-void ResourceProvider::BindForSampling(ResourceProvider::ResourceId resource_id,
-                                       GLenum target,
-                                       GLenum unit,
-                                       GLenum filter) {
+GLenum ResourceProvider::BindForSampling(
+    ResourceProvider::ResourceId resource_id,
+    GLenum unit,
+    GLenum filter) {
   DCHECK(thread_checker_.CalledOnValidThread());
   WebGraphicsContext3D* context3d = Context3d();
   ResourceMap::iterator it = resources_.find(resource_id);
   DCHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(resource->lock_for_read_count);
   DCHECK(!resource->locked_for_write || resource->set_pixels_completion_forced);
 
   ScopedSetActiveTexture scoped_active_tex(context3d, unit);
+  GLenum target = resource->target;
   GLC(context3d, context3d->bindTexture(target, resource->gl_id));
   if (filter != resource->filter) {
-    DCHECK_EQ(resource->target, target);
     GLC(context3d,
         context3d->texParameteri(target, GL_TEXTURE_MIN_FILTER, filter));
     GLC(context3d,
         context3d->texParameteri(target, GL_TEXTURE_MAG_FILTER, filter));
     resource->filter = filter;
   }
 
   if (resource->image_id && resource->dirty_image) {
     // Release image currently bound to texture.
     if (resource->bound_image_id)
       context3d->releaseTexImage2DCHROMIUM(target, resource->bound_image_id);
     context3d->bindTexImage2DCHROMIUM(target, resource->image_id);
     resource->bound_image_id = resource->image_id;
     resource->dirty_image = false;
   }
+
+  return target;
 }
 
 void ResourceProvider::BeginSetPixels(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(!resource->pending_set_pixels);
 
   LazyCreate(resource);
   DCHECK(resource->gl_id || resource->allocated);
   DCHECK(ReadLockFenceHasPassed(resource));
   DCHECK(!resource->image_id);
@@ skipping 299 matching lines @@
   context->getIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 blink::WebGraphicsContext3D* ResourceProvider::Context3d() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->Context3d() : NULL;
 }
 
 }  // namespace cc