[cc] Allow resources and ui resources to specify wrap mode

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 36 matching lines @@
       break;
   }
 
   return storage_format;
 }
 
 bool IsTextureFormatSupportedForStorage(GLenum format) {
   return (format == GL_RGBA || format == GL_BGRA_EXT);
 }
 
-unsigned CreateTextureId(WebGraphicsContext3D* context3d) {
-  unsigned texture_id = 0;
-  GLC(context3d, texture_id = context3d->createTexture());
-  GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, texture_id));
-  GLC(context3d, context3d->texParameteri(
-      GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
-  GLC(context3d, context3d->texParameteri(
-      GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
-  GLC(context3d, context3d->texParameteri(
-      GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
-  GLC(context3d, context3d->texParameteri(
-      GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
-  return texture_id;
-}
-
 }  // namespace
 
 ResourceProvider::Resource::Resource()
     : gl_id(0),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(NULL),
       pixel_buffer(NULL),
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       locked_for_write(false),
       external(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(),
       format(0),
       filter(0),
       image_id(0),
       texture_pool(0),
+      wrap_mode(0),
       hint(TextureUsageAny),
       type(static_cast<ResourceType>(0)) {}
 
 ResourceProvider::Resource::~Resource() {}
 
 ResourceProvider::Resource::Resource(
     unsigned texture_id,
     gfx::Size size,
     GLenum format,
     GLenum filter,
     GLenum texture_pool,
+    GLint wrap_mode,
     TextureUsageHint hint)
     : gl_id(texture_id),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(NULL),
       pixel_buffer(NULL),
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       locked_for_write(false),
       external(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(size),
       format(format),
       filter(filter),
       image_id(0),
       texture_pool(texture_pool),
+      wrap_mode(wrap_mode),
       hint(hint),
-      type(GLTexture) {}
+      type(GLTexture) {
+  DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
+}
 
 ResourceProvider::Resource::Resource(
-    uint8_t* pixels, gfx::Size size, GLenum format, GLenum filter)
+    uint8_t* pixels,
+    gfx::Size size,
+    GLenum format,
+    GLenum filter,
+    GLint wrap_mode)
     : gl_id(0),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(pixels),
       pixel_buffer(NULL),
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       locked_for_write(false),
       external(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(size),
       format(format),
       filter(filter),
       image_id(0),
       texture_pool(0),
+      wrap_mode(wrap_mode),
       hint(TextureUsageAny),
-      type(Bitmap) {}
+      type(Bitmap) {
+  DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
+}
 
 ResourceProvider::Child::Child() {}
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     int highp_threshold_min) {
   scoped_ptr<ResourceProvider> resource_provider(
       new ResourceProvider(output_surface, highp_threshold_min));
@@ skipping 19 matching lines @@
 
   CleanUpGLIfNeeded();
 }
 
 bool ResourceProvider::InUseByConsumer(ResourceId id) {
   Resource* resource = GetResource(id);
   return resource->lock_for_read_count > 0 || resource->exported_count > 0;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateResource(
-    gfx::Size size, GLenum format, TextureUsageHint hint) {
+    gfx::Size size, GLenum format, GLint wrap_mode, TextureUsageHint hint) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case GLTexture:
-      return CreateGLTexture(
-          size, format, GL_TEXTURE_POOL_UNMANAGED_CHROMIUM, hint);
+      return CreateGLTexture(size, format, GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
+                             wrap_mode, hint);
     case Bitmap:
+      // The only wrap_mode currently implemented in software mode is
+      // GL_CLAMP_TO_EDGE.
+      // http://crbug.com/284796
       DCHECK(format == GL_RGBA);
       return CreateBitmap(size);
     case InvalidType:
       break;
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateManagedResource(
-    gfx::Size size, GLenum format, TextureUsageHint hint) {
+    gfx::Size size, GLenum format, GLint wrap_mode, TextureUsageHint hint) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case GLTexture:
-      return CreateGLTexture(
-          size, format, GL_TEXTURE_POOL_MANAGED_CHROMIUM, hint);
+      return CreateGLTexture(size, format, GL_TEXTURE_POOL_MANAGED_CHROMIUM,
+                             wrap_mode, hint);
     case Bitmap:
       DCHECK(format == GL_RGBA);
       return CreateBitmap(size);
     case InvalidType:
       break;
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateGLTexture(
-    gfx::Size size, GLenum format, GLenum texture_pool, TextureUsageHint hint) {
+    gfx::Size size,
+    GLenum format,
+    GLenum texture_pool,
+    GLint wrap_mode,
+    TextureUsageHint hint) {
   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, format, GL_LINEAR, texture_pool, hint);
+  Resource resource(0, size, format, GL_LINEAR, texture_pool, wrap_mode, hint);
   resource.allocated = false;
   resources_[id] = resource;
   return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateBitmap(gfx::Size size) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   uint8_t* pixels = new uint8_t[4 * size.GetArea()];
 
   ResourceId id = next_id_++;
-  Resource resource(pixels, size, GL_RGBA, GL_LINEAR);
+  Resource resource(pixels, size, GL_RGBA, GL_LINEAR, GL_CLAMP_TO_EDGE);
   resource.allocated = true;
   resources_[id] = resource;
   return id;
 }
 
 ResourceProvider::ResourceId
 ResourceProvider::CreateResourceFromExternalTexture(
     unsigned texture_target,
     unsigned texture_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   WebGraphicsContext3D* context3d = Context3d();
   DCHECK(context3d);
   GLC(context3d, context3d->bindTexture(texture_target, texture_id));
   GLC(context3d, context3d->texParameteri(
       texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
   GLC(context3d, context3d->texParameteri(
       texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
   GLC(context3d, context3d->texParameteri(
       texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
   GLC(context3d, context3d->texParameteri(
       texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
 
   ResourceId id = next_id_++;
-  Resource resource(texture_id, gfx::Size(), 0, GL_LINEAR, 0, TextureUsageAny);
+  Resource resource(texture_id, gfx::Size(), 0, GL_LINEAR, 0, GL_CLAMP_TO_EDGE,
+                    TextureUsageAny);
   resource.external = true;
   resource.allocated = true;
   resources_[id] = resource;
   return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Just store the information. Mailbox will be consumed in LockForRead().
   ResourceId id = next_id_++;
   DCHECK(mailbox.IsValid());
   Resource& resource = resources_[id];
   if (mailbox.IsTexture()) {
-    resource = Resource(0, gfx::Size(), 0, GL_LINEAR, 0, TextureUsageAny);
+    resource = Resource(0, gfx::Size(), 0, GL_LINEAR, 0, GL_CLAMP_TO_EDGE,
+                        TextureUsageAny);
   } else {
     DCHECK(mailbox.IsSharedMemory());
     base::SharedMemory* shared_memory = mailbox.shared_memory();
     DCHECK(shared_memory->memory());
     uint8_t* pixels = reinterpret_cast<uint8_t*>(shared_memory->memory());
     resource = Resource(pixels, mailbox.shared_memory_size(),
-                        GL_RGBA, GL_LINEAR);
+                        GL_RGBA, GL_LINEAR, GL_CLAMP_TO_EDGE);
   }
   resource.external = true;
   resource.allocated = true;
   resource.mailbox = mailbox;
   return id;
 }
 
 void ResourceProvider::DeleteResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
@@ skipping 569 matching lines @@
     // However if the parent is a renderer (e.g. browser tag), it may be ok
     // (and is simpler) to wait.
     if (it->sync_point)
       GLC(context3d, context3d->waitSyncPoint(it->sync_point));
     GLC(context3d, texture_id = context3d->createTexture());
     GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, texture_id));
     GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D,
                                                      it->mailbox.name));
     ResourceId id = next_id_++;
     Resource resource(
-        texture_id, it->size, it->format, it->filter, 0, TextureUsageAny);
+        texture_id, it->size, it->format, it->filter, 0, GL_CLAMP_TO_EDGE,
+        TextureUsageAny);
     resource.mailbox.SetName(it->mailbox);
     // Don't allocate a texture for a child.
     resource.allocated = true;
     resource.imported_count = 1;
     resources_[id] = resource;
     child_info.parent_to_child_map[id] = it->id;
     child_info.child_to_parent_map[it->id] = id;
   }
 }
 
@@ skipping 337 matching lines @@
   resource->pending_set_pixels = false;
   UnlockForWrite(id);
 
   return true;
 }
 
 void ResourceProvider::CreateForTesting(ResourceId id) {
   LazyCreate(GetResource(id));
 }
 
+GLint ResourceProvider::WrapModeForTesting(ResourceId id) {
+  Resource* resource = GetResource(id);
+  return resource->wrap_mode;
+}
+
 void ResourceProvider::LazyCreate(Resource* resource) {
   if (resource->type != GLTexture || resource->gl_id != 0)
     return;
 
   // Early out for resources that don't require texture creation.
   if (resource->texture_pool == 0)
     return;
 
   WebGraphicsContext3D* context3d = Context3d();
   DCHECK(context3d);
+
   // Create and set texture properties. Allocation is delayed until needed.
-  resource->gl_id = CreateTextureId(context3d);
+  GLC(context3d, resource->gl_id = context3d->createTexture());
+  GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id));
+  GLC(context3d, context3d->texParameteri(
+      GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
+  GLC(context3d, context3d->texParameteri(
+      GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
+  GLC(context3d, context3d->texParameteri(
+      GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, resource->wrap_mode));
+  GLC(context3d, context3d->texParameteri(
+      GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, resource->wrap_mode));
   GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D,
                                           GL_TEXTURE_POOL_CHROMIUM,
                                           resource->texture_pool));
   if (use_texture_usage_hint_ && resource->hint == TextureUsageFramebuffer) {
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D,
                                             GL_TEXTURE_USAGE_ANGLE,
                                             GL_FRAMEBUFFER_ATTACHMENT_ANGLE));
   }
 }
 
@@ skipping 127 matching lines @@
   context->getIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 WebKit::WebGraphicsContext3D* ResourceProvider::Context3d() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->Context3d() : NULL;
 }
 
 }  // namespace cc