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

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 1491 matching lines @@
     scoped_ptr<LayerTilingData> tiling_data =
         LayerTilingData::Create(gfx::Size(10, 10),
                                 LayerTilingData::NO_BORDER_TEXELS);
     tiling_data->SetBounds(bounds());
     SetTilingData(*tiling_data.get());
     set_skips_draw(skips_draw);
     if (!tile_missing) {
       ResourceProvider::ResourceId resource =
           resource_provider->CreateResource(gfx::Size(1, 1),
                                             GL_RGBA,
+                                            GL_CLAMP_TO_EDGE,
                                             ResourceProvider::TextureUsageAny);
       resource_provider->AllocateForTesting(resource);
       PushTileProperties(0, 0, resource, gfx::Rect(), false);
     }
     if (animating)
       AddAnimatedTransformToLayer(this, 10.0, 3, 0);
   }
 };
 
 TEST_F(LayerTreeHostImplTest, PrepareToDrawFailsWhenAnimationUsesCheckerboard) {
@@ skipping 1071 matching lines @@
                        ResourceProvider* resource_provider)
       : LayerImpl(tree_impl, id),
         blend_(false),
         has_render_surface_(false),
         quads_appended_(false),
         quad_rect_(5, 5, 5, 5),
         quad_visible_rect_(5, 5, 5, 5),
         resource_id_(resource_provider->CreateResource(
             gfx::Size(1, 1),
             GL_RGBA,
+            GL_CLAMP_TO_EDGE,
             ResourceProvider::TextureUsageAny)) {
     resource_provider->AllocateForTesting(resource_id_);
     SetAnchorPoint(gfx::PointF());
     SetBounds(gfx::Size(10, 10));
     SetContentBounds(gfx::Size(10, 10));
     SetDrawsContent(true);
   }
 
   bool blend_;
   bool has_render_surface_;
@@ skipping 373 matching lines @@
     }
     return num_gutter_quads;
   }
 
   // Make sure that the texture coordinates match their expectations.
   void ValidateTextureDrawQuads(const QuadList& quad_list) {
     for (size_t i = 0; i < quad_list.size(); ++i) {
       if (quad_list[i]->material == DrawQuad::TEXTURE_CONTENT) {
         TextureDrawQuad* quad = reinterpret_cast<TextureDrawQuad*>(
             quad_list[i]);
-        EXPECT_EQ(quad->uv_top_left.x(),
-                  quad->rect.x() /
-                      static_cast<float>(gutter_texture_size_.width()));
-        EXPECT_EQ(quad->uv_top_left.y(),
-                  quad->rect.y() /
-                      static_cast<float>(gutter_texture_size_.height()));
-        EXPECT_EQ(quad->uv_bottom_right.x(),
-                  (quad->rect.x() + quad->rect.width()) /
-                      static_cast<float>(gutter_texture_size_.width()));
-        EXPECT_EQ(quad->uv_bottom_right.y(),
-                  (quad->rect.y() + quad->rect.height()) /
-                      static_cast<float>(gutter_texture_size_.height()));
+        EXPECT_EQ(quad->rect.x() /
+                      static_cast<float>(gutter_texture_size_.width()),
+                  quad->uv_top_left.x());
+        EXPECT_EQ(quad->rect.y() /
+                      static_cast<float>(gutter_texture_size_.height()),
+                  quad->uv_top_left.y());
+        EXPECT_EQ((quad->rect.x() + quad->rect.width()) /
+                      static_cast<float>(gutter_texture_size_.width()),
+                  quad->uv_bottom_right.x());
+        EXPECT_EQ((quad->rect.y() + quad->rect.height()) /
+                      static_cast<float>(gutter_texture_size_.height()),
+                  quad->uv_bottom_right.y());
+        EXPECT_EQ(GL_REPEAT,
+                  host_impl_->resource_provider()->WrapModeForTesting(
+                      quad->resource_id));
       }
     }
   }
 
   DrawQuad::Material gutter_quad_material_;
   gfx::Size gutter_texture_size_;
   gfx::Size viewport_size_;
   BlendStateCheckLayer* child_;
   bool did_activate_pending_tree_;
 };
@@ skipping 12 matching lines @@
 
 TEST_F(LayerTreeHostImplViewportCoveredTest, ViewportCoveredOverhangBitmap) {
   bool always_draw = false;
   CreateLayerTreeHostImpl(always_draw);
 
   host_impl_->SetViewportSize(viewport_size_);
   SetupActiveTreeLayers();
 
   // Specify an overhang bitmap to use.
   scoped_refptr<UIResourceBitmap> ui_resource_bitmap(UIResourceBitmap::Create(
-      new uint8_t[4], UIResourceBitmap::RGBA8, gfx::Size(1, 1)));
+      new uint8_t[4],
+      UIResourceBitmap::RGBA8,
+      UIResourceBitmap::REPEAT,
+      gfx::Size(1, 1)));
   UIResourceId ui_resource_id = 12345;
   host_impl_->CreateUIResource(ui_resource_id, ui_resource_bitmap);
   host_impl_->SetOverhangUIResource(ui_resource_id, gfx::Size(32, 32));
   set_gutter_quad_material(DrawQuad::TEXTURE_CONTENT);
   set_gutter_texture_size(gfx::Size(32, 32));
 
   TestLayerCoversFullViewport();
   TestEmptyLayer();
   TestLayerInMiddleOfViewport();
   TestLayerIsLargerThanViewport();
@@ skipping 3352 matching lines @@
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   TestWebGraphicsContext3D* context3d = context.get();
   scoped_ptr<OutputSurface> output_surface = CreateFakeOutputSurface();
   host_impl_->InitializeRenderer(output_surface.Pass());
 
   EXPECT_EQ(0u, context3d->NumTextures());
 
   UIResourceId ui_resource_id = 1;
   scoped_refptr<UIResourceBitmap> bitmap = UIResourceBitmap::Create(
-      new uint8_t[1], UIResourceBitmap::RGBA8, gfx::Size(1, 1));
+      new uint8_t[1],
+      UIResourceBitmap::RGBA8,
+      UIResourceBitmap::CLAMP_TO_EDGE,
+      gfx::Size(1, 1));
   host_impl_->CreateUIResource(ui_resource_id, bitmap);
   EXPECT_EQ(1u, context3d->NumTextures());
   ResourceProvider::ResourceId id1 =
       host_impl_->ResourceIdForUIResource(ui_resource_id);
   EXPECT_NE(0u, id1);
 
   // Multiple requests with the same id is allowed.  The previous texture is
   // deleted.
   host_impl_->CreateUIResource(ui_resource_id, bitmap);
   EXPECT_EQ(1u, context3d->NumTextures());
@@ skipping 15 matching lines @@
   EXPECT_EQ(0u, host_impl_->ResourceIdForUIResource(ui_resource_id));
   EXPECT_EQ(0u, context3d->NumTextures());
 
   // Should not change state for multiple deletion on one UIResourceId
   host_impl_->DeleteUIResource(ui_resource_id);
   EXPECT_EQ(0u, context3d->NumTextures());
 }
 
 }  // namespace
 }  // namespace cc