Fixed rounding issue on scrollbar rasterization.

cc/layers/painted_scrollbar_layer.cc

 // Copyright 2013 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/painted_scrollbar_layer.h"
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
@@ skipping 151 matching lines @@
     thumb_resource_.reset();
   }
 
   ContentsScalingLayer::SetLayerTreeHost(host);
 }
 
 gfx::Rect PaintedScrollbarLayer::ScrollbarLayerRectToContentRect(
     const gfx::Rect& layer_rect) const {
   // Don't intersect with the bounds as in LayerRectToContentRect() because
   // layer_rect here might be in coordinates of the containing layer.
-  gfx::Rect expanded_rect = gfx::ScaleToEnclosingRect(
+  gfx::Rect expanded_rect = gfx::ScaleToEnclosedRect(

[danakj, 2014/02/10 19:17:28]

I don't believe this is correct.

Say you have a scale of 1.5 and a width of 11. Then your content bounds width
will be 17.

If you take the enclosed here, you'll get only 16, so your width won't fill the
entire content_bounds().

This is why we clamp to the content_bounds() after doing Enclosing on line 176.

       layer_rect, contents_scale_y(), contents_scale_y());
   // We should never return a rect bigger than the content_bounds().
   gfx::Size clamped_size = expanded_rect.size();
   clamped_size.SetToMin(content_bounds());
   expanded_rect.set_size(clamped_size);
   return expanded_rect;
 }
 
 gfx::Rect PaintedScrollbarLayer::OriginThumbRect() const {
   gfx::Size thumb_size;
@@ skipping 58 matching lines @@
 
   SkBitmap skbitmap;
   skbitmap.setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height());
   skbitmap.allocPixels();
 
   SkCanvas skcanvas(skbitmap);
   skcanvas.translate(SkFloatToScalar(-rect.x()), SkFloatToScalar(-rect.y()));
   skcanvas.scale(SkFloatToScalar(contents_scale_x()),
                  SkFloatToScalar(contents_scale_y()));
 
+  // Since rect is an enclosed rect around the scaled layer_rect, we must take
+  // the enclosing rect when unscaling so we don't lose a pixel in truncation.
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(

[danakj, 2014/02/10 19:17:28]

It seems like this one is the one we should switch to enclosed? Or maybe you can
explain what I'm missing there?

Maybe we need to scale the skcanvas to the |rect| instead of using the
contents_scale_x/y directly?

[danakj, 2014/02/10 19:19:37]

A possible nice change would be to pass in the layer rect instead of having to
do this math here again, since the caller already had the layer rect.

[bokan, 2014/02/11 00:01:53]

If the one above is enclosed then it can be clipped which means that layer_rect
* contents_scale_x != rect which is assumed here. I've changed to pass in the
layer rect as you suggested. 

       rect, 1.f / contents_scale_x(), 1.f / contents_scale_y());
   SkRect layer_skrect = RectToSkRect(layer_rect);
   SkPaint paint;
   paint.setAntiAlias(false);
   paint.setXfermodeMode(SkXfermode::kClear_Mode);
   skcanvas.drawRect(layer_skrect, paint);
   skcanvas.clipRect(layer_skrect);
 
   scrollbar_->PaintPart(&skcanvas, part, layer_rect);
   // Make sure that the pixels are no longer mutable to unavoid unnecessary
   // allocation and copying.
   skbitmap.setImmutable();
 
   return UIResourceBitmap(skbitmap);
 }
 
 }  // namespace cc