cc: Allow TEXTURE_RECTANGLE_ARB to be used for tile textures.

cc/resources/resource_provider.h

 // 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.
 
 #ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_
 #define CC_RESOURCES_RESOURCE_PROVIDER_H_
 
 #include <deque>
 #include <set>
 #include <string>
@@ skipping 83 matching lines @@
 
   // Creates a resource of the default resource type.
   ResourceId CreateResource(gfx::Size size,
                             GLint wrap_mode,
                             TextureUsageHint hint,
                             ResourceFormat format);
 
   // Creates a resource which is tagged as being managed for GPU memory
   // accounting purposes.
   ResourceId CreateManagedResource(gfx::Size size,
+                                   GLenum target,
                                    GLint wrap_mode,
                                    TextureUsageHint hint,
                                    ResourceFormat format);
 
   // You can also explicitly create a specific resource type.
   ResourceId CreateGLTexture(gfx::Size size,
+                             GLenum target,
                              GLenum texture_pool,
                              GLint wrap_mode,
                              TextureUsageHint hint,
                              ResourceFormat format);
 
   ResourceId CreateBitmap(gfx::Size size, GLint wrap_mode);
   // Wraps an external texture into a GL resource.
   ResourceId CreateResourceFromExternalTexture(
       unsigned texture_target,
       unsigned texture_id);
@@ skipping 94 matching lines @@
    private:
     unsigned texture_id_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGL);
   };
 
   class CC_EXPORT ScopedSamplerGL : public ScopedReadLockGL {
    public:
     ScopedSamplerGL(ResourceProvider* resource_provider,
                     ResourceProvider::ResourceId resource_id,
-                    GLenum target,
                     GLenum filter);
     ScopedSamplerGL(ResourceProvider* resource_provider,
                     ResourceProvider::ResourceId resource_id,
-                    GLenum target,
                     GLenum unit,
                     GLenum filter);
     virtual ~ScopedSamplerGL();
 
+    GLenum target() const { return target_; }
+
    private:
+    GLenum unit_;
     GLenum target_;
-    GLenum unit_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedSamplerGL);
   };
 
   class CC_EXPORT ScopedWriteLockGL {
    public:
     ScopedWriteLockGL(ResourceProvider* resource_provider,
                       ResourceProvider::ResourceId resource_id);
     ~ScopedWriteLockGL();
 
@@ skipping 212 matching lines @@
   };
   void DeleteResourceInternal(ResourceMap::iterator it, DeleteStyle style);
   void DeleteAndReturnUnusedResourcesToChild(ChildMap::iterator child_it,
                                              DeleteStyle style,
                                              const ResourceIdArray& unused);
   void DestroyChildInternal(ChildMap::iterator it, DeleteStyle style);
   void LazyCreate(Resource* resource);
   void LazyAllocate(Resource* resource);
 
   // Binds the given GL resource to a texture target for sampling using the
-  // specified filter for both minification and magnification. The resource
-  // must be locked for reading.
-  void BindForSampling(ResourceProvider::ResourceId resource_id,
-                       GLenum target,
-                       GLenum unit,
-                       GLenum filter);
+  // specified filter for both minification and magnification. Returns the
+  // texture target used. The resource must be locked for reading.
+  GLenum BindForSampling(ResourceProvider::ResourceId resource_id,
+                         GLenum unit,
+                         GLenum filter);
 
   // Returns NULL if the output_surface_ does not have a ContextProvider.
   blink::WebGraphicsContext3D* Context3d() const;
 
   OutputSurface* output_surface_;
   SharedBitmapManager* shared_bitmap_manager_;
   bool lost_output_surface_;
   int highp_threshold_min_;
   ResourceId next_id_;
   ResourceMap resources_;
@@ skipping 63 matching lines @@
   return format_gl_data_format[format];
 }
 
 inline GLenum GLInternalFormat(ResourceFormat format) {
   return GLDataFormat(format);
 }
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_