cc: Make PaintedScrollbarLayer not use ContentsScalingLayer

cc/layers/scrollbar_layer_unittest.cc

 // Copyright 2012 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 "base/containers/hash_tables.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/scrollbar_layer_interface.h"
@@ skipping 560 matching lines @@
   void BeginTest() override {
     scroll_layer_ = Layer::Create();
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
 
     scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
     scrollbar_layer_ =
         PaintedScrollbarLayer::Create(scrollbar.Pass(), scroll_layer_->id());
     scrollbar_layer_->SetScrollLayer(scroll_layer_->id());
     scrollbar_layer_->SetLayerTreeHost(layer_tree_host());
     scrollbar_layer_->SetBounds(bounds_);
+    scrollbar_layer_->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(scrollbar_layer_);
 
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommitAndDrawFrame() override {
     const int kMaxTextureSize =
         layer_tree_host()->GetRendererCapabilities().max_texture_size;
 
     // Check first that we're actually testing something.
     EXPECT_GT(scrollbar_layer_->bounds().width(), kMaxTextureSize);
 
-    EXPECT_EQ(scrollbar_layer_->content_bounds().width(),
+    EXPECT_EQ(scrollbar_layer_->internal_content_bounds().width(),
               kMaxTextureSize - 1);
-    EXPECT_EQ(scrollbar_layer_->content_bounds().height(),
+    EXPECT_EQ(scrollbar_layer_->internal_content_bounds().height(),
               kMaxTextureSize - 1);
 
     EndTest();
   }
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<PaintedScrollbarLayer> scrollbar_layer_;
   scoped_refptr<Layer> scroll_layer_;
@@ skipping 69 matching lines @@
  private:
   typedef base::hash_map<UIResourceId, UIResourceBitmap>
       UIResourceBitmapMap;
   UIResourceBitmapMap ui_resource_bitmap_map_;
 
   int next_id_;
   int total_ui_resource_created_;
   int total_ui_resource_deleted_;
 };
 
-class ScrollbarLayerTestResourceCreationAndRelease : public testing::Test {
+class ScrollbarLayerResourceTest : public testing::Test {
  public:
-  ScrollbarLayerTestResourceCreationAndRelease()
-      : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
+  ScrollbarLayerResourceTest()
+      : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {
+    layer_tree_settings_.single_thread_proxy_scheduler = false;
+    layer_tree_host_.reset(
+        new FakeLayerTreeHost(&fake_client_, layer_tree_settings_));
+    fake_client_.SetLayerTreeHost(layer_tree_host_.get());
+    // Force output surface creation for renderer capabilities.

[enne (OOO), 2015/02/11 21:41:59]

Previously the MaxTextureSize (which reached into renderer capabilities, which
dchecks output surface lost) only happened during CDP, which doesn't happen in
these tests.  Because Update does happen (where the max texture size clamping
moved to), they suddenly need an output surface.

+    layer_tree_host_->Composite(base::TimeTicks());
+    EXPECT_FALSE(layer_tree_host_->output_surface_lost());
+  }
 
+ protected:
+  FakeLayerTreeHostClient fake_client_;
+  LayerTreeSettings layer_tree_settings_;
+  scoped_ptr<FakeLayerTreeHost> layer_tree_host_;
+};
+
+class ScrollbarLayerTestResourceCreationAndRelease
+    : public ScrollbarLayerResourceTest {
+ public:
   void TestResourceUpload(int num_updates,
                           size_t expected_resources,
                           int expected_created,
                           int expected_deleted,
                           bool use_solid_color_scrollbar) {
-    layer_tree_host_.reset(
-        new FakeLayerTreeHost(&fake_client_, layer_tree_settings_));
-
     scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar(false, true, false));
     scoped_refptr<Layer> layer_tree_root = Layer::Create();
     scoped_refptr<Layer> content_layer = Layer::Create();
     scoped_refptr<Layer> scrollbar_layer;
     if (use_solid_color_scrollbar) {
       const int kThumbThickness = 3;
       const int kTrackStart = 0;
       const bool kIsLeftSideVerticalScrollbar = false;
       scrollbar_layer =
           SolidColorScrollbarLayer::Create(scrollbar->Orientation(),
@@ skipping 34 matching lines @@
 
     // A non-solid-color scrollbar should have requested two textures.
     EXPECT_EQ(expected_resources, layer_tree_host_->UIResourceCount());
     EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
     EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
 
     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
     scrollbar_layer->ClearRenderSurface();
   }
-
- protected:
-  FakeLayerTreeHostClient fake_client_;
-  LayerTreeSettings layer_tree_settings_;
-  scoped_ptr<FakeLayerTreeHost> layer_tree_host_;
 };
 
 TEST_F(ScrollbarLayerTestResourceCreationAndRelease, ResourceUpload) {
   bool use_solid_color_scrollbars = false;
   TestResourceUpload(0, 0, 0, 0, use_solid_color_scrollbars);
   int num_updates[3] = {1, 5, 10};
+  int created = 0;
+  int deleted = 0;
   for (int j = 0; j < 3; j++) {
-    TestResourceUpload(num_updates[j],
-                       2,
-                       num_updates[j] * 2,
-                       (num_updates[j] - 1) * 2,
+    created += num_updates[j] * 2;

[enne (OOO), 2015/02/11 21:41:59]

This test used to recreate the LTH every time, but rather than refactoring the
creation function, I just accumulated the values here.  The test is ultimately
the same.

+    deleted = created - 2;
+    TestResourceUpload(num_updates[j], 2, created, deleted,
                        use_solid_color_scrollbars);
   }
 }
 
 TEST_F(ScrollbarLayerTestResourceCreationAndRelease,
        SolidColorNoResourceUpload) {
   bool use_solid_color_scrollbars = true;
   TestResourceUpload(0, 0, 0, 0, use_solid_color_scrollbars);
   TestResourceUpload(1, 0, 0, 0, use_solid_color_scrollbars);
 }
 
 TEST_F(ScrollbarLayerTestResourceCreationAndRelease, TestResourceUpdate) {
-  FakeLayerTreeHostClient fake_client_(FakeLayerTreeHostClient::DIRECT_3D);
-  LayerTreeSettings layer_tree_settings_;
-  scoped_ptr<FakeLayerTreeHost> layer_tree_host_;
-
-  layer_tree_host_.reset(
-      new FakeLayerTreeHost(&fake_client_, layer_tree_settings_));
-
   gfx::Point scrollbar_location(0, 185);
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
   scoped_refptr<Layer> content_layer = Layer::Create();
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
       FakePaintedScrollbarLayer::Create(false, true, layer_tree_root->id());
 
   layer_tree_root->AddChild(content_layer);
   layer_tree_root->AddChild(scrollbar_layer);
 
   layer_tree_host_->SetRootLayer(layer_tree_root);
@@ skipping 114 matching lines @@
   EXPECT_NE(0, scrollbar_layer->track_resource_id());
   EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
   EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
   EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
   EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
 
   testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   scrollbar_layer->ClearRenderSurface();
 }
 
-class ScaledScrollbarLayerTestResourceCreation : public testing::Test {
+class ScaledScrollbarLayerTestResourceCreation
+    : public ScrollbarLayerResourceTest {
  public:
-  ScaledScrollbarLayerTestResourceCreation()
-      : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
-
   void TestResourceUpload(const float test_scale) {
-    layer_tree_host_.reset(
-        new FakeLayerTreeHost(&fake_client_, layer_tree_settings_));
-
     gfx::Point scrollbar_location(0, 185);
     scoped_refptr<Layer> layer_tree_root = Layer::Create();
     scoped_refptr<Layer> content_layer = Layer::Create();
     scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
         FakePaintedScrollbarLayer::Create(false, true, layer_tree_root->id());
 
     layer_tree_root->AddChild(content_layer);
     layer_tree_root->AddChild(scrollbar_layer);
 
     layer_tree_host_->SetRootLayer(layer_tree_root);
@@ skipping 29 matching lines @@
     scrollbar_layer->Update(&queue, &occlusion_tracker);
 
     // Verify that we have not generated any content uploads that are larger
     // than their destination textures.
 
     gfx::Size track_size = layer_tree_host_->ui_resource_size(
         scrollbar_layer->track_resource_id());
     gfx::Size thumb_size = layer_tree_host_->ui_resource_size(
         scrollbar_layer->thumb_resource_id());
 
-    EXPECT_LE(track_size.width(), scrollbar_layer->content_bounds().width());
-    EXPECT_LE(track_size.height(), scrollbar_layer->content_bounds().height());
-    EXPECT_LE(thumb_size.width(), scrollbar_layer->content_bounds().width());
-    EXPECT_LE(thumb_size.height(), scrollbar_layer->content_bounds().height());
+    EXPECT_LE(track_size.width(),
+              scrollbar_layer->internal_content_bounds().width());
+    EXPECT_LE(track_size.height(),
+              scrollbar_layer->internal_content_bounds().height());
+    EXPECT_LE(thumb_size.width(),
+              scrollbar_layer->internal_content_bounds().width());
+    EXPECT_LE(thumb_size.height(),
+              scrollbar_layer->internal_content_bounds().height());
 
     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
     scrollbar_layer->ClearRenderSurface();
   }
-
- protected:
-  FakeLayerTreeHostClient fake_client_;
-  LayerTreeSettings layer_tree_settings_;
-  scoped_ptr<FakeLayerTreeHost> layer_tree_host_;
 };
 
 TEST_F(ScaledScrollbarLayerTestResourceCreation, ScaledResourceUpload) {
   // Pick a test scale that moves the scrollbar's (non-zero) position to
   // a non-pixel-aligned location.
   TestResourceUpload(.041f);
   TestResourceUpload(1.41f);
   TestResourceUpload(4.1f);
 }
 
-class ScaledScrollbarLayerTestScaledRasterization : public testing::Test {
+class ScaledScrollbarLayerTestScaledRasterization
+    : public ScrollbarLayerResourceTest {
  public:
-  ScaledScrollbarLayerTestScaledRasterization()
-      : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
-
   void TestScale(const gfx::Rect scrollbar_rect, const float test_scale) {
-    layer_tree_host_.reset(
-        new FakeLayerTreeHost(&fake_client_, layer_tree_settings_));
-
     bool paint_during_update = true;
     bool has_thumb = false;
     scoped_refptr<Layer> layer_tree_root = Layer::Create();
     scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
         FakePaintedScrollbarLayer::Create(paint_during_update,
                                           has_thumb,
                                           layer_tree_root->id());
 
     layer_tree_root->AddChild(scrollbar_layer);
 
@@ skipping 53 matching lines @@
   }
 
  protected:
   // On Android, Skia uses ABGR
   static SkColor argb_to_skia(SkColor c) {
       return (SkColorGetA(c) << SK_A32_SHIFT) |
              (SkColorGetR(c) << SK_R32_SHIFT) |
              (SkColorGetG(c) << SK_G32_SHIFT) |
              (SkColorGetB(c) << SK_B32_SHIFT);
   }
-
-  FakeLayerTreeHostClient fake_client_;
-  LayerTreeSettings layer_tree_settings_;
-  scoped_ptr<FakeLayerTreeHost> layer_tree_host_;
 };
 
 TEST_F(ScaledScrollbarLayerTestScaledRasterization, TestLostPrecisionInClip) {
   // Try rasterization at coordinates and scale that caused problematic
   // rounding and clipping errors.
   // Vertical Scrollbars.
   TestScale(gfx::Rect(1240, 0, 15, 1333), 2.7754839f);
   TestScale(gfx::Rect(1240, 0, 15, 677), 2.46677136f);
 
   // Horizontal Scrollbars.
   TestScale(gfx::Rect(0, 1240, 1333, 15), 2.7754839f);
   TestScale(gfx::Rect(0, 1240, 677, 15), 2.46677136f);
 }
 
 }  // namespace
 }  // namespace cc