Refactor cc scrollbar layers to separate solid-color vs desktop.

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/debug/test_web_graphics_context_3d.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/resources/resource_update_queue.h"
 #include "cc/test/fake_impl_proxy.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_quad_culler.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 LayerImpl* LayerImplForScrollAreaAndScrollbar(
     FakeLayerTreeHost* host,
     scoped_ptr<Scrollbar> scrollbar,
-    bool reverse_order) {
+    bool reverse_order,
+    bool use_solid_color_scrollbar,
+    int thumb_thickness) {
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
   scoped_refptr<Layer> child1 = Layer::Create();
-  scoped_refptr<Layer> child2 =
-      PaintedScrollbarLayer::Create(scrollbar.Pass(), child1->id());
+  scoped_refptr<Layer> child2;
+  if (use_solid_color_scrollbar) {
+    child2 = SolidColorScrollbarLayer::Create(
+        scrollbar->Orientation(), thumb_thickness, child1->id());
+  } else {
+    child2 = PaintedScrollbarLayer::Create(scrollbar.Pass(), child1->id());
+  }
   layer_tree_root->AddChild(child1);
   layer_tree_root->InsertChild(child2, reverse_order ? 0 : 1);
   host->SetRootLayer(layer_tree_root);
   return host->CommitAndCreateLayerImplTree();
 }
 
 TEST(ScrollbarLayerTest, ResolveScrollLayerPointer) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
-  LayerImpl* layer_impl_tree_root =
-      LayerImplForScrollAreaAndScrollbar(host.get(), scrollbar.Pass(), false);
+  LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
+      host.get(), scrollbar.Pass(), false, false, 0);
 
   LayerImpl* cc_child1 = layer_impl_tree_root->children()[0];
   PaintedScrollbarLayerImpl* cc_child2 =
       static_cast<PaintedScrollbarLayerImpl*>(
           layer_impl_tree_root->children()[1]);
 
   EXPECT_EQ(cc_child1->horizontal_scrollbar_layer(), cc_child2);
 }
 
 TEST(ScrollbarLayerTest, ResolveScrollLayerPointer_ReverseOrder) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
-  LayerImpl* layer_impl_tree_root =
-      LayerImplForScrollAreaAndScrollbar(host.get(), scrollbar.Pass(), true);
+  LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
+      host.get(), scrollbar.Pass(), true, false, 0);
 
   PaintedScrollbarLayerImpl* cc_child1 =
       static_cast<PaintedScrollbarLayerImpl*>(
           layer_impl_tree_root->children()[0]);
   LayerImpl* cc_child2 = layer_impl_tree_root->children()[1];
 
   EXPECT_EQ(cc_child2->horizontal_scrollbar_layer(), cc_child1);
 }
 
 TEST(ScrollbarLayerTest, ShouldScrollNonOverlayOnMainThread) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
 
   // Create and attach a non-overlay scrollbar.
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
-  LayerImpl* layer_impl_tree_root =
-      LayerImplForScrollAreaAndScrollbar(host.get(), scrollbar.Pass(), false);
+  LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
+      host.get(), scrollbar.Pass(), false, false, 0);
   PaintedScrollbarLayerImpl* scrollbar_layer_impl =
       static_cast<PaintedScrollbarLayerImpl*>(
           layer_impl_tree_root->children()[1]);
 
   // When the scrollbar is not an overlay scrollbar, the scroll should be
   // responded to on the main thread as the compositor does not yet implement
   // scrollbar scrolling.
   EXPECT_EQ(InputHandler::ScrollOnMainThread,
             scrollbar_layer_impl->TryScroll(gfx::Point(0, 0),
                                             InputHandler::Gesture));
 
   // Create and attach an overlay scrollbar.
   scrollbar.reset(new FakeScrollbar(false, false, true));
 
-  layer_impl_tree_root =
-      LayerImplForScrollAreaAndScrollbar(host.get(), scrollbar.Pass(), false);
+  layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
+      host.get(), scrollbar.Pass(), false, false, 0);
   scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
       layer_impl_tree_root->children()[1]);
 
   // The user shouldn't be able to drag an overlay scrollbar and the scroll
   // may be handled in the compositor.
   EXPECT_EQ(InputHandler::ScrollIgnored,
             scrollbar_layer_impl->TryScroll(gfx::Point(0, 0),
                                             InputHandler::Gesture));
 }
 
