[cc] Enable specifying a overhang/gutter texture.

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 2825 matching lines @@
   layer1->SetExpectation(false, false);
   layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
   EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 class LayerTreeHostImplViewportCoveredTest : public LayerTreeHostImplTest {
  public:
+  LayerTreeHostImplViewportCoveredTest() :
+      gutter_quad_material_(DrawQuad::SOLID_COLOR),
+      child_(NULL),
+      did_activate_pending_tree_(false) { }

[enne (OOO), 2013/09/03 23:18:26]

style nit: {}.  Consider running 'git cl format' on your patch.

[ccameron, 2013/09/04 02:36:47]

Done.

+
   void CreateLayerTreeHostImpl(bool always_draw) {
     LayerTreeSettings settings;
     settings.minimum_occlusion_tracking_size = gfx::Size();
     settings.impl_side_painting = true;
     host_impl_ = LayerTreeHostImpl::Create(
         settings, this, &proxy_, &stats_instrumentation_);
 
     scoped_ptr<FakeOutputSurface> output_surface;
     if (always_draw)
       output_surface = FakeOutputSurface::CreateAlwaysDrawAndSwap3d().Pass();
@@ skipping 24 matching lines @@
     child_->SetPosition(layer_rect.origin());
     child_->SetBounds(layer_rect.size());
     child_->SetContentBounds(layer_rect.size());
     child_->SetQuadRect(gfx::Rect(layer_rect.size()));
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     ASSERT_EQ(1u, frame.render_passes.size());
 
-    size_t num_gutter_quads = 0;
-    for (size_t i = 0; i < frame.render_passes[0]->quad_list.size(); ++i)
-      num_gutter_quads += (frame.render_passes[0]->quad_list[i]->material ==
-                           DrawQuad::SOLID_COLOR) ? 1 : 0;
-    EXPECT_EQ(0u, num_gutter_quads);
+    EXPECT_EQ(0u, CountGutterQuads(frame.render_passes[0]->quad_list));
     EXPECT_EQ(1u, frame.render_passes[0]->quad_list.size());
+    ValidateTextureDrawQuads(frame.render_passes[0]->quad_list);
 
     LayerTestCommon::VerifyQuadsExactlyCoverRect(
         frame.render_passes[0]->quad_list, gfx::Rect(viewport_size_));
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Expect fullscreen gutter rect.
   void TestEmptyLayer() {
     gfx::Rect layer_rect(0, 0, 0, 0);
     child_->SetPosition(layer_rect.origin());
     child_->SetBounds(layer_rect.size());
     child_->SetContentBounds(layer_rect.size());
     child_->SetQuadRect(gfx::Rect(layer_rect.size()));
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     ASSERT_EQ(1u, frame.render_passes.size());
 
-    size_t num_gutter_quads = 0;
-    for (size_t i = 0; i < frame.render_passes[0]->quad_list.size(); ++i)
-      num_gutter_quads += (frame.render_passes[0]->quad_list[i]->material ==
-                           DrawQuad::SOLID_COLOR) ? 1 : 0;
-    EXPECT_EQ(1u, num_gutter_quads);
+    EXPECT_EQ(1u, CountGutterQuads(frame.render_passes[0]->quad_list));
     EXPECT_EQ(1u, frame.render_passes[0]->quad_list.size());
+    ValidateTextureDrawQuads(frame.render_passes[0]->quad_list);
 
     LayerTestCommon::VerifyQuadsExactlyCoverRect(
         frame.render_passes[0]->quad_list, gfx::Rect(viewport_size_));
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Expect four surrounding gutter rects.
   void TestLayerInMiddleOfViewport() {
     gfx::Rect layer_rect(500, 500, 200, 200);
     child_->SetPosition(layer_rect.origin());
     child_->SetBounds(layer_rect.size());
     child_->SetContentBounds(layer_rect.size());
     child_->SetQuadRect(gfx::Rect(layer_rect.size()));
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     ASSERT_EQ(1u, frame.render_passes.size());
 
-    size_t num_gutter_quads = 0;
-    for (size_t i = 0; i < frame.render_passes[0]->quad_list.size(); ++i)
-      num_gutter_quads += (frame.render_passes[0]->quad_list[i]->material ==
-                           DrawQuad::SOLID_COLOR) ? 1 : 0;
-    EXPECT_EQ(4u, num_gutter_quads);
+    EXPECT_EQ(4u, CountGutterQuads(frame.render_passes[0]->quad_list));
     EXPECT_EQ(5u, frame.render_passes[0]->quad_list.size());
+    ValidateTextureDrawQuads(frame.render_passes[0]->quad_list);
 
     LayerTestCommon::VerifyQuadsExactlyCoverRect(
         frame.render_passes[0]->quad_list, gfx::Rect(viewport_size_));
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Expect no gutter rects.
   void TestLayerIsLargerThanViewport() {
     gfx::Rect layer_rect(viewport_size_.width() + 10,
                          viewport_size_.height() + 10);
     child_->SetPosition(layer_rect.origin());
     child_->SetBounds(layer_rect.size());
     child_->SetContentBounds(layer_rect.size());
     child_->SetQuadRect(gfx::Rect(layer_rect.size()));
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     ASSERT_EQ(1u, frame.render_passes.size());
 
-    size_t num_gutter_quads = 0;
-    for (size_t i = 0; i < frame.render_passes[0]->quad_list.size(); ++i)
-      num_gutter_quads += (frame.render_passes[0]->quad_list[i]->material ==
-                           DrawQuad::SOLID_COLOR) ? 1 : 0;
-    EXPECT_EQ(0u, num_gutter_quads);
+    EXPECT_EQ(0u, CountGutterQuads(frame.render_passes[0]->quad_list));
     EXPECT_EQ(1u, frame.render_passes[0]->quad_list.size());
+    ValidateTextureDrawQuads(frame.render_passes[0]->quad_list);
 
     host_impl_->DidDrawAllLayers(frame);
   }
 
   virtual void DidActivatePendingTree() OVERRIDE {
     did_activate_pending_tree_ = true;
   }
 
+  void set_gutter_quad_material(DrawQuad::Material material) {
+    gutter_quad_material_ = material;
+  }
+  void set_gutter_texture_size(gfx::Size gutter_texture_size) {
+    gutter_texture_size_ = gutter_texture_size;
+  }
+
  protected:
+  size_t CountGutterQuads(const QuadList& quad_list) {
+    size_t num_gutter_quads = 0;
+    for (size_t i = 0; i < quad_list.size(); ++i) {
+      num_gutter_quads += (quad_list[i]->material ==
+                           gutter_quad_material_) ? 1 : 0;
+    }
+    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) {

[enne (OOO), 2013/09/03 23:18:26]

style nit: early-out with a continue here, rather than indenting the whole
block.

[ccameron, 2013/09/04 02:36:47]

Done.

+        TextureDrawQuad* quad = reinterpret_cast<TextureDrawQuad*>(

[enne (OOO), 2013/09/03 23:18:26]

TextureDrawQuad::MaterialCast(quad_list[i])

[ccameron, 2013/09/04 02:36:47]

Done.

+            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()) /

[enne (OOO), 2013/09/03 23:18:26]

quad->rect.right()

[ccameron, 2013/09/04 02:36:47]

Done.

+                      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()));
+      }
+    }
+  }
+
+  DrawQuad::Material gutter_quad_material_;
+  gfx::Size gutter_texture_size_;
   gfx::Size viewport_size_;
   BlendStateCheckLayer* child_;
   bool did_activate_pending_tree_;
 };
 
 TEST_F(LayerTreeHostImplViewportCoveredTest, ViewportCovered) {
   bool always_draw = false;
   CreateLayerTreeHostImpl(always_draw);
 
   host_impl_->SetViewportSize(viewport_size_);
   SetupActiveTreeLayers();
   TestLayerCoversFullViewport();
   TestEmptyLayer();
   TestLayerInMiddleOfViewport();
   TestLayerIsLargerThanViewport();
 }
 
+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)));
+  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();
+
+  // Change the resource size.
+  host_impl_->SetOverhangUIResource(ui_resource_id, gfx::Size(128, 16));
+  set_gutter_texture_size(gfx::Size(128, 16));
+
+  TestLayerCoversFullViewport();
+  TestEmptyLayer();
+  TestLayerInMiddleOfViewport();
+  TestLayerIsLargerThanViewport();
+}
+
 TEST_F(LayerTreeHostImplViewportCoveredTest, ActiveTreeGrowViewportInvalid) {
   bool always_draw = true;
   CreateLayerTreeHostImpl(always_draw);
 
   // Pending tree to force active_tree size invalid. Not used otherwise.
   host_impl_->CreatePendingTree();
   host_impl_->SetViewportSize(viewport_size_);
   EXPECT_TRUE(host_impl_->active_tree()->ViewportSizeInvalid());
 
   SetupActiveTreeLayers();
   TestEmptyLayer();
   TestLayerInMiddleOfViewport();
   TestLayerIsLargerThanViewport();
 }
 
 TEST_F(LayerTreeHostImplViewportCoveredTest, ActiveTreeShrinkViewportInvalid) {
   bool always_draw = true;
   CreateLayerTreeHostImpl(always_draw);
 
   // Set larger viewport and activate it to active tree.
   host_impl_->CreatePendingTree();
   gfx::Size larger_viewport(viewport_size_.width() + 100,
                             viewport_size_.height() + 100);
   host_impl_->SetViewportSize(larger_viewport);
   EXPECT_TRUE(host_impl_->active_tree()->ViewportSizeInvalid());
-  did_activate_pending_tree_ = false;
   host_impl_->ActivatePendingTree();
   EXPECT_TRUE(did_activate_pending_tree_);
   EXPECT_FALSE(host_impl_->active_tree()->ViewportSizeInvalid());
 
   // Shrink pending tree viewport without activating.
   host_impl_->CreatePendingTree();
   host_impl_->SetViewportSize(viewport_size_);
   EXPECT_TRUE(host_impl_->active_tree()->ViewportSizeInvalid());
 
   SetupActiveTreeLayers();
@@ skipping 3342 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