Fixed rounding issue on scrollbar rasterization.

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 11 matching lines @@
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/mock_quad_culler.h"
 #include "cc/test/test_web_graphics_context_3d.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"
 
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::MatcherInterface;
+using ::testing::Matcher;
+using ::testing::MakeMatcher;
+using ::testing::MatchResultListener;
+
 namespace cc {
 namespace {
 
 LayerImpl* LayerImplForScrollAreaAndScrollbar(
     FakeLayerTreeHost* host,
     scoped_ptr<Scrollbar> scrollbar,
     bool reverse_order,
     bool use_solid_color_scrollbar,
     int thumb_thickness) {
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
@@ skipping 717 matching lines @@
 };
 
 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 MockScrollbar : public FakeScrollbar {
+   public:
+    MockScrollbar(bool paint, bool has_thumb, bool is_overlay)
+    : FakeScrollbar(paint, has_thumb, is_overlay)
+    {}
+
+    MOCK_METHOD3(PaintPart, void(SkCanvas* canvas,
+                                 ScrollbarPart part,
+                                 const gfx::Rect& content_rect));
+  };
+
+  class IsCorrectTransformMatcher : public MatcherInterface<SkCanvas*> {
+   public:
+    IsCorrectTransformMatcher(int tx, int ty, float scale)
+    : tx_(tx),
+      ty_(ty),
+      scale_(scale)
+    {}
+    virtual bool MatchAndExplain(SkCanvas* arg,
+        MatchResultListener* listener) const {
+      const SkMatrix& mat = arg->getTotalMatrix();
+      if (!(mat.getType() ==
+          (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask))) {
+        *listener << "Wrong matrix type - expected Translate and Scale. Got "
+                  << mat.getType();
+        return false;
+      }
+
+      if (mat.getScaleX() != SkFloatToScalar(scale_) ||
+          mat.getScaleY() != SkFloatToScalar(scale_)) {
+        *listener << "Incorrect scale. Expected [" << scale_ << ", " << scale_
+                  << "] Actual [" << mat.getScaleX() << ", " << mat.getScaleY()
+                  << "].";
+        return false;
+      }
+
+      if (mat.getTranslateX() != SkIntToScalar(tx_) ||
+          mat.getTranslateY() != SkIntToScalar(ty_)) {
+        *listener << "Incorrect translation. Expected [" << tx_ << ", " << ty_
+                  << "] Actual [" << mat.getTranslateX() << ", "
+                  << mat.getTranslateY() << "].";
+        return false;
+      }
+
+      return true;
+    }
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "SkCanvas has correct transform.";
+    }
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "SkCanvas has incorrect transform.";
+    }
+
+   private:
+    int tx_;
+    int ty_;
+    float scale_;
+  };
+
+  Matcher<SkCanvas*> IsCorrectTransform(int tx, int ty, float scale) {
+    return MakeMatcher(new IsCorrectTransformMatcher(tx, ty, scale));
+  }
+
+ public:
+  ScaledScrollbarLayerTestScaledRasterization()
+      : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
+
+  void TestScale(const gfx::Rect scrollbar_rect, const float test_scale) {
+    layer_tree_host_.reset(
+        new MockLayerTreeHost(&fake_client_, layer_tree_settings_));
+
+    MockScrollbar* mock_scrollbar = new MockScrollbar(false, false, false);
+    scoped_refptr<Layer> layer_tree_root = Layer::Create();
+    scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
+        FakePaintedScrollbarLayer::Create(false, false, layer_tree_root->id(),
+                                          mock_scrollbar);
+
+    layer_tree_root->AddChild(scrollbar_layer);
+
+    layer_tree_host_->SetRootLayer(layer_tree_root);
+
+    scrollbar_layer->SetBounds(scrollbar_rect.size());
+    scrollbar_layer->SetPosition(scrollbar_rect.origin());
+    scrollbar_layer->fake_scrollbar()->set_location(scrollbar_rect.origin());
+    gfx::SizeF scaled_size =
+        gfx::ScaleSize(scrollbar_layer->bounds(), test_scale, test_scale);
+    gfx::PointF scaled_location =
+        gfx::ScalePoint(scrollbar_layer->position(), test_scale, test_scale);
+    scrollbar_layer->draw_properties().content_bounds =
+        gfx::Size(scaled_size.width(), scaled_size.height());
+    scrollbar_layer->draw_properties().contents_scale_x = test_scale;
+    scrollbar_layer->draw_properties().contents_scale_y = test_scale;
+    scrollbar_layer->draw_properties().visible_content_rect =
+        gfx::Rect(scaled_location.x(),
+                  scaled_location.y(),
+                  scaled_size.width(),
+                  scaled_size.height());
+
+    ResourceUpdateQueue queue;
+    OcclusionTracker occlusion_tracker(gfx::Rect(), false);
+    scrollbar_layer->SavePaintProperties();
+
+    // Since Skia will round scaled coordinates, the canvas should be translated
+    // back to origin by the rounded amount.
+    int xTranslate = round(scrollbar_rect.x() * test_scale);
+    int yTranslate = round(scrollbar_rect.y() * test_scale);
+
+    EXPECT_CALL(
+        *mock_scrollbar,
+        PaintPart(IsCorrectTransform(-xTranslate, -yTranslate, test_scale),
+        TRACK,
+        scrollbar_rect));
+
+    scrollbar_layer->Update(&queue, &occlusion_tracker);
+    scrollbar_layer->ClearRenderSurface();
+  }
+
+ protected:
+  FakeLayerTreeHostClient fake_client_;
+  LayerTreeSettings layer_tree_settings_;
+  scoped_ptr<MockLayerTreeHost> layer_tree_host_;
+};
+
+TEST_F(ScaledScrollbarLayerTestScaledRasterization, TestLostPrecisionInClip) {
+  // Try rasterization at a scale that caused problematic floating point
+  // clamping causing a black line on scrollbar edges. Sweep across a range
+  // of coordinates to uproot numeric errors.
+  for (int i = 0; i < 10; ++i) {
+    // Vertical scrollbar.
+    TestScale(gfx::Rect(1120 - i, 0, 15, 677), 7.301320f);
+
+    // Horizontal scrollbar.
+    TestScale(gfx::Rect(0, 1120 - i, 677, 15), 7.301320f);
+  }
+}
+
 }  // namespace
 }  // namespace cc