Null-check Compositor() in PaintLayer

third_party/WebKit/Source/core/paint/PaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 206 matching lines @@
     return 0;
   return GetLayoutObject().View()->Compositor();
 }
 
 void PaintLayer::ContentChanged(ContentChangeType change_type) {
   // updateLayerCompositingState will query compositingReasons for accelerated
   // overflow scrolling.  This is tripped by
   // LayoutTests/compositing/content-changed-chicken-egg.html
   DisableCompositingQueryAsserts disabler;
 
-  if (change_type == kCanvasChanged)
-    Compositor()->SetNeedsCompositingUpdate(
-        kCompositingUpdateAfterCompositingInputChange);
+  if (Compositor()) {
+    if (change_type == kCanvasChanged) {
+      Compositor()->SetNeedsCompositingUpdate(
+          kCompositingUpdateAfterCompositingInputChange);
+    }
 
-  if (change_type == kCanvasContextChanged) {
-    Compositor()->SetNeedsCompositingUpdate(
-        kCompositingUpdateAfterCompositingInputChange);
+    if (change_type == kCanvasContextChanged) {
+      Compositor()->SetNeedsCompositingUpdate(
+          kCompositingUpdateAfterCompositingInputChange);
+    }
+  }
 
-    // Although we're missing test coverage, we need to call
-    // GraphicsLayer::setContentsToPlatformLayer with the new platform
-    // layer for this canvas.
-    // See http://crbug.com/349195
-    if (HasCompositedLayerMapping())
-      GetCompositedLayerMapping()->SetNeedsGraphicsLayerUpdate(
-          kGraphicsLayerUpdateSubtree);
+  // Although we're missing test coverage, we need to call
+  // GraphicsLayer::setContentsToPlatformLayer with the new platform
+  // layer for this canvas.
+  // See http://crbug.com/349195
+  if (HasCompositedLayerMapping()) {

[wkorman, 2017/04/26 01:04:36]

It looks like we used to only do this if change_type == kCanvasContextChanged.
Is it ok to move it out and do it regardless of what change_type is?

[chrishtr, 2017/04/26 01:09:38]

Oh, that was not intended. Fixed.

+    GetCompositedLayerMapping()->SetNeedsGraphicsLayerUpdate(
+        kGraphicsLayerUpdateSubtree);
   }
 
   if (CompositedLayerMapping* composited_layer_mapping =
           this->GetCompositedLayerMapping())
     composited_layer_mapping->ContentChanged(change_type);
 }
 
 bool PaintLayer::PaintsWithFilters() const {
   if (!GetLayoutObject().HasFilterInducingProperty())
     return false;
@@ skipping 126 matching lines @@
 
 void PaintLayer::UpdateTransformationMatrix() {
   if (TransformationMatrix* transform = this->Transform()) {
     LayoutBox* box = GetLayoutBox();
     DCHECK(box);
     transform->MakeIdentity();
     box->Style()->ApplyTransform(
         *transform, box->Size(), ComputedStyle::kIncludeTransformOrigin,
         ComputedStyle::kIncludeMotionPath,
         ComputedStyle::kIncludeIndependentTransformProperties);
-    MakeMatrixRenderable(*transform, Compositor()->HasAcceleratedCompositing());
+    MakeMatrixRenderable(
+        *transform,
+        Compositor() ? Compositor()->HasAcceleratedCompositing() : false);
   }
 }
 
 void PaintLayer::UpdateTransform(const ComputedStyle* old_style,
                                  const ComputedStyle& new_style) {
   // It's possible for the old and new style transform data to be equivalent
   // while hasTransform() differs, as it checks a number of conditions aside
   // from just the matrix, including but not limited to animation state.
   if (old_style && old_style->HasTransform() == new_style.HasTransform() &&
       new_style.TransformDataEquivalent(*old_style)) {
@@ skipping 625 matching lines @@
 }
 
 void PaintLayer::SetNeedsCompositingInputsUpdateInternal() {
   needs_ancestor_dependent_compositing_inputs_update_ = true;
 
   for (PaintLayer* current = this;
        current && !current->child_needs_compositing_inputs_update_;
        current = current->Parent())
     current->child_needs_compositing_inputs_update_ = true;
 
-  Compositor()->SetNeedsCompositingUpdate(
-      kCompositingUpdateAfterCompositingInputChange);
+  if (Compositor()) {
+    Compositor()->SetNeedsCompositingUpdate(
+        kCompositingUpdateAfterCompositingInputChange);
+  }
 }
 
 void PaintLayer::UpdateAncestorDependentCompositingInputs(
     const AncestorDependentCompositingInputs& compositing_inputs,
     bool has_ancestor_with_clip_path) {
   ancestor_dependent_compositing_inputs_ =
       WTF::MakeUnique<AncestorDependentCompositingInputs>(compositing_inputs);
   has_ancestor_with_clip_path_ = has_ancestor_with_clip_path;
   needs_ancestor_dependent_compositing_inputs_update_ = false;
 }
@@ skipping 206 matching lines @@
   }
 
   child->parent_ = this;
 
   // The ancestor overflow layer is calculated during compositing inputs update
   // and should not be set yet.
   CHECK(!child->AncestorOverflowLayer());
 
   SetNeedsCompositingInputsUpdate();
 
-  if (!child->StackingNode()->IsStacked() &&
-      !GetLayoutObject().DocumentBeingDestroyed())
-    Compositor()->SetNeedsCompositingUpdate(kCompositingUpdateRebuildTree);
+  if (Compositor()) {
+    if (!child->StackingNode()->IsStacked() &&
+        !GetLayoutObject().DocumentBeingDestroyed())
+      Compositor()->SetNeedsCompositingUpdate(kCompositingUpdateRebuildTree);
+  }
 
   if (child->StackingNode()->IsStacked() || child->FirstChild()) {
     // Dirty the z-order list in which we are contained. The
     // ancestorStackingContextNode() can be null in the case where we're
     // building up generated content layers. This is ok, since the lists will
     // start off dirty in that case anyway.
     child->StackingNode()->DirtyStackingContextZOrderLists();
   }
 
   // Non-self-painting children paint into this layer, so the visible contents
@@ skipping 11 matching lines @@
   if (old_child->PreviousSibling())
     old_child->PreviousSibling()->SetNextSibling(old_child->NextSibling());
   if (old_child->NextSibling())
     old_child->NextSibling()->SetPreviousSibling(old_child->PreviousSibling());
 
   if (first_ == old_child)
     first_ = old_child->NextSibling();
   if (last_ == old_child)
     last_ = old_child->PreviousSibling();
 
-  if (!old_child->StackingNode()->IsStacked() &&
-      !GetLayoutObject().DocumentBeingDestroyed())
-    Compositor()->SetNeedsCompositingUpdate(kCompositingUpdateRebuildTree);
+  if (Compositor()) {
+    if (!old_child->StackingNode()->IsStacked() &&
+        !GetLayoutObject().DocumentBeingDestroyed())
+      Compositor()->SetNeedsCompositingUpdate(kCompositingUpdateRebuildTree);
+  }
 
   if (old_child->StackingNode()->IsStacked() || old_child->FirstChild()) {
     // Dirty the z-order list in which we are contained.  When called via the
     // reattachment process in removeOnlyThisLayer, the layer may already be
     // disconnected from the main layer tree, so we need to null-check the
     // |stackingContext| value.
     old_child->StackingNode()->DirtyStackingContextZOrderLists();
   }
 
   if (GetLayoutObject().Style()->Visibility() != EVisibility::kVisible)
@@ skipping 1644 matching lines @@
     ToReferenceClipPathOperation(old_clip_operation)
         ->RemoveClient(ResourceInfo());
   }
 }
 
 bool PaintLayer::AttemptDirectCompositingUpdate(
     StyleDifference diff,
     const ComputedStyle* old_style) {
   CompositingReasons old_potential_compositing_reasons_from_style =
       PotentialCompositingReasonsFromStyle();
-  Compositor()->UpdatePotentialCompositingReasonsFromStyle(this);
+  if (Compositor())
+    Compositor()->UpdatePotentialCompositingReasonsFromStyle(this);
 
   // This function implements an optimization for transforms and opacity.
   // A common pattern is for a touchmove handler to update the transform
   // and/or an opacity of an element every frame while the user moves their
   // finger across the screen. The conditions below recognize when the
   // compositing state is set up to receive a direct transform or opacity
   // update.
 
   if (!diff.HasAtMostPropertySpecificDifferences(
           StyleDifference::kTransformChanged |
@@ skipping 33 matching lines @@
     return false;
 
   UpdateTransform(old_style, GetLayoutObject().StyleRef());
 
   // FIXME: Consider introducing a smaller graphics layer update scope
   // that just handles transforms and opacity. GraphicsLayerUpdateLocal
   // will also program bounds, clips, and many other properties that could
   // not possibly have changed.
   rare_data_->composited_layer_mapping->SetNeedsGraphicsLayerUpdate(
       kGraphicsLayerUpdateLocal);
-  Compositor()->SetNeedsCompositingUpdate(
-      kCompositingUpdateAfterGeometryChange);
+  if (Compositor()) {
+    Compositor()->SetNeedsCompositingUpdate(
+        kCompositingUpdateAfterGeometryChange);
+  }
 
   if (scrollable_area_)
     scrollable_area_->UpdateAfterStyleChange(old_style);
 
   return true;
 }
 
 void PaintLayer::StyleDidChange(StyleDifference diff,
                                 const ComputedStyle* old_style) {
   if (AttemptDirectCompositingUpdate(diff, old_style))
@@ skipping 272 matching lines @@
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
   showLayerTree(layoutObject->EnclosingLayer());
 }
 #endif