Fix crash about mask layers

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 184 matching lines @@
             oldSquashedLayer->setLostGroupedMapping(true);
         }
     }
 
     updateClippingLayers(false, false);
     updateOverflowControlsLayers(false, false, false, false);
     updateChildTransformLayer(false);
     updateForegroundLayer(false);
     updateBackgroundLayer(false);
     updateMaskLayer(false);
-    updateClippingMaskLayers(false);
+    updateChildClippingMaskLayer(false);
     updateScrollingLayers(false);
     updateSquashingLayers(false);
     destroyGraphicsLayers();
 }
 
 PassOwnPtr<GraphicsLayer> CompositedLayerMapping::createGraphicsLayer(CompositingReasons reasons)
 {
     GraphicsLayerFactory* graphicsLayerFactory = nullptr;
     if (Page* page = layoutObject()->frame()->page())
         graphicsLayerFactory = page->chromeClient().graphicsLayerFactory();
@@ skipping 245 matching lines @@
 
     if (scrollingConfigChanged) {
         if (layoutObject->view())
             compositor->scrollingLayerDidChange(&m_owningLayer);
     }
 
     // A mask layer is not part of the hierarchy proper, it's an auxiliary layer
     // that's plugged into another GraphicsLayer that is part of the hierarchy.
     // It has no parent or child GraphicsLayer. For that reason, we process it
     // here, after the hierarchy has been updated.
-    bool maskLayerChanged = false;
-    if (updateMaskLayer(layoutObject->hasMask())) {
-        maskLayerChanged = true;
+    bool maskLayerChanged = updateMaskLayer(layoutObject->hasMask());
+    if (maskLayerChanged)
         m_graphicsLayer->setMaskLayer(m_maskLayer.get());
-    }
 
     bool hasChildClippingLayer = compositor->clipsCompositingDescendants(&m_owningLayer) && (hasClippingLayer() || hasScrollingLayer());
     // If we have a border radius or clip path on a scrolling layer, we need a clipping mask to properly
     // clip the scrolled contents, even if there are no composited descendants.
     bool hasClipPath = layoutObject->style()->clipPath();
     bool needsChildClippingMask = (hasClipPath || layoutObject->style()->hasBorderRadius()) && (hasChildClippingLayer || isAcceleratedContents(layoutObject) || hasScrollingLayer());
-    if (updateClippingMaskLayers(needsChildClippingMask)) {
-        // Clip path clips the entire subtree, including scrollbars. It must be attached directly onto
-        // the main m_graphicsLayer.
-        if (hasClipPath)
+
+    GraphicsLayer* layerToApplyChildClippingMask = nullptr;
+    bool shouldApplyChildClippingMaskOnContents = false;
+    if (needsChildClippingMask) {
+        if (hasClipPath) {

[chrishtr, 2015/11/09 22:24:51]

Is this and the below just refactoring? Or what is the change?

+            // Clip path clips the entire subtree, including scrollbars. It must be attached directly onto
+            // the main m_graphicsLayer.
+            layerToApplyChildClippingMask = m_graphicsLayer.get();
+        } else if (hasClippingLayer()) {
+            layerToApplyChildClippingMask = clippingLayer();
+        } else if (hasScrollingLayer()) {
+            layerToApplyChildClippingMask = scrollingLayer();
+        } else if (isAcceleratedContents(layoutObject)) {
+            shouldApplyChildClippingMaskOnContents = true;
+        }
+    }
+
+    updateChildClippingMaskLayer(needsChildClippingMask);
+
+    if (layerToApplyChildClippingMask == m_graphicsLayer) {
+        if (m_graphicsLayer->maskLayer() != m_childClippingMaskLayer.get()) {
             m_graphicsLayer->setMaskLayer(m_childClippingMaskLayer.get());
-        else if (hasClippingLayer())
-            clippingLayer()->setMaskLayer(m_childClippingMaskLayer.get());
-        else if (hasScrollingLayer())
-            scrollingLayer()->setMaskLayer(m_childClippingMaskLayer.get());
-        else if (isAcceleratedContents(layoutObject))
-            m_graphicsLayer->setContentsClippingMaskLayer(m_childClippingMaskLayer.get());
+            maskLayerChanged = true;
+        }
+    } else if (m_graphicsLayer->maskLayer() && m_graphicsLayer->maskLayer() != m_maskLayer.get()) {
+        m_graphicsLayer->setMaskLayer(nullptr);
+        maskLayerChanged = true;
     }
+    if (hasClippingLayer())
+        clippingLayer()->setMaskLayer(layerToApplyChildClippingMask == clippingLayer() ? m_childClippingMaskLayer.get() : nullptr);
+    if (hasScrollingLayer())
+        scrollingLayer()->setMaskLayer(layerToApplyChildClippingMask == clippingLayer() ? m_childClippingMaskLayer.get() : nullptr);

[Xianzhu, 2015/11/09 22:47:24]

The above line is wrong. Fixing.

[Xianzhu, 2015/11/09 22:51:56]

Done.

+    m_graphicsLayer->setContentsClippingMaskLayer(shouldApplyChildClippingMaskOnContents ? m_childClippingMaskLayer.get() : nullptr);
 
     if (m_owningLayer.reflectionInfo()) {
         if (m_owningLayer.reflectionInfo()->reflectionLayer()->hasCompositedLayerMapping()) {
             GraphicsLayer* reflectionLayer = m_owningLayer.reflectionInfo()->reflectionLayer()->compositedLayerMapping()->mainGraphicsLayer();
             m_graphicsLayer->setReplicatedByLayer(reflectionLayer);
         }
     } else {
         m_graphicsLayer->setReplicatedByLayer(nullptr);
     }
 
@@ skipping 1035 matching lines @@
             layerChanged = true;
         }
     } else if (m_maskLayer) {
         m_maskLayer = nullptr;
         layerChanged = true;
     }
 
     return layerChanged;
 }
 
-bool CompositedLayerMapping::updateClippingMaskLayers(bool needsChildClippingMaskLayer)
+void CompositedLayerMapping::updateChildClippingMaskLayer(bool needsChildClippingMaskLayer)
 {
-    bool layerChanged = false;
     if (needsChildClippingMaskLayer) {
         if (!m_childClippingMaskLayer) {
             m_childClippingMaskLayer = createGraphicsLayer(CompositingReasonLayerForClippingMask);
             m_childClippingMaskLayer->setPaintingPhase(GraphicsLayerPaintChildClippingMask);
-            layerChanged = true;
         }
-    } else if (m_childClippingMaskLayer) {
-        m_childClippingMaskLayer = nullptr;
-        layerChanged = true;
+        return;
     }
-    return layerChanged;
+    m_childClippingMaskLayer = nullptr;
 }
 
 bool CompositedLayerMapping::updateScrollingLayers(bool needsScrollingLayers)
 {
     ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer);
 
     bool layerChanged = false;
     if (needsScrollingLayers) {
         if (!m_scrollingLayer) {
             // Outer layer which corresponds with the scroll view.
@@ skipping 933 matching lines @@
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink