Consolidate background fill layer opaqueness into one method

third_party/WebKit/Source/core/style/FillLayer.cpp

 /*
  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "core/style/FillLayer.h"
 
+#include "core/layout/LayoutObject.h"
 #include "core/style/DataEquivalency.h"
 
 namespace blink {
 
 struct SameSizeAsFillLayer {
     FillLayer* m_next;
 
     RefPtrWillBePersistent<StyleImage> m_image;
 
     Length m_xPosition;
@@ skipping 329 matching lines @@
 {
     const FillLayer* curr;
     for (curr = this; curr; curr = curr->next()) {
         if (curr->m_image && !curr->m_image->isLoaded())
             return false;
     }
 
     return true;
 }
 
-bool FillLayer::hasOpaqueImage(const LayoutObject* layoutObject) const
+bool FillLayer::imageIsOpaqueAndTilesLayer(const LayoutObject& layoutObject) const

[Stephen Chennney, 2016/03/16 20:54:16]

Put almost all the conditions surround images here.

 {
-    if (!m_image)
+    // Returns true if we have an image and tiling that will cover the content below it when
+    // m_composite == CompositeSourceOver && m_blendMode == WebBlendModeNormal.
+    // Otherwise false.
+    // TODO(schenney) We could relax the repeat mode requirement if we also knew the rect we
+    // had to fill, and the portion of the image we need to use, and know that the latter
+    // covers the former
+    return m_image
+        && m_image->canRender()

[Stephen Chennney, 2016/03/16 20:54:16]

Forgot to remove these. Will follow up.

+        && m_image->knownToBeOpaque(layoutObject)
+        && !m_image->imageSize(layoutObject, layoutObject.style()->effectiveZoom(), LayoutSize()).isEmpty()
+        && (m_repeatX == RepeatFill || m_repeatX == RoundFill)
+        && (m_repeatY == RepeatFill || m_repeatY == RoundFill);
+
+}
+
+bool FillLayer::imageOccludesNextLayers(const LayoutObject& layoutObject) const

[Stephen Chennney, 2016/03/16 20:54:16]

Due to the compositing modes behavior, it's not really possible to get a nice
breakdown of single conditions.

+{
+    // We can't cover without an image, regardless of other parameters
+    if (!m_image || !m_image->canRender())
         return false;
 
-    // TODO(trchen): Should check blend mode before composite mode.
-    if (m_composite == CompositeClear || m_composite == CompositeCopy)
-        return true;
+    if (imageIsOpaqueAndTilesLayer(layoutObject)) {
+        // Check that the compositing and blend modes maintain the opaqueness
+        return (m_composite == CompositeClear
+            || m_composite == CompositeCopy
+            || m_composite == CompositeSourceOver)
+            && m_blendMode == WebBlendModeNormal;
+    }
 
-    if (m_blendMode != WebBlendModeNormal)
-        return false;
-
-    if (m_composite == CompositeSourceOver)
-        return m_image->knownToBeOpaque(*layoutObject);
-
-    return false;
-}
-
-bool FillLayer::hasRepeatXY() const
-{
-    return m_repeatX == RepeatFill && m_repeatY == RepeatFill;
+    // The image is not opaque, but these composite modes overwrite the background
+    // regardless of the foreground.
+    return (m_composite == CompositeClear || m_composite == CompositeCopy);

[Stephen Chennney, 2016/03/16 20:54:16]

This is really the else clause, but we do not put the else clause before an
immediate method return.

 }
 
 static inline bool layerImagesIdentical(const FillLayer& layer1, const FillLayer& layer2)
 {
     // We just care about pointer equivalency.
     return layer1.image() == layer2.image();
 }
 
 bool FillLayer::imagesIdentical(const FillLayer* layer1, const FillLayer* layer2)
 {
     for (; layer1 && layer2; layer1 = layer1->next(), layer2 = layer2->next()) {
         if (!layerImagesIdentical(*layer1, *layer2))
             return false;
     }
 
     return !layer1 && !layer2;
 }
 
 } // namespace blink