Deduplicating compositing scrollingCoordinator helper

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 142 matching lines @@
 }
 
 static inline bool IsAcceleratedContents(LayoutObject& layout_object) {
   return IsCompositedCanvas(layout_object) ||
          (layout_object.IsEmbeddedObject() &&
           ToLayoutEmbeddedObject(layout_object)
               .RequiresAcceleratedCompositing()) ||
          layout_object.IsVideo();
 }
 
-// Get the scrolling coordinator in a way that works inside
-// CompositedLayerMapping's destructor.
-static ScrollingCoordinator* ScrollingCoordinatorFromLayer(PaintLayer& layer) {
-  Page* page = layer.GetLayoutObject().GetFrame()->GetPage();
-  return (!page) ? nullptr : page->GetScrollingCoordinator();
-}
-
 CompositedLayerMapping::CompositedLayerMapping(PaintLayer& layer)
     : owning_layer_(layer),
       content_offset_in_compositing_layer_dirty_(false),
       pending_update_scope_(kGraphicsLayerUpdateNone),
       is_main_frame_layout_view_layer_(false),
       background_layer_paints_fixed_root_background_(false),
       scrolling_contents_are_empty_(false),
       background_paints_onto_scrolling_contents_layer_(false),
       background_paints_onto_graphics_layer_(false),
       draws_background_onto_content_layer_(false) {
@@ skipping 1417 matching lines @@
     decoration_outline_layer_->SetNeedsDisplay();
   }
   decoration_outline_layer_->SetOffsetFromLayoutObject(
       graphics_layer_->OffsetFromLayoutObject());
 }
 
 void CompositedLayerMapping::RegisterScrollingLayers() {
   // Register fixed position layers and their containers with the scrolling
   // coordinator.
   ScrollingCoordinator* scrolling_coordinator =
-      ScrollingCoordinatorFromLayer(owning_layer_);
+      owning_layer_.GetScrollingCoordinator();
   if (!scrolling_coordinator)
     return;
 
   scrolling_coordinator->UpdateLayerPositionConstraint(&owning_layer_);
 
   // Page scale is applied as a transform on the root layout view layer. Because
   // the scroll layer is further up in the hierarchy, we need to avoid marking
   // the root layout view layer as a container.
   bool is_container =
       owning_layer_.GetLayoutObject().CanContainFixedPositionObjects() &&
@@ skipping 314 matching lines @@
     std::unique_ptr<GraphicsLayer>& layer,
     bool needs_layer,
     CompositingReasons reason) {
   if (needs_layer == !!layer)
     return false;
   layer = needs_layer ? CreateGraphicsLayer(reason) : nullptr;
 
   if (PaintLayerScrollableArea* scrollable_area =
           owning_layer_.GetScrollableArea()) {
     if (ScrollingCoordinator* scrolling_coordinator =
-            ScrollingCoordinatorFromLayer(owning_layer_)) {
+            owning_layer_.GetScrollingCoordinator()) {
       if (reason == kCompositingReasonLayerForHorizontalScrollbar)
         scrolling_coordinator->ScrollableAreaScrollbarLayerDidChange(
             scrollable_area, kHorizontalScrollbar);
       else if (reason == kCompositingReasonLayerForVerticalScrollbar)
         scrolling_coordinator->ScrollableAreaScrollbarLayerDidChange(
             scrollable_area, kVerticalScrollbar);
     }
   }
   return true;
 }
@@ skipping 415 matching lines @@
           kGraphicsLayerPaintChildClippingMask);
     }
     return;
   }
   child_clipping_mask_layer_ = nullptr;
 }
 
 bool CompositedLayerMapping::UpdateScrollingLayers(
     bool needs_scrolling_layers) {
   ScrollingCoordinator* scrolling_coordinator =
-      ScrollingCoordinatorFromLayer(owning_layer_);
+      owning_layer_.GetScrollingCoordinator();
 
   bool layer_changed = false;
   if (needs_scrolling_layers) {
     if (!scrolling_layer_) {
       // Outer layer which corresponds with the scroll view.
       scrolling_layer_ =
           CreateGraphicsLayer(kCompositingReasonLayerForScrollingContainer);
       scrolling_layer_->SetDrawsContent(false);
       scrolling_layer_->SetMasksToBounds(true);
 
@@ skipping 42 matching lines @@
   if (layer != topmost_layer)
     scroll_parent = 0;
 
   scrolling_coordinator->UpdateScrollParentForGraphicsLayer(layer,
                                                             scroll_parent);
 }
 
 void CompositedLayerMapping::UpdateScrollParent(
     const PaintLayer* scroll_parent) {
   if (ScrollingCoordinator* scrolling_coordinator =
-          ScrollingCoordinatorFromLayer(owning_layer_)) {
+          owning_layer_.GetScrollingCoordinator()) {
     GraphicsLayer* topmost_layer = ChildForSuperlayers();
     UpdateScrollParentForGraphicsLayer(squashing_containment_layer_.get(),
                                        topmost_layer, scroll_parent,
                                        scrolling_coordinator);
     UpdateScrollParentForGraphicsLayer(ancestor_clipping_layer_.get(),
                                        topmost_layer, scroll_parent,
                                        scrolling_coordinator);
     UpdateScrollParentForGraphicsLayer(graphics_layer_.get(), topmost_layer,
                                        scroll_parent, scrolling_coordinator);
   }
@@ skipping 22 matching lines @@
   OwningLayerClippedOrMaskedByLayerNotAboveCompositedAncestor(
       scroll_parent, have_ancestor_clip_layer, have_ancestor_mask_layer);
   if (!have_ancestor_clip_layer) {
     clip_parent = owning_layer_.ClipParent();
     if (clip_parent)
       clip_parent =
           clip_parent->EnclosingLayerWithCompositedLayerMapping(kIncludeSelf);
   }
 
   if (ScrollingCoordinator* scrolling_coordinator =
-          ScrollingCoordinatorFromLayer(owning_layer_)) {
+          owning_layer_.GetScrollingCoordinator()) {
     GraphicsLayer* topmost_layer = ChildForSuperlayers();
     UpdateClipParentForGraphicsLayer(squashing_containment_layer_.get(),
                                      topmost_layer, clip_parent,
                                      scrolling_coordinator);
     UpdateClipParentForGraphicsLayer(ancestor_clipping_layer_.get(),
                                      topmost_layer, clip_parent,
                                      scrolling_coordinator);
     UpdateClipParentForGraphicsLayer(graphics_layer_.get(), topmost_layer,
                                      clip_parent, scrolling_coordinator);
   }
@@ skipping 1113 matching lines @@
   } else if (graphics_layer == decoration_outline_layer_.get()) {
     name = "Decoration Layer";
   } else {
     NOTREACHED();
   }
 
   return name;
 }
 
 }  // namespace blink