Make RootScroller set the outer viewport scroll layer in the compositor

cc/trees/layer_tree_host.h

 // 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.
 
 #ifndef CC_TREES_LAYER_TREE_HOST_H_
 #define CC_TREES_LAYER_TREE_HOST_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 195 matching lines @@
 
   void SetAnimationEvents(std::unique_ptr<AnimationEvents> events);
 
   void SetRootLayer(scoped_refptr<Layer> root_layer);
   Layer* root_layer() { return root_layer_.get(); }
   const Layer* root_layer() const { return root_layer_.get(); }
   const Layer* overscroll_elasticity_layer() const {
     return overscroll_elasticity_layer_.get();
   }
   const Layer* page_scale_layer() const { return page_scale_layer_.get(); }
   void RegisterViewportLayers(scoped_refptr<Layer> overscroll_elasticity_layer,

[aelias_OOO_until_Jul13, 2016/06/29 22:44:08]

Can you make it an argument to this (and likewise down the commit flow)?  We
always end up regretting it later when related state isn't committed atomically.

[bokan, 2016/07/07 21:20:45]

Done. I moved registerViewportLayers in Blink out from VisualViewport and into
WebViewImpl since it's really more general than VisualViewport. I've split that
off into a separate patch.

                               scoped_refptr<Layer> page_scale_layer,
                               scoped_refptr<Layer> inner_viewport_scroll_layer,

[aelias_OOO_until_Jul13, 2016/06/29 22:44:08]

I'm having trouble understanding the intended breakdown of what's tied to the
root scroller and what to the inner viewport layer, could you lay it out?

[bokan, 2016/07/07 21:20:45]

The root scroller is really just designating which layer is the outer viewport.
In a future patch I'll add plumbing in cc::Viewport to swap the outer viewport
when the root scroller changes.

When a layer is designated as the root scroller, we shouldn't chain scrolls past
it and scrolling it should move top controls and activate overscroll glow. We
still want it to scroll as part of cc::Viewport and in tandem with the inner
viewport since we still want to scroll inner first when pinch zoomed in.

You can see the main thread version of this in
https://codereview.chromium.org/2128553002/ which is about to land.

[aelias_OOO_until_Jul13, 2016/07/07 22:03:15]

So, we have another layer right above it called the outer_viewport_scroll_layer.
 So I assume you mean this is the outer viewport container layer.  But we
already have a canonical reference to that:
outer_viewport_scroll_layer()->scroll_clip_layer_id().  Why is this one needed?

I'm not necessarily super committed to the existing way it's structured, but I
do think we shouldn't pass it in redundantly via two different APIs.

[bokan, 2016/07/07 22:49:53]

No, it's basically an indirection. If the page doesn't set a rootScroller
element, root_scroller_layer here would be outer_viewport_scroll_layer (and
that's what cc::Viewport will set as the outer viewport). But if the page does
set a rootScroller, root_scroller_layer will point to the scroll layer of some
other scroller (e.g. a <div>) in the hierarchy and now cc::Viewport will set
that as its "outer viewport". The outer viewport scroll/container layers remain
in the tree hierarchy though.

Perhaps cc::Viewport should use the visual/layout terminology to make this less
confusing. We're not replacing the outer viewport layers in the tree at all (we
could, conceptually, but I tried that and found doing layer surgery to be
difficult). What we're doing is specifying which scroll layer in the tree moves
top controls/overscroll. So maybe what I should have said above is that "root
scroller specifies which layer is the layout viewport" and layout viewport
doesn't necessarily have to be the outer viewport.

E.g.

When the page loads:

inner_container
  page_scale
    inner_scroll <---------------------
      outer_container                 |
        outer_scroll <----------- cc::Viewport uses these as
          root layer             "visual" and "layout" layers
            #div container            
              #div scroll 
            .... 

Now the page does document.rootScroller = $('#div'). The #div scrolling layer
becomes the "root scroller" but the outer viewport layers remain part of the
hierarchy

inner_container
  page_scale
    inner_scroll <--------------------+
      outer_container                 |
        outer_scroll       cc::Viewport uses these as
          root layer       "visual" and "layout" layers
            #div container            |
              #div scroll <-----------+
            .... 

Does that make sense?

                               scoped_refptr<Layer> outer_viewport_scroll_layer);
+
+  // Sets the layer whose scrolling will affect top controls and produce
+  // overscroll effects.
+  void SetRootScrollerLayer(scoped_refptr<Layer> root_scroller_layer);
+
   Layer* inner_viewport_scroll_layer() const {
     return inner_viewport_scroll_layer_.get();
   }
   Layer* outer_viewport_scroll_layer() const {
     return outer_viewport_scroll_layer_.get();
   }
 
   void RegisterSelection(const LayerSelection& selection);
 
   bool have_scroll_event_handlers() const {
@@ skipping 347 matching lines @@
   bool in_paint_layer_contents_;
 
   int id_;
   bool next_commit_forces_redraw_;
 
   scoped_refptr<Layer> overscroll_elasticity_layer_;
   scoped_refptr<Layer> page_scale_layer_;
   scoped_refptr<Layer> inner_viewport_scroll_layer_;
   scoped_refptr<Layer> outer_viewport_scroll_layer_;
 
+  scoped_refptr<Layer> root_scroller_layer_;
+
   LayerSelection selection_;
 
   SharedBitmapManager* shared_bitmap_manager_;
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
   TaskGraphRunner* task_graph_runner_;
 
   ImageSerializationProcessor* image_serialization_processor_;
   std::unique_ptr<EnginePictureCache> engine_picture_cache_;
   std::unique_ptr<ClientPictureCache> client_picture_cache_;
 
   std::vector<std::unique_ptr<SwapPromise>> swap_promise_list_;
   std::set<SwapPromiseMonitor*> swap_promise_monitor_;
 
   PropertyTrees property_trees_;
 
   using LayerIdMap = std::unordered_map<int, Layer*>;
   LayerIdMap layer_id_map_;
   // Set of layers that need to push properties.
   std::unordered_set<Layer*> layers_that_should_push_properties_;
 
   uint32_t surface_id_namespace_;
   uint32_t next_surface_sequence_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_H_