Make scrollable viewport size no longer depend on clip layer.

cc/trees/layer_tree_impl.cc

 // Copyright 2011 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/trees/layer_tree_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/debug/traced_value.h"
@@ skipping 118 matching lines @@
 
   if (hud_layer())
     target_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(
         LayerTreeHostCommon::FindLayerInSubtree(
             target_tree->root_layer(), hud_layer()->id())));
   else
     target_tree->set_hud_layer(NULL);
 }
 
 LayerImpl* LayerTreeImpl::RootScrollLayer() const {
-  DCHECK(IsActiveTree());
   return root_scroll_layer_;
 }
 
 LayerImpl* LayerTreeImpl::RootClipLayer() const {
   return root_scroll_layer_ ? root_scroll_layer_->parent() : NULL;
 }
 
 LayerImpl* LayerTreeImpl::CurrentlyScrollingLayer() const {
   DCHECK(IsActiveTree());
   return currently_scrolling_layer_;
@@ skipping 149 matching lines @@
       "CalcDrawProperties should not set_needs_update_draw_properties()";
 }
 
 const LayerImplList& LayerTreeImpl::RenderSurfaceLayerList() const {
   // If this assert triggers, then the list is dirty.
   DCHECK(!needs_update_draw_properties_);
   return render_surface_layer_list_;
 }
 
 gfx::Size LayerTreeImpl::ScrollableSize() const {
-  if (!root_scroll_layer_ || root_scroll_layer_->children().empty())
+  LayerImpl* root_scroll = RootScrollLayer();
+  if (!root_scroll || root_scroll->children().empty())
     return gfx::Size();
-  return root_scroll_layer_->children()[0]->bounds();
+  gfx::Size content_size = root_scroll->children()[0]->bounds();
+
+  // For the purposes of scrolling, non-overlay scrollbars are considered to

[enne (OOO), 2013/07/12 17:19:27]

This code looks a bit suspicious to me and I need some more convincing.

Why would the scrollable size change because of scrollbars? If you have both
horizontal and vertical overflow (and thus have both scrollbars), I wouldn't
expect the scrollable size to shrink because there was a clip layer with
scrollbars above it.

[aelias_OOO_until_Jul13, 2013/07/12 18:18:23]

Note that this code is adding to the scrollable size, not shrinking it.

There are two ways of considering the effect of non-overlay scrollbars.  They
can shrink the viewport or expand the scrollable size.  Those interpretations
are equivalent until pinch zoom comes into play.  Recall that wjmaclean's
desired UX is to make the non-overlay scrollbars scale up and to become visible
if you scroll the inner viewport to the right/bottom, but be invisible
otherwise.  This matches "expand the scrollable size" semantics.

[enne (OOO), 2013/07/12 18:30:27]

I don't think the scroll layer size is at all related to the scrollbars, growing
or shrinking.
I do not agree that expanding the scrollable size is equivalent.  I think this
would be better placed in UpdateMaxScrollOffset rather than changing the
scrollable size.

+  // occupy a placeholder area on the right and bottom of the document, instead
+  // of shrinking the viewport size.
+  ScrollbarLayerImpl* horiz = root_scroll->horizontal_scrollbar_layer();
+  ScrollbarLayerImpl* vertical = root_scroll->vertical_scrollbar_layer();
+  if (horiz && !horiz->is_overlay_scrollbar())
+    content_size.set_height(content_size.height() + horiz->thumb_thickness());
+  if (vertical && !vertical->is_overlay_scrollbar())
+    content_size.set_width(content_size.width() + vertical->thumb_thickness());
+
+  return content_size;
 }
 
 LayerImpl* LayerTreeImpl::LayerById(int id) {
   LayerIdMap::iterator iter = layer_id_map_.find(id);
   return iter != layer_id_map_.end() ? iter->second : NULL;
 }
 
 void LayerTreeImpl::RegisterLayer(LayerImpl* layer) {
   DCHECK(!LayerById(layer->id()));
   layer_id_map_[layer->id()] = layer;
@@ skipping 264 matching lines @@
 const std::vector<LayerImpl*> LayerTreeImpl::LayersWithCopyOutputRequest()
     const {
   // Only the active tree needs to know about layers with copy requests, as
   // they are aborted if not serviced during draw.
   DCHECK(IsActiveTree());
 
   return layers_with_copy_output_request_;
 }
 
 }  // namespace cc