@@ skipping 14 matching lines @@
 
   host->SetRootLayer(layer_tree_root);
   layer_tree_root->AddChild(content_layer);
   layer_tree_root->AddChild(scrollbar_layer);
 
   layer_tree_root->SavePaintProperties();
   content_layer->SavePaintProperties();
 
   LayerImpl* layer_impl_tree_root = host->CommitAndCreateLayerImplTree();
 
-  PaintedScrollbarLayerImpl* cc_scrollbar_layer =
+  ScrollbarLayerImplBase* cc_scrollbar_layer =
       static_cast<PaintedScrollbarLayerImpl*>(
           layer_impl_tree_root->children()[1]);
 
-  EXPECT_EQ(10.f, cc_scrollbar_layer->CurrentPos());
-  EXPECT_EQ(30, cc_scrollbar_layer->Maximum());
+  EXPECT_EQ(10.f, cc_scrollbar_layer->current_pos());
+  EXPECT_EQ(30, cc_scrollbar_layer->maximum());
 
   layer_tree_root->SetScrollOffset(gfx::Vector2d(100, 200));
   layer_tree_root->SetMaxScrollOffset(gfx::Vector2d(300, 500));
   layer_tree_root->SetBounds(gfx::Size(1000, 2000));
   layer_tree_root->SavePaintProperties();
   content_layer->SetBounds(gfx::Size(1000, 2000));
   content_layer->SavePaintProperties();
 
   ScrollbarAnimationController* scrollbar_controller =
       layer_impl_tree_root->scrollbar_animation_controller();
   layer_impl_tree_root = host->CommitAndCreateLayerImplTree();
   EXPECT_EQ(scrollbar_controller,
             layer_impl_tree_root->scrollbar_animation_controller());
 
-  EXPECT_EQ(100.f, cc_scrollbar_layer->CurrentPos());
-  EXPECT_EQ(300, cc_scrollbar_layer->Maximum());
+  EXPECT_EQ(100.f, cc_scrollbar_layer->current_pos());
+  EXPECT_EQ(300, cc_scrollbar_layer->maximum());
 
   layer_impl_tree_root->ScrollBy(gfx::Vector2d(12, 34));
 
-  EXPECT_EQ(112.f, cc_scrollbar_layer->CurrentPos());
-  EXPECT_EQ(300, cc_scrollbar_layer->Maximum());
+  EXPECT_EQ(112.f, cc_scrollbar_layer->current_pos());
+  EXPECT_EQ(300, cc_scrollbar_layer->maximum());
 }
 
 TEST(ScrollbarLayerTest, ThumbRect) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   scoped_refptr<Layer> root_layer = Layer::Create();
   scoped_refptr<Layer> content_layer = Layer::Create();
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
       FakePaintedScrollbarLayer::Create(false, true, root_layer->id());
 
   root_layer->SetScrollable(true);
@@ skipping 75 matching lines @@
 
   scrollbar_layer->UpdateThumbAndTrackGeometry();
   root_layer_impl = host->CommitAndCreateLayerImplTree();
   scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
       root_layer_impl->children()[1]);
   EXPECT_EQ(gfx::Rect(44, 0, 6, 4).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 }
 
 TEST(ScrollbarLayerTest, SolidColorDrawQuads) {
+  const int kThumbThickness = 3;
+  const int kTrackLength = 100;
+
   LayerTreeSettings layer_tree_settings;
-  layer_tree_settings.solid_color_scrollbars = true;
   scoped_ptr<FakeLayerTreeHost> host =
       FakeLayerTreeHost::Create(layer_tree_settings);
 
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar(false, true, true));
-  LayerImpl* layer_impl_tree_root =
-      LayerImplForScrollAreaAndScrollbar(host.get(), scrollbar.Pass(), false);
-  PaintedScrollbarLayerImpl* scrollbar_layer_impl =
-      static_cast<PaintedScrollbarLayerImpl*>(
+  LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
+      host.get(), scrollbar.Pass(), false, true, kThumbThickness);
+  ScrollbarLayerImplBase* scrollbar_layer_impl =
+      static_cast<SolidColorScrollbarLayerImpl*>(
           layer_impl_tree_root->children()[1]);
-  scrollbar_layer_impl->SetThumbThickness(3);
+  scrollbar_layer_impl->SetBounds(gfx::Size(kTrackLength, kThumbThickness));
   scrollbar_layer_impl->SetCurrentPos(10.f);
   scrollbar_layer_impl->SetMaximum(100);
-  scrollbar_layer_impl->SetTrackLength(100);
   scrollbar_layer_impl->SetVisibleToTotalLengthRatio(0.4f);
 
   // Thickness should be overridden to 3.
   {
     MockQuadCuller quad_culler;
     AppendQuadsData data;
     scrollbar_layer_impl->AppendQuads(&quad_culler, &data);
 
     const QuadList& quads = quad_culler.quad_list();
     ASSERT_EQ(1u, quads.size());
@@ skipping 26 matching lines @@
     scrollbar_layer_impl->AppendQuads(&quad_culler, &data);
 
     const QuadList& quads = quad_culler.quad_list();
     ASSERT_EQ(1u, quads.size());
     EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
     EXPECT_RECT_EQ(gfx::Rect(8, 0, 20, 3), quads[0]->rect);
   }
 }
 
 TEST(ScrollbarLayerTest, LayerDrivenSolidColorDrawQuads) {
+  const int kThumbThickness = 3;
+  const int kTrackLength = 10;
+
   LayerTreeSettings layer_tree_settings;
-  layer_tree_settings.solid_color_scrollbars = true;
+//  layer_tree_settings.solid_color_scrollbars = true; // WJM ??
   scoped_ptr<FakeLayerTreeHost> host =
       FakeLayerTreeHost::Create(layer_tree_settings);
 
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar(false, true, true));
-  LayerImpl* layer_impl_tree_root =
-      LayerImplForScrollAreaAndScrollbar(host.get(), scrollbar.Pass(), false);
-  PaintedScrollbarLayerImpl* scrollbar_layer_impl =
+  LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
+      host.get(), scrollbar.Pass(), false, true, kThumbThickness);
+  ScrollbarLayerImplBase* scrollbar_layer_impl =
       static_cast<PaintedScrollbarLayerImpl*>(
           layer_impl_tree_root->children()[1]);
 
-  scrollbar_layer_impl->SetThumbThickness(3);
-  scrollbar_layer_impl->SetTrackLength(10);
+  scrollbar_layer_impl->SetBounds(gfx::Size(kTrackLength, kThumbThickness));
   scrollbar_layer_impl->SetCurrentPos(4.f);
   scrollbar_layer_impl->SetMaximum(8);
 
   layer_impl_tree_root->SetScrollable(true);
   layer_impl_tree_root->SetHorizontalScrollbarLayer(scrollbar_layer_impl);
   layer_impl_tree_root->SetMaxScrollOffset(gfx::Vector2d(8, 8));
   layer_impl_tree_root->SetBounds(gfx::Size(2, 2));
   layer_impl_tree_root->ScrollBy(gfx::Vector2dF(4.f, 0.f));
 
   {
     MockQuadCuller quad_culler;
     AppendQuadsData data;
     scrollbar_layer_impl->AppendQuads(&quad_culler, &data);
 
     const QuadList& quads = quad_culler.quad_list();
     ASSERT_EQ(1u, quads.size());
     EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
     EXPECT_RECT_EQ(gfx::Rect(3, 0, 3, 3), quads[0]->rect);
   }
 }
 
 class ScrollbarLayerSolidColorThumbTest : public testing::Test {
  public:
   ScrollbarLayerSolidColorThumbTest() {
     LayerTreeSettings layer_tree_settings;
     layer_tree_settings.solid_color_scrollbars = true;
     host_impl_.reset(new FakeLayerTreeHostImpl(layer_tree_settings, &proxy_));
 
-    horizontal_scrollbar_layer_ = PaintedScrollbarLayerImpl::Create(
-        host_impl_->active_tree(), 1, HORIZONTAL);
-    vertical_scrollbar_layer_ = PaintedScrollbarLayerImpl::Create(
-        host_impl_->active_tree(), 2, VERTICAL);
+    const int kThumbThickness = 3;
+
+    horizontal_scrollbar_layer_ = SolidColorScrollbarLayerImpl::Create(
+        host_impl_->active_tree(), 1, HORIZONTAL, kThumbThickness);
+    vertical_scrollbar_layer_ = SolidColorScrollbarLayerImpl::Create(
+        host_impl_->active_tree(), 2, VERTICAL, kThumbThickness);
   }
 
  protected:
   FakeImplProxy proxy_;
   scoped_ptr<FakeLayerTreeHostImpl> host_impl_;
-  scoped_ptr<PaintedScrollbarLayerImpl> horizontal_scrollbar_layer_;
-  scoped_ptr<PaintedScrollbarLayerImpl> vertical_scrollbar_layer_;
+  scoped_ptr<SolidColorScrollbarLayerImpl> horizontal_scrollbar_layer_;
+  scoped_ptr<SolidColorScrollbarLayerImpl> vertical_scrollbar_layer_;
 };
 
 TEST_F(ScrollbarLayerSolidColorThumbTest, SolidColorThumbLength) {
   horizontal_scrollbar_layer_->SetCurrentPos(0);
   horizontal_scrollbar_layer_->SetMaximum(10);
-  horizontal_scrollbar_layer_->SetThumbThickness(3);
 
   // Simple case - one third of the scrollable area is visible, so the thumb
   // should be one third as long as the track.
   horizontal_scrollbar_layer_->SetVisibleToTotalLengthRatio(0.33f);
-  horizontal_scrollbar_layer_->SetTrackLength(100);
+  horizontal_scrollbar_layer_->SetBounds(gfx::Size(100, 3));
   EXPECT_EQ(33, horizontal_scrollbar_layer_->ComputeThumbQuadRect().width());
 
   // The thumb's length should never be less than its thickness.
   horizontal_scrollbar_layer_->SetVisibleToTotalLengthRatio(0.01f);
-  horizontal_scrollbar_layer_->SetTrackLength(100);
+  horizontal_scrollbar_layer_->SetBounds(gfx::Size(100, 3));
   EXPECT_EQ(3, horizontal_scrollbar_layer_->ComputeThumbQuadRect().width());
 }
 
 TEST_F(ScrollbarLayerSolidColorThumbTest, SolidColorThumbPosition) {
-  horizontal_scrollbar_layer_->SetTrackLength(100);
+  horizontal_scrollbar_layer_->SetBounds(gfx::Size(100, 3));
   horizontal_scrollbar_layer_->SetVisibleToTotalLengthRatio(0.1f);
-  horizontal_scrollbar_layer_->SetThumbThickness(3);
 
   horizontal_scrollbar_layer_->SetCurrentPos(0);
   horizontal_scrollbar_layer_->SetMaximum(100);
   EXPECT_EQ(0, horizontal_scrollbar_layer_->ComputeThumbQuadRect().x());
   EXPECT_EQ(10, horizontal_scrollbar_layer_->ComputeThumbQuadRect().width());
 
   horizontal_scrollbar_layer_->SetCurrentPos(100);
   // The thumb is 10px long and the track is 100px, so the maximum thumb
   // position is 90px.
   EXPECT_EQ(90, horizontal_scrollbar_layer_->ComputeThumbQuadRect().x());
 
   horizontal_scrollbar_layer_->SetCurrentPos(80);
   // The scroll position is 80% of the maximum, so the thumb's position should
   // be at 80% of its maximum or 72px.
   EXPECT_EQ(72, horizontal_scrollbar_layer_->ComputeThumbQuadRect().x());
 }
 
 TEST_F(ScrollbarLayerSolidColorThumbTest, SolidColorThumbVerticalAdjust) {
-  PaintedScrollbarLayerImpl* layers[2] =
+  SolidColorScrollbarLayerImpl* layers[2] =
       { horizontal_scrollbar_layer_.get(), vertical_scrollbar_layer_.get() };
   for (size_t i = 0; i < 2; ++i) {
-    layers[i]->SetTrackLength(100);
     layers[i]->SetVisibleToTotalLengthRatio(0.2f);
-    layers[i]->SetThumbThickness(3);
     layers[i]->SetCurrentPos(25);
     layers[i]->SetMaximum(100);
   }
+  layers[0]->SetBounds(gfx::Size(100, 3));
+  layers[1]->SetBounds(gfx::Size(3, 100));
 
   EXPECT_RECT_EQ(gfx::RectF(20.f, 0.f, 20.f, 3.f),
                  horizontal_scrollbar_layer_->ComputeThumbQuadRect());
   EXPECT_RECT_EQ(gfx::RectF(0.f, 20.f, 3.f, 20.f),
                  vertical_scrollbar_layer_->ComputeThumbQuadRect());
 
   horizontal_scrollbar_layer_->SetVerticalAdjust(10.f);
   vertical_scrollbar_layer_->SetVerticalAdjust(10.f);
 
   // The vertical adjustment factor has two effects:
@@ skipping 117 matching lines @@
 
 
 class ScrollbarLayerTestResourceCreation : public testing::Test {
  public:
   ScrollbarLayerTestResourceCreation()
       : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
 
   void TestResourceUpload(int num_updates,
                           size_t expected_resources,
                           int expected_created,
-                          int expected_deleted) {
+                          int expected_deleted,
+                          bool use_solid_color_scrollbar) {
     layer_tree_host_.reset(
         new MockLayerTreeHost(&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 =
-      PaintedScrollbarLayer::Create(scrollbar.Pass(), layer_tree_root->id());
+    scoped_refptr<Layer> scrollbar_layer;
+    if (use_solid_color_scrollbar) {
+      const int kThumbThickness = 3;
+      scrollbar_layer =
+          SolidColorScrollbarLayer::Create(scrollbar->Orientation(),
+                                           kThumbThickness,
+                                           layer_tree_root->id());
+    } else {
+      scrollbar_layer = PaintedScrollbarLayer::Create(scrollbar.Pass(),
+                                                      layer_tree_root->id());
+    }
     layer_tree_root->AddChild(content_layer);
     layer_tree_root->AddChild(scrollbar_layer);
 
     layer_tree_host_->InitializeOutputSurfaceIfNeeded();
     layer_tree_host_->SetRootLayer(layer_tree_root);
 
     scrollbar_layer->SetIsDrawable(true);
     scrollbar_layer->SetBounds(gfx::Size(100, 100));
     layer_tree_root->SetScrollOffset(gfx::Vector2d(10, 20));
     layer_tree_root->SetMaxScrollOffset(gfx::Vector2d(30, 50));
@@ skipping 25 matching lines @@
     scrollbar_layer->ClearRenderSurface();
   }
 
  protected:
   FakeLayerTreeHostClient fake_client_;
   LayerTreeSettings layer_tree_settings_;
   scoped_ptr<MockLayerTreeHost> layer_tree_host_;
 };
 
 TEST_F(ScrollbarLayerTestResourceCreation, ResourceUpload) {
-  layer_tree_settings_.solid_color_scrollbars = false;
-  TestResourceUpload(0, 0, 0, 0);
+  bool use_solid_color_scrollbars = false;
+  TestResourceUpload(0, 0, 0, 0, use_solid_color_scrollbars);
   int num_updates[3] = {1, 5, 10};
   for (int j = 0; j < 3; j++) {
-    TestResourceUpload(
-        num_updates[j], 2, num_updates[j] * 2, (num_updates[j] - 1) * 2);
+    TestResourceUpload(num_updates[j],
+                       2,
+                       num_updates[j] * 2,
+                       (num_updates[j] - 1) * 2,
+                       use_solid_color_scrollbars);
   }
 }
 
 TEST_F(ScrollbarLayerTestResourceCreation, SolidColorNoResourceUpload) {
-  layer_tree_settings_.solid_color_scrollbars = true;
-  TestResourceUpload(0, 0, 0, 0);
-  TestResourceUpload(1, 0, 0, 0);
+  bool use_solid_color_scrollbars = true;
+  TestResourceUpload(0, 0, 0, 0, use_solid_color_scrollbars);
+  TestResourceUpload(1, 0, 0, 0, use_solid_color_scrollbars);
 }
 
 class ScaledScrollbarLayerTestResourceCreation : public testing::Test {
  public:
   ScaledScrollbarLayerTestResourceCreation()
       : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
 
   void TestResourceUpload(const float test_scale) {
     layer_tree_host_.reset(
         new MockLayerTreeHost(&fake_client_, layer_tree_settings_));
@@ skipping 57 matching lines @@
     scrollbar_layer->ClearRenderSurface();
   }
 
  protected:
   FakeLayerTreeHostClient fake_client_;
   LayerTreeSettings layer_tree_settings_;
   scoped_ptr<MockLayerTreeHost> layer_tree_host_;
 };
 
 TEST_F(ScaledScrollbarLayerTestResourceCreation, ScaledResourceUpload) {
-  layer_tree_settings_.solid_color_scrollbars = false;
   // 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);
 }
 
 }  // namespace
 }  // namespace cc