Find root scroll layer at tree activation

cc/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/layer_tree_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
 #include "ui/gfx/vector2d_conversions.h"
@@ skipping 51 matching lines @@
         scrolling_layer_id_from_previous_tree_);
   }
 
   scrolling_layer_id_from_previous_tree_ = 0;
 }
 
 scoped_ptr<LayerImpl> LayerTreeImpl::DetachLayerTree() {
   // Clear all data structures that have direct references to the layer tree.
   scrolling_layer_id_from_previous_tree_ =
     currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0;
+  root_scroll_layer_ = NULL;
   currently_scrolling_layer_ = NULL;
 
   render_surface_layer_list_.clear();
   SetNeedsUpdateDrawProperties();
   return root_layer_.Pass();
 }
 
+LayerImpl* LayerTreeImpl::RootScrollLayer() {
+  DCHECK(IsActiveTree());
+  return root_scroll_layer_;
+}
+
+LayerImpl* LayerTreeImpl::CurrentlyScrollingLayer() {
+  DCHECK(IsActiveTree());
+  return currently_scrolling_layer_;
+}
+
 void LayerTreeImpl::ClearCurrentlyScrollingLayer() {
   currently_scrolling_layer_ = NULL;
   scrolling_layer_id_from_previous_tree_ = 0;
 }
 
 void LayerTreeImpl::UpdateMaxScrollOffset() {
-  if (!root_scroll_layer() || !root_scroll_layer()->children().size())
+  if (!root_scroll_layer_ || !root_scroll_layer_->children().size())
     return;
 
   gfx::SizeF view_bounds = device_viewport_size();
-  if (LayerImpl* clip_layer = root_scroll_layer()->parent()) {
+  if (LayerImpl* clip_layer = root_scroll_layer_->parent()) {
     // Compensate for non-overlay scrollbars.
     if (clip_layer->masksToBounds())
       view_bounds = gfx::ScaleSize(clip_layer->bounds(), device_scale_factor());
   }
 
   gfx::Size content_bounds = ContentSize();
   if (settings().pageScalePinchZoomEnabled) {
     // Pinch with pageScale scrolls entirely in layout space.  ContentSize
     // returns the bounds including the page scale factor, so calculate the
     // pre page-scale layout size here.
     float page_scale_factor = pinch_zoom_viewport().page_scale_factor();
     content_bounds.set_width(content_bounds.width() / page_scale_factor);
     content_bounds.set_height(content_bounds.height() / page_scale_factor);
   } else {
     view_bounds.Scale(1 / pinch_zoom_viewport().page_scale_delta());
   }
 
   gfx::Vector2dF max_scroll = gfx::Rect(content_bounds).bottom_right() -
       gfx::RectF(view_bounds).bottom_right();
   max_scroll.Scale(1 / device_scale_factor());
 
   // The viewport may be larger than the contents in some cases, such as
   // having a vertical scrollbar but no horizontal overflow.
   max_scroll.ClampToMin(gfx::Vector2dF());
 
-  root_scroll_layer()->setMaxScrollOffset(gfx::ToFlooredVector2d(max_scroll));
+  root_scroll_layer_->setMaxScrollOffset(gfx::ToFlooredVector2d(max_scroll));
 }
 
 void LayerTreeImpl::UpdateDrawProperties() {
   render_surface_layer_list_.clear();
   if (!RootLayer())
     return;
 
-  if (root_scroll_layer()) {
-    root_scroll_layer()->setImplTransform(
+  if (root_scroll_layer_) {
+    root_scroll_layer_->setImplTransform(
         layer_tree_host_impl_->implTransform());
   }
 
   {
     TRACE_EVENT0("cc", "LayerTreeImpl::UpdateDrawProperties");
     LayerTreeHostCommon::calculateDrawProperties(
         RootLayer(),
         device_viewport_size(),
         device_scale_factor(),
         pinch_zoom_viewport().page_scale_factor(),
@@ skipping 34 matching lines @@
   return true;
 }
 
 const LayerTreeImpl::LayerList& LayerTreeImpl::RenderSurfaceLayerList() const {
   // If this assert triggers, then the list is dirty.
   DCHECK(!layer_tree_host_impl_->needsUpdateDrawProperties());
   return render_surface_layer_list_;
 }
 
 gfx::Size LayerTreeImpl::ContentSize() const {
-  // TODO(aelias): Hardcoding the first child here is weird. Think of
-  // a cleaner way to get the contentBounds on the Impl side.
-  if (!root_scroll_layer() || root_scroll_layer()->children().empty())
+  if (!root_scroll_layer_)
     return gfx::Size();
-  return root_scroll_layer()->children()[0]->contentBounds();
+  return root_scroll_layer_->bounds();
 }
 
 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 12 matching lines @@
 
 static void DidBecomeActiveRecursive(LayerImpl* layer) {
   layer->didBecomeActive();
   for (size_t i = 0; i < layer->children().size(); ++i)
     DidBecomeActiveRecursive(layer->children()[i]);
 }
 
 void LayerTreeImpl::DidBecomeActive() {
   if (RootLayer())
     DidBecomeActiveRecursive(RootLayer());
+  FindRootScrollLayer();
+  UpdateMaxScrollOffset();
 }
 
 const LayerTreeSettings& LayerTreeImpl::settings() const {
   return layer_tree_host_impl_->settings();
 }
 
 OutputSurface* LayerTreeImpl::output_surface() const {
   return layer_tree_host_impl_->outputSurface();
 }
 
@@ skipping 73 matching lines @@
 
 AnimationRegistrar* LayerTreeImpl::animationRegistrar() const {
   return layer_tree_host_impl_->animationRegistrar();
 }
 
 const PinchZoomViewport& LayerTreeImpl::pinch_zoom_viewport() const {
   return layer_tree_host_impl_->pinchZoomViewport();
 }
 
 } // namespace cc