cc: Apply occlusion before creating quads in PaintedScrollbarLayerImpl.

This makes the AppendQuads method query occlusion directly and subtract
it from the quads it would create before they are created, skipping
quads that are completely occluded and avoiding a malloc/free for them.

R=enne@chromium.org
BUG=344962

Review URL: https://codereview.chromium.org/240833004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@264571 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 110 insertions, 8 deletions

diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp
index e5a533b..b67daf6 100644
--- a/cc/cc_tests.gyp
+++ b/cc/cc_tests.gyp
@@ -37,6 +37,7 @@
       'layers/layer_utils_unittest.cc',
       'layers/nine_patch_layer_impl_unittest.cc',
       'layers/nine_patch_layer_unittest.cc',
+      'layers/painted_scrollbar_layer_impl_unittest.cc',
       'layers/picture_image_layer_impl_unittest.cc',
       'layers/picture_layer_impl_unittest.cc',
       'layers/picture_layer_unittest.cc',
diff --git a/cc/layers/painted_scrollbar_layer_impl.cc b/cc/layers/painted_scrollbar_layer_impl.cc
index 25138ca..e4677f7 100644
--- a/cc/layers/painted_scrollbar_layer_impl.cc
+++ b/cc/layers/painted_scrollbar_layer_impl.cc
@@ -83,14 +83,15 @@ void PaintedScrollbarLayerImpl::AppendQuads(
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   gfx::Rect thumb_quad_rect = ComputeThumbQuadRect();
-  gfx::Rect visible_thumb_quad_rect = thumb_quad_rect;
+  gfx::Rect visible_thumb_quad_rect =
+      quad_sink->UnoccludedContentRect(thumb_quad_rect, draw_transform());
 
   ResourceProvider::ResourceId thumb_resource_id =
       layer_tree_impl()->ResourceIdForUIResource(thumb_ui_resource_id_);
   ResourceProvider::ResourceId track_resource_id =
       layer_tree_impl()->ResourceIdForUIResource(track_ui_resource_id_);
 
-  if (thumb_resource_id && !thumb_quad_rect.IsEmpty()) {
+  if (thumb_resource_id && !visible_thumb_quad_rect.IsEmpty()) {
     gfx::Rect opaque_rect;
     const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
@@ -105,12 +106,13 @@ void PaintedScrollbarLayerImpl::AppendQuads(
                  SK_ColorTRANSPARENT,
                  opacity,
                  flipped);
-    quad_sink->MaybeAppend(quad.PassAs<DrawQuad>());
+    quad_sink->Append(quad.PassAs<DrawQuad>());
   }
 
   gfx::Rect track_quad_rect = content_bounds_rect;
-  gfx::Rect visible_track_quad_rect = track_quad_rect;
-  if (track_resource_id && !track_quad_rect.IsEmpty()) {
+  gfx::Rect visible_track_quad_rect =
+      quad_sink->UnoccludedContentRect(track_quad_rect, draw_transform());
+  if (track_resource_id && !visible_track_quad_rect.IsEmpty()) {
     gfx::Rect opaque_rect(contents_opaque() ? track_quad_rect : gfx::Rect());
     const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
@@ -125,7 +127,7 @@ void PaintedScrollbarLayerImpl::AppendQuads(
                  SK_ColorTRANSPARENT,
                  opacity,
                  flipped);
-    quad_sink->MaybeAppend(quad.PassAs<DrawQuad>());
+    quad_sink->Append(quad.PassAs<DrawQuad>());
   }
 }
 
diff --git a/cc/layers/painted_scrollbar_layer_impl_unittest.cc b/cc/layers/painted_scrollbar_layer_impl_unittest.cc
new file mode 100644
index 0000000..f6d3ded
--- /dev/null
+++ b/cc/layers/painted_scrollbar_layer_impl_unittest.cc
@@ -0,0 +1,95 @@
+// Copyright 2014 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/layers/painted_scrollbar_layer_impl.h"
+
+#include "cc/test/layer_test_common.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cc {
+namespace {
+
+TEST(PaintedScrollbarLayerImplTest, Occlusion) {
+  gfx::Size layer_size(10, 1000);
+  gfx::Size viewport_size(1000, 1000);
+
+  LayerTestCommon::LayerImplTest impl;
+
+  SkBitmap thumb_sk_bitmap;
+  thumb_sk_bitmap.allocN32Pixels(10, 10);
+  thumb_sk_bitmap.setImmutable();
+  UIResourceId thumb_uid = 5;
+  UIResourceBitmap thumb_bitmap(thumb_sk_bitmap);
+  impl.host_impl()->CreateUIResource(thumb_uid, thumb_bitmap);
+
+  SkBitmap track_sk_bitmap;
+  track_sk_bitmap.allocN32Pixels(10, 10);
+  track_sk_bitmap.setImmutable();
+  UIResourceId track_uid = 6;
+  UIResourceBitmap track_bitmap(track_sk_bitmap);
+  impl.host_impl()->CreateUIResource(track_uid, track_bitmap);
+
+  ScrollbarOrientation orientation = VERTICAL;
+
+  PaintedScrollbarLayerImpl* scrollbar_layer_impl =
+      impl.AddChildToRoot<PaintedScrollbarLayerImpl>(orientation);
+  scrollbar_layer_impl->SetAnchorPoint(gfx::PointF());
+  scrollbar_layer_impl->SetBounds(layer_size);
+  scrollbar_layer_impl->SetContentBounds(layer_size);
+  scrollbar_layer_impl->SetDrawsContent(true);
+  scrollbar_layer_impl->SetThumbThickness(layer_size.width());
+  scrollbar_layer_impl->SetThumbLength(500);
+  scrollbar_layer_impl->SetTrackLength(layer_size.height());
+  scrollbar_layer_impl->SetCurrentPos(100.f / 4);
+  scrollbar_layer_impl->SetMaximum(100);
+  scrollbar_layer_impl->SetVisibleToTotalLengthRatio(1.f / 2);
+  scrollbar_layer_impl->set_track_ui_resource_id(track_uid);
+  scrollbar_layer_impl->set_thumb_ui_resource_id(thumb_uid);
+
+  impl.CalcDrawProps(viewport_size);
+
+  gfx::Rect thumb_rect = scrollbar_layer_impl->ComputeThumbQuadRect();
+  EXPECT_EQ(gfx::Rect(0, 500 / 4, 10, layer_size.height() / 2).ToString(),
+            thumb_rect.ToString());
+
+  {
+    SCOPED_TRACE("No occlusion");
+    gfx::Rect occluded;
+    impl.AppendQuadsWithOcclusion(scrollbar_layer_impl, occluded);
+
+    size_t partially_occluded_count = 0;
+    LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
+        impl.quad_list(),
+        gfx::Rect(layer_size),
+        occluded,
+        &partially_occluded_count);
+    EXPECT_EQ(2u, impl.quad_list().size());
+    EXPECT_EQ(0u, partially_occluded_count);
+  }
+
+  {
+    SCOPED_TRACE("Full occlusion");
+    gfx::Rect occluded(scrollbar_layer_impl->visible_content_rect());
+    impl.AppendQuadsWithOcclusion(scrollbar_layer_impl, occluded);
+
+    LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
+    EXPECT_EQ(impl.quad_list().size(), 0u);
+  }
+
+  {
+    SCOPED_TRACE("Partial occlusion");
+    gfx::Rect occluded(0, 0, 5, 1000);
+    impl.AppendQuadsWithOcclusion(scrollbar_layer_impl, occluded);
+
+    size_t partially_occluded_count = 0;
+    LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
+        impl.quad_list(), thumb_rect, occluded, &partially_occluded_count);
+    // The layer outputs two quads, which is partially occluded.
+    EXPECT_EQ(2u, impl.quad_list().size());
+    EXPECT_EQ(2u, partially_occluded_count);
+  }
+}
+
+}  // namespace
+}  // namespace cc
diff --git a/cc/test/layer_test_common.cc b/cc/test/layer_test_common.cc
index a3ab907..6661644 100644
--- a/cc/test/layer_test_common.cc
+++ b/cc/test/layer_test_common.cc
@@ -50,8 +50,12 @@ void LayerTestCommon::VerifyQuadsExactlyCoverRect(const QuadList& quads,
 
     gfx::Rect quad_rect = gfx::ToEnclosingRect(quad_rectf);
 
-    EXPECT_TRUE(rect.Contains(quad_rect)) << quad_string << i;
-    EXPECT_TRUE(remaining.Contains(quad_rect)) << quad_string << i;
+    EXPECT_TRUE(rect.Contains(quad_rect)) << quad_string << i
+                                          << " rect: " << rect.ToString()
+                                          << " quad: " << quad_rect.ToString();
+    EXPECT_TRUE(remaining.Contains(quad_rect))
+        << quad_string << i << " remaining: " << remaining.ToString()
+        << " quad: " << quad_rect.ToString();
     remaining.Subtract(quad_rect);
   }