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

cc/resources/resource_provider_unittest.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 "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ skipping 414 matching lines @@
                          ResourceProvider* resource_provider,
                          ResourceProviderContext* context) {
   DCHECK_EQ(expected_default_type, resource_provider->default_resource_type());
 
   gfx::Size size(1, 1);
   WGC3Denum format = GL_RGBA;
   size_t pixel_size = TextureSize(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id = resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   EXPECT_EQ(1, static_cast<int>(resource_provider->num_resources()));
   if (expected_default_type == ResourceProvider::GLTexture)
     EXPECT_EQ(0, context->texture_count());
 
   uint8_t data[4] = { 1, 2, 3, 4 };
   gfx::Rect rect(size);
   resource_provider->SetPixels(id, data, rect, rect, gfx::Vector2d());
   if (expected_default_type == ResourceProvider::GLTexture)
     EXPECT_EQ(1, context->texture_count());
 
@@ skipping 11 matching lines @@
   CheckCreateResource(GetParam(), resource_provider_.get(), context());
 }
 
 TEST_P(ResourceProviderTest, Upload) {
   gfx::Size size(2, 2);
   WGC3Denum format = GL_RGBA;
   size_t pixel_size = TextureSize(size, format);
   ASSERT_EQ(16U, pixel_size);
 
   ResourceProvider::ResourceId id = resource_provider_->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
 
   uint8_t image[16] = { 0 };
   gfx::Rect image_rect(size);
   resource_provider_->SetPixels(
       id, image, image_rect, image_rect, gfx::Vector2d());
 
   for (uint8_t i = 0; i < pixel_size; ++i)
     image[i] = i;
 
   uint8_t result[16] = { 0 };
@@ skipping 63 matching lines @@
 
   scoped_ptr<ResourceProvider> child_resource_provider(
       ResourceProvider::Create(child_output_surface.get(), 0));
 
   gfx::Size size(1, 1);
   WGC3Denum format = GL_RGBA;
   size_t pixel_size = TextureSize(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id1 = child_resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   gfx::Rect rect(size);
   child_resource_provider->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
 
   ResourceProvider::ResourceId id2 = child_resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   uint8_t data2[4] = { 5, 5, 5, 5 };
   child_resource_provider->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
 
   int child_id = resource_provider_->CreateChild();
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
     TransferableResourceArray list;
@@ skipping 109 matching lines @@
 
   scoped_ptr<ResourceProvider> child_resource_provider(
       ResourceProvider::Create(child_output_surface.get(), 0));
 
   gfx::Size size(1, 1);
   WGC3Denum format = GL_RGBA;
   size_t pixel_size = TextureSize(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id = child_resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   uint8_t data[4] = { 1, 2, 3, 4 };
   gfx::Rect rect(size);
   child_resource_provider->SetPixels(id, data, rect, rect, gfx::Vector2d());
 
   int child_id = resource_provider_->CreateChild();
   {
     // Transfer some resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id);
     TransferableResourceArray list;
@@ skipping 42 matching lines @@
 
   scoped_ptr<ResourceProvider> child_resource_provider(
       ResourceProvider::Create(child_output_surface.get(), 0));
 
   gfx::Size size(1, 1);
   WGC3Denum format = GL_RGBA;
   size_t pixel_size = TextureSize(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id = child_resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   uint8_t data[4] = { 1, 2, 3, 4 };
   gfx::Rect rect(size);
   child_resource_provider->SetPixels(id, data, rect, rect, gfx::Vector2d());
   EXPECT_EQ(static_cast<unsigned>(GL_LINEAR),
             GetResourceFilter(child_resource_provider.get(),
                               child_context,
                               id));
   SetResourceFilter(child_resource_provider.get(), id, GL_NEAREST);
   EXPECT_EQ(static_cast<unsigned>(GL_NEAREST),
             GetResourceFilter(child_resource_provider.get(),
@@ skipping 346 matching lines @@
       *context,
       texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
   EXPECT_CALL(
       *context,
       texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
   EXPECT_CALL(*context,
               texParameteri(GL_TEXTURE_2D,
                             GL_TEXTURE_POOL_CHROMIUM,
                             GL_TEXTURE_POOL_UNMANAGED_CHROMIUM));
   ResourceProvider::ResourceId id = resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   resource_provider->AllocateForTesting(id);
 
   // Creating a sampler with the default filter should not change any texture
   // parameters.
   {
     EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
     ResourceProvider::ScopedSamplerGL sampler(
         resource_provider.get(), id, GL_TEXTURE_2D, GL_LINEAR);
   }
 
@@ skipping 40 matching lines @@
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
   gfx::Size size(1, 1);
   WGC3Denum format = GL_RGBA;
   int texture_id = 1;
 
   // Check that the texture gets created with the right sampler settings.
   ResourceProvider::ResourceId id = resource_provider->CreateManagedResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
   EXPECT_CALL(*context,
               texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
   EXPECT_CALL(*context,
               texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
   EXPECT_CALL(
       *context,
       texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
   EXPECT_CALL(
       *context,
       texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
   EXPECT_CALL(*context,
               texParameteri(GL_TEXTURE_2D,
                             GL_TEXTURE_POOL_CHROMIUM,
                             GL_TEXTURE_POOL_MANAGED_CHROMIUM));
   resource_provider->CreateForTesting(id);
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
 }
 
+TEST_P(ResourceProviderTest, TextureWrapMode) {
+  // Sampling is only supported for GL textures.
+  if (GetParam() != ResourceProvider::GLTexture)
+    return;
+
+  scoped_ptr<TextureStateTrackingContext> context_owned(
+      new TextureStateTrackingContext);
+  TextureStateTrackingContext* context = context_owned.get();
+
+  FakeOutputSurfaceClient output_surface_client;
+  scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
+      context_owned.PassAs<TestWebGraphicsContext3D>()));
+  CHECK(output_surface->BindToClient(&output_surface_client));
+
+  scoped_ptr<ResourceProvider> resource_provider(
+      ResourceProvider::Create(output_surface.get(), 0));
+
+  gfx::Size size(1, 1);
+  WGC3Denum format = GL_RGBA;
+  int texture_id = 1;
+  GLenum texture_pool = GL_TEXTURE_POOL_UNMANAGED_CHROMIUM;
+
+  for (int i = 0; i < 2; ++i) {
+    GLint wrap_mode = i ? GL_CLAMP_TO_EDGE : GL_REPEAT;
+    // Check that the texture gets created with the right sampler settings.
+    ResourceProvider::ResourceId id = resource_provider->CreateGLTexture(
+        size, format, texture_pool, wrap_mode,
+        ResourceProvider::TextureUsageAny);
+    EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
+    EXPECT_CALL(*context,
+                texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
+    EXPECT_CALL(*context,
+                texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
+    EXPECT_CALL(
+        *context,
+        texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_mode));
+    EXPECT_CALL(
+        *context,
+        texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_mode));
+    EXPECT_CALL(*context,
+                texParameteri(GL_TEXTURE_2D,
+                              GL_TEXTURE_POOL_CHROMIUM,
+                              GL_TEXTURE_POOL_UNMANAGED_CHROMIUM));
+    resource_provider->CreateForTesting(id);
+    EXPECT_NE(0u, id);
+
+    Mock::VerifyAndClearExpectations(context);
+  }
+}
+
 static void EmptyReleaseCallback(unsigned sync_point, bool lost_resource) {}
 
 TEST_P(ResourceProviderTest, TextureMailbox_SharedMemory) {
   if (GetParam() != ResourceProvider::Bitmap)
     return;
 
   gfx::Size size(64, 64);
   const uint32_t kBadBeef = 0xbadbeef;
   scoped_ptr<base::SharedMemory> shared_memory(
       CreateAndFillSharedMemory(size, kBadBeef));
@@ skipping 228 matching lines @@
   gfx::Size size(2, 2);
   gfx::Vector2d offset(0, 0);
   gfx::Rect rect(0, 0, 2, 2);
   WGC3Denum format = GL_RGBA;
   ResourceProvider::ResourceId id = 0;
   uint8_t pixels[16] = { 0 };
   int texture_id = 123;
 
   // Lazy allocation. Don't allocate when creating the resource.
   id = resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
 
   EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(1);
   resource_provider->CreateForTesting(id);
 
   EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 
   Mock::VerifyAndClearExpectations(context);
 
   // Do allocate when we set the pixels.
   id = resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
 
   EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
   EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _)).Times(1);
   EXPECT_CALL(*context, texSubImage2D(_, _, _, _, 2, 2, _, _, _)).Times(1);
   resource_provider->SetPixels(id, pixels, rect, rect, offset);
 
   EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 
   Mock::VerifyAndClearExpectations(context);
 
   // Same for async version.
   id = resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   resource_provider->AcquirePixelBuffer(id);
 
   EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
   EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
       .Times(1);
   resource_provider->BeginSetPixels(id);
   ASSERT_TRUE(resource_provider->DidSetPixelsComplete(id));
 
   resource_provider->ReleasePixelBuffer(id);
@@ skipping 18 matching lines @@
 
   gfx::Size size(2, 2);
   WGC3Denum format = GL_RGBA;
   ResourceProvider::ResourceId id = 0;
   int texture_id = 123;
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
   id = resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   resource_provider->AcquirePixelBuffer(id);
 
   EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
   EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
       .Times(1);
   resource_provider->BeginSetPixels(id);
 
   EXPECT_TRUE(resource_provider->DidSetPixelsComplete(id));
 
@@ skipping 16 matching lines @@
 
   gfx::Size size(1, 1);
   WGC3Denum format = GL_RGBA;
   ResourceProvider::ResourceId id = 0;
   const uint32_t kBadBeef = 0xbadbeef;
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
   id = resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   resource_provider->AcquirePixelBuffer(id);
 
   void* data = resource_provider->MapPixelBuffer(id);
   ASSERT_TRUE(!!data);
   memcpy(data, &kBadBeef, sizeof(kBadBeef));
   resource_provider->UnmapPixelBuffer(id);
 
   resource_provider->BeginSetPixels(id);
   EXPECT_TRUE(resource_provider->DidSetPixelsComplete(id));
 
@@ skipping 25 matching lines @@
 
   gfx::Size size(2, 2);
   WGC3Denum format = GL_RGBA;
   ResourceProvider::ResourceId id = 0;
   int texture_id = 123;
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
   id = resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   resource_provider->AcquirePixelBuffer(id);
 
   EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
   EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
       .Times(1);
   resource_provider->BeginSetPixels(id);
 
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(1);
   EXPECT_CALL(*context, waitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D)).Times(1);
@@ skipping 22 matching lines @@
   WGC3Denum format = GL_RGBA;
   ResourceProvider::ResourceId id = 0;
   int texture_id = 123;
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
   EXPECT_CALL(*context, createTexture()).WillRepeatedly(Return(texture_id));
 
   id = resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   context->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                GL_INNOCENT_CONTEXT_RESET_ARB);
   resource_provider->AcquirePixelBuffer(id);
   uint8_t* buffer = resource_provider->MapPixelBuffer(id);
   EXPECT_TRUE(buffer == NULL);
   resource_provider->UnmapPixelBuffer(id);
   resource_provider->ReleasePixelBuffer(id);
   Mock::VerifyAndClearExpectations(context);
 }
 
@@ skipping 15 matching lines @@
   gfx::Size size(kWidth, kHeight);
   WGC3Denum format = GL_RGBA;
   ResourceProvider::ResourceId id = 0;
   const unsigned kTextureId = 123u;
   const unsigned kImageId = 234u;
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
   id = resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   EXPECT_CALL(*context, createImageCHROMIUM(kWidth, kHeight, GL_RGBA8_OES))
       .WillOnce(Return(kImageId))
       .RetiresOnSaturation();
   resource_provider->AcquireImage(id);
 
   void* dummy_mapped_buffer_address = NULL;
   EXPECT_CALL(*context, mapImageCHROMIUM(kImageId, GL_READ_WRITE))
       .WillOnce(Return(dummy_mapped_buffer_address))
       .RetiresOnSaturation();
   resource_provider->MapImage(id);
@@ skipping 50 matching lines @@
 
   gfx::Size size(1, 1);
   WGC3Denum format = GL_RGBA;
   ResourceProvider::ResourceId id = 0;
   const uint32_t kBadBeef = 0xbadbeef;
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
   id = resource_provider->CreateResource(
-      size, format, ResourceProvider::TextureUsageAny);
+      size, format, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny);
   resource_provider->AcquireImage(id);
 
   const int kStride = 0;
   int stride = resource_provider->GetImageStride(id);
   EXPECT_EQ(kStride, stride);
 
   void* data = resource_provider->MapImage(id);
   ASSERT_TRUE(!!data);
   memcpy(data, &kBadBeef, sizeof(kBadBeef));
   resource_provider->UnmapImage(id);
@@ skipping 51 matching lines @@
                        output_surface.get());
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceProviderTests,
     ResourceProviderTest,
     ::testing::Values(ResourceProvider::GLTexture, ResourceProvider::Bitmap));
 
 }  // namespace
 }  // namespace cc