Ignore rounding error between clip_layer_length_ and scroll_layer_length_

cc/layers/scrollbar_layer_impl_base.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/scrollbar_layer_impl_base.h"
 
 #include <algorithm>
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/geometry/rect_conversions.h"
@@ skipping 52 matching lines @@
     return false;
   current_pos_ = current_pos;
   NoteLayerPropertyChanged();
   return true;
 }
 
 bool ScrollbarLayerImplBase::CanScrollOrientation() const {
   LayerImpl* scroll_layer = layer_tree_impl()->LayerById(scroll_layer_id_);
   if (!scroll_layer)
     return false;
+
+  float device_scale_factor = layer_tree_impl()->device_scale_factor();
+
+  int clip_layer_length = std::ceil(clip_layer_length_ * device_scale_factor);

[bokan, 2017/04/20 21:34:36]

Sorry to flip flop again, but I think you were right before - sorry! We should
multiply here by page_scale_factor. This gets us to physical pixels in all
cases.

For the viewport, the clip layer will have been divided by PSF in
UpdateScrollbars so we'll undo that here and multiply by DSF to get the real
viewport size in device pixels. Multiplying the scroll layer below by PSF and
DSF makes it so that we're "keeping the viewport fixed in size while scaling
scroll layer" for zooming.

And for non viewport layers, we also want to multiply by PSF because as we zoom
in, we can scroll those layers in smaller and smaller increments so a scroller
that wasn't scrollable at a small zoom might become scrollable at higher zooms.
e.g. At PSF=1 DSF=2 with scroll_length=100.3 and clip_length=100 - since DSF=2,
there's 2 DP per 1 DIP so there's no scrolling possible while PSF is 1. If we
zoom in to PSF=2, the scroll_length=401.2 and the clip_length=400 in DP. So now
we have 1 device pixel of scrolling.

As the example demonstrates though, ceil is the wrong thing to do for
scroll_layer_length. I think we should ceil for clip and floor for scroll. My
floating point knowledge is rusty but I think the introduced error from
multiplying two ints can in general go in different directions (scroll might be
slightly over an integer and clip might be slightly under). I don't think it'll
matter in practice but flooring clip means we'll err to not scrolling which I
think is right thing to do.

Does that make sense? If so, lets bring back PSF, floor clip, and I'll stamp.
(And to make this clearer, call the variables "clip_device_pixels" and
"scroll_device_pixels".)

+  int scroll_layer_length =
+      std::ceil(scroll_layer_length_ * device_scale_factor);
+
   return scroll_layer->user_scrollable(orientation()) &&
-         clip_layer_length_ < scroll_layer_length_;
+         clip_layer_length < scroll_layer_length;
 }
 
 bool ScrollbarLayerImplBase::SetVerticalAdjust(float vertical_adjust) {
   if (vertical_adjust_ == vertical_adjust)
     return false;
   vertical_adjust_ = vertical_adjust;
   NoteLayerPropertyChanged();
   return true;
 }
 
@@ skipping 145 matching lines @@
   layer_tree_impl()->AddToOpacityAnimationsMap(id(), opacity);
 
   node->opacity = opacity;
   node->effect_changed = true;
   property_trees->changed = true;
   property_trees->effect_tree.set_needs_update(true);
   layer_tree_impl()->set_needs_update_draw_properties();
 }
 
 }  // namespace cc