1 files changed, 77 insertions, 17 deletions

diff --git a/chromium/cc/layers/ui_resource_layer_impl_unittest.cc b/chromium/cc/layers/ui_resource_layer_impl_unittest.cc
index 4a2a1164182..cd0d7bf02f7 100644
--- a/chromium/cc/layers/ui_resource_layer_impl_unittest.cc
+++ b/chromium/cc/layers/ui_resource_layer_impl_unittest.cc
@@ -11,6 +11,7 @@
 #include "cc/test/fake_ui_resource_layer_tree_host_impl.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/mock_quad_culler.h"
+#include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -21,8 +22,8 @@ namespace {
 
 scoped_ptr<UIResourceLayerImpl> GenerateUIResourceLayer(
     FakeUIResourceLayerTreeHostImpl* host_impl,
-    gfx::Size bitmap_size,
-    gfx::Size layer_size,
+    const gfx::Size& bitmap_size,
+    const gfx::Size& layer_size,
     bool opaque,
     UIResourceId uid) {
   gfx::Rect visible_content_rect(layer_size);
@@ -34,15 +35,7 @@ scoped_ptr<UIResourceLayerImpl> GenerateUIResourceLayer(
   layer->CreateRenderSurface();
   layer->draw_properties().render_target = layer.get();
 
-  SkBitmap skbitmap;
-  skbitmap.setConfig(SkBitmap::kARGB_8888_Config,
-                     bitmap_size.width(),
-                     bitmap_size.height(),
-                     0,
-                     opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
-  skbitmap.allocPixels();
-  skbitmap.setImmutable();
-  UIResourceBitmap bitmap(skbitmap);
+  UIResourceBitmap bitmap(bitmap_size, opaque);
 
   host_impl->CreateUIResource(uid, bitmap);
   layer->SetUIResourceId(uid);
@@ -52,7 +45,10 @@ scoped_ptr<UIResourceLayerImpl> GenerateUIResourceLayer(
 
 void QuadSizeTest(scoped_ptr<UIResourceLayerImpl> layer,
                   size_t expected_quad_size) {
-  MockQuadCuller quad_culler;
+  MockOcclusionTracker<LayerImpl> occlusion_tracker;
+  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  MockQuadCuller quad_culler(render_pass.get(), &occlusion_tracker);
+
   AppendQuadsData data;
   layer->AppendQuads(&quad_culler, &data);
 
@@ -63,7 +59,8 @@ void QuadSizeTest(scoped_ptr<UIResourceLayerImpl> layer,
 
 TEST(UIResourceLayerImplTest, VerifyDrawQuads) {
   FakeImplProxy proxy;
-  FakeUIResourceLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeUIResourceLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   // Make sure we're appending quads when there are valid values.
   gfx::Size bitmap_size(100, 100);
   gfx::Size layer_size(100, 100);;
@@ -89,8 +86,11 @@ TEST(UIResourceLayerImplTest, VerifyDrawQuads) {
 }
 
 void OpaqueBoundsTest(scoped_ptr<UIResourceLayerImpl> layer,
-                 gfx::Rect expected_opaque_bounds) {
-  MockQuadCuller quad_culler;
+                 const gfx::Rect& expected_opaque_bounds) {
+  MockOcclusionTracker<LayerImpl> occlusion_tracker;
+  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  MockQuadCuller quad_culler(render_pass.get(), &occlusion_tracker);
+
   AppendQuadsData data;
   layer->AppendQuads(&quad_culler, &data);
 
@@ -103,7 +103,8 @@ void OpaqueBoundsTest(scoped_ptr<UIResourceLayerImpl> layer,
 
 TEST(UIResourceLayerImplTest, VerifySetOpaqueOnSkBitmap) {
   FakeImplProxy proxy;
-  FakeUIResourceLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeUIResourceLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
 
   gfx::Size bitmap_size(100, 100);
   gfx::Size layer_size(100, 100);;
@@ -129,7 +130,8 @@ TEST(UIResourceLayerImplTest, VerifySetOpaqueOnSkBitmap) {
 
 TEST(UIResourceLayerImplTest, VerifySetOpaqueOnLayer) {
   FakeImplProxy proxy;
-  FakeUIResourceLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeUIResourceLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
 
   gfx::Size bitmap_size(100, 100);
   gfx::Size layer_size(100, 100);
@@ -148,5 +150,63 @@ TEST(UIResourceLayerImplTest, VerifySetOpaqueOnLayer) {
   OpaqueBoundsTest(layer.Pass(), expected_opaque_bounds);
 }
 
+TEST(UIResourceLayerImplTest, Occlusion) {
+  gfx::Size layer_size(1000, 1000);
+  gfx::Size viewport_size(1000, 1000);
+
+  LayerTestCommon::LayerImplTest impl;
+
+  SkBitmap sk_bitmap;
+  sk_bitmap.allocN32Pixels(10, 10);
+  sk_bitmap.setImmutable();
+  UIResourceId uid = 5;
+  UIResourceBitmap bitmap(sk_bitmap);
+  impl.host_impl()->CreateUIResource(uid, bitmap);
+
+  UIResourceLayerImpl* ui_resource_layer_impl =
+      impl.AddChildToRoot<UIResourceLayerImpl>();
+  ui_resource_layer_impl->SetBounds(layer_size);
+  ui_resource_layer_impl->SetContentBounds(layer_size);
+  ui_resource_layer_impl->SetDrawsContent(true);
+  ui_resource_layer_impl->SetUIResourceId(uid);
+
+  impl.CalcDrawProps(viewport_size);
+
+  {
+    SCOPED_TRACE("No occlusion");
+    gfx::Rect occluded;
+    impl.AppendQuadsWithOcclusion(ui_resource_layer_impl, occluded);
+
+    LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
+                                                 gfx::Rect(layer_size));
+    EXPECT_EQ(1u, impl.quad_list().size());
+  }
+
+  {
+    SCOPED_TRACE("Full occlusion");
+    gfx::Rect occluded(ui_resource_layer_impl->visible_content_rect());
+    impl.AppendQuadsWithOcclusion(ui_resource_layer_impl, occluded);
+
+    LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
+    EXPECT_EQ(impl.quad_list().size(), 0u);
+  }
+
+  {
+    SCOPED_TRACE("Partial occlusion");
+    gfx::Rect occluded(200, 0, 800, 1000);
+    impl.AppendQuadsWithOcclusion(ui_resource_layer_impl, occluded);
+
+    size_t partially_occluded_count = 0;
+    LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
+        impl.quad_list(),
+        gfx::Rect(layer_size),
+        occluded,
+        &partially_occluded_count);
+    // The layer outputs one quad, which is partially occluded.
+    EXPECT_EQ(1u, impl.quad_list().size());
+    EXPECT_EQ(1u, partially_occluded_count);
+  }
+}
+
 }  // namespace
 }  // namespace cc