Revert of Move scaling of ui resources for scrollbars to the time of upload

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 <stddef.h>
 
 #include <unordered_map>
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation_host.h"
 #include "cc/input/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"
 #include "cc/layers/solid_color_scrollbar_layer.h"
 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_painted_scrollbar_layer.h"
 #include "cc/test/fake_scrollbar.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/mock_occlusion_tracker.h"
 #include "cc/test/stub_layer_tree_host_single_thread_client.h"
-#include "cc/test/test_context_provider.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/scroll_node.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 694 matching lines @@
   // The vertical adjustment factor has two effects:
   // 1.) Moves the horizontal scrollbar down
   // 2.) Increases the vertical scrollbar's effective track length which both
   // increases the thumb's length and its position within the track.
   EXPECT_EQ(gfx::Rect(20.f, 10.f, 20.f, 3.f),
             horizontal_scrollbar_layer_->ComputeThumbQuadRect());
   EXPECT_EQ(gfx::Rect(0.f, 22, 3.f, 22.f),
             vertical_scrollbar_layer_->ComputeThumbQuadRect());
 }
 
+class ScrollbarLayerTestWithFixedScrollbarBounds : public LayerTreeTest {
+ public:
+  ScrollbarLayerTestWithFixedScrollbarBounds() {}
+
+  void SetScrollbarBounds(const gfx::Size& bounds) { bounds_ = bounds; }
+
+  void BeginTest() override {
+    scroll_layer_ = Layer::Create();
+    layer_tree()->root_layer()->AddChild(scroll_layer_);
+
+    std::unique_ptr<Scrollbar> scrollbar(new FakeScrollbar);
+    scrollbar_layer_ = PaintedScrollbarLayer::Create(std::move(scrollbar),
+                                                     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()->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_->internal_content_bounds().width(),
+              kMaxTextureSize - 1);
+    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_;
+  gfx::Size bounds_;
+};
+
+TEST_F(ScrollbarLayerTestWithFixedScrollbarBounds, MaxTextureSize) {
+  std::unique_ptr<TestWebGraphicsContext3D> context =
+      TestWebGraphicsContext3D::Create();
+  int max_size = 0;
+  context->getIntegerv(GL_MAX_TEXTURE_SIZE, &max_size);
+  SetScrollbarBounds(gfx::Size(max_size + 100, max_size + 100));
+  RunTest(CompositorMode::THREADED);
+}
+
 class ScrollbarLayerTestResourceCreationAndRelease : public ScrollbarLayerTest {
  public:
   void TestResourceUpload(int num_updates,
                           size_t expected_resources,
                           int expected_created,
                           int expected_deleted,
                           bool use_solid_color_scrollbar) {
     std::unique_ptr<Scrollbar> scrollbar(new FakeScrollbar(false, true, false));
     scoped_refptr<Layer> layer_tree_root = Layer::Create();
     scoped_refptr<Layer> content_layer = Layer::Create();
@@ skipping 213 matching lines @@
     layer_tree_->SetRootLayer(layer_tree_root);
 
     scrollbar_layer->SetIsDrawable(true);
     scrollbar_layer->SetBounds(gfx::Size(100, 15));
     scrollbar_layer->SetPosition(gfx::PointF(scrollbar_location));
     layer_tree_root->SetBounds(gfx::Size(100, 200));
     content_layer->SetBounds(gfx::Size(100, 200));
     scrollbar_layer->set_visible_layer_rect(
         gfx::Rect(scrollbar_location, scrollbar_layer->bounds()));
 
+    testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
     EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
 
     layer_tree_->SetDeviceScaleFactor(test_scale);
 
     scrollbar_layer->SavePaintProperties();
     scrollbar_layer->Update();
 
     // 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->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());
+    EXPECT_LE(track_size.width(),
+              layer_tree_host_->GetRendererCapabilities().max_texture_size);
+    EXPECT_LE(track_size.height(),
+              layer_tree_host_->GetRendererCapabilities().max_texture_size);
+    EXPECT_LE(thumb_size.width(),
+              layer_tree_host_->GetRendererCapabilities().max_texture_size);
+    EXPECT_LE(thumb_size.height(),
+              layer_tree_host_->GetRendererCapabilities().max_texture_size);
+
+    testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   }
 };
 
 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);
 
-  // Try something extreme to be larger than max texture size, and make it a
-  // non-integer for funsies.
-  scoped_refptr<TestContextProvider> context = TestContextProvider::Create();
-  context->BindToCurrentThread();
-  int max_texture_size = 0;
-  context->ContextGL()->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
-  TestResourceUpload(max_texture_size / 9.9f);
+  // Try something extreme to make sure it gets clamped.
+  TestResourceUpload(2147483647.0f);
 }
 
 class ScaledScrollbarLayerTestScaledRasterization : public ScrollbarLayerTest {
  public:
   void TestScale(const gfx::Rect scrollbar_rect, const float test_scale) {
     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,
@@ skipping 61 matching lines @@
   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