cc: Apply occlusion before creating quads in SolidColorScrollbarLayerImpl.

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
BUG=344962

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

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

4 files changed, 95 insertions, 5 deletions

diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp
index 73e4a06..0c7bb62 100644
--- a/cc/cc_tests.gyp
+++ b/cc/cc_tests.gyp
@@ -43,6 +43,7 @@
       'layers/render_surface_unittest.cc',
       'layers/scrollbar_layer_unittest.cc',
       'layers/solid_color_layer_impl_unittest.cc',
+      'layers/solid_color_scrollbar_layer_impl_unittest.cc',
       'layers/surface_layer_impl_unittest.cc',
       'layers/texture_layer_unittest.cc',
       'layers/texture_layer_impl_unittest.cc',
diff --git a/cc/layers/solid_color_scrollbar_layer_impl.cc b/cc/layers/solid_color_scrollbar_layer_impl.cc
index 395cca2..211108a 100644
--- a/cc/layers/solid_color_scrollbar_layer_impl.cc
+++ b/cc/layers/solid_color_scrollbar_layer_impl.cc
@@ -91,17 +91,20 @@ bool SolidColorScrollbarLayerImpl::IsThumbResizable() const {
 
 void SolidColorScrollbarLayerImpl::AppendQuads(QuadSink* quad_sink,
                            AppendQuadsData* append_quads_data) {
-  gfx::Rect thumb_quad_rect(ComputeThumbQuadRect());
-  gfx::Rect visible_quad_rect(thumb_quad_rect);
-
   SharedQuadState* shared_quad_state =
       quad_sink->UseSharedQuadState(CreateSharedQuadState());
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
+  gfx::Rect thumb_quad_rect(ComputeThumbQuadRect());
+  gfx::Rect visible_quad_rect = quad_sink->UnoccludedContentRect(
+      thumb_quad_rect, draw_properties().target_space_transform);
+  if (visible_quad_rect.IsEmpty())
+    return;
+
   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
   quad->SetNew(
       shared_quad_state, thumb_quad_rect, visible_quad_rect, color_, false);
-  quad_sink->MaybeAppend(quad.PassAs<DrawQuad>());
+  quad_sink->Append(quad.PassAs<DrawQuad>());
 }
 
 }  // namespace cc
diff --git a/cc/layers/solid_color_scrollbar_layer_impl_unittest.cc b/cc/layers/solid_color_scrollbar_layer_impl_unittest.cc
new file mode 100644
index 0000000..0317015
--- /dev/null
+++ b/cc/layers/solid_color_scrollbar_layer_impl_unittest.cc
@@ -0,0 +1,77 @@
+// 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/solid_color_scrollbar_layer_impl.h"
+
+#include "cc/test/layer_test_common.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cc {
+namespace {
+
+TEST(SolidColorScrollbarLayerImplTest, Occlusion) {
+  gfx::Size layer_size(10, 1000);
+  gfx::Size viewport_size(1000, 1000);
+
+  LayerTestCommon::LayerImplTest impl;
+
+  ScrollbarOrientation orientation = VERTICAL;
+  int thumb_thickness = layer_size.width();
+  bool is_left_side_vertical_scrollbar = false;
+  bool is_overlay = false;
+
+  SolidColorScrollbarLayerImpl* scrollbar_layer_impl =
+      impl.AddChildToRoot<SolidColorScrollbarLayerImpl>(
+          orientation,
+          thumb_thickness,
+          is_left_side_vertical_scrollbar,
+          is_overlay);
+  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->SetCurrentPos(100.f / 4);
+  scrollbar_layer_impl->SetMaximum(100);
+  scrollbar_layer_impl->SetVisibleToTotalLengthRatio(1.f / 2);
+
+  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);
+
+    LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), thumb_rect);
+    EXPECT_EQ(1u, impl.quad_list().size());
+  }
+
+  {
+    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 one quad, which is partially occluded.
+    EXPECT_EQ(1u, impl.quad_list().size());
+    EXPECT_EQ(1u, partially_occluded_count);
+  }
+}
+
+}  // namespace
+}  // namespace cc
diff --git a/cc/test/layer_test_common.h b/cc/test/layer_test_common.h
index 6caa604..cb56417 100644
--- a/cc/test/layer_test_common.h
+++ b/cc/test/layer_test_common.h
@@ -59,13 +59,22 @@ class LayerTestCommon {
     }
 
     template <typename T, typename A>
-    T* AddChildToRoot(A a) {
+    T* AddChildToRoot(const A& a) {
       scoped_ptr<T> layer = T::Create(host_->host_impl()->active_tree(), 2, a);
       T* ptr = layer.get();
       root_layer_impl_->AddChild(layer.template PassAs<LayerImpl>());
       return ptr;
     }
 
+    template <typename T, typename A, typename B, typename C, typename D>
+    T* AddChildToRoot(const A& a, const B& b, const C& c, const D& d) {
+      scoped_ptr<T> layer =
+          T::Create(host_->host_impl()->active_tree(), 2, a, b, c, d);
+      T* ptr = layer.get();
+      root_layer_impl_->AddChild(layer.template PassAs<LayerImpl>());
+      return ptr;
+    }
+
     void CalcDrawProps(const gfx::Size& viewport_size);
     void AppendQuadsWithOcclusion(LayerImpl* layer_impl,
                                   const gfx::Rect& occluded);