Remove |success| parameter from GeometryMapper's public methods

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.cpp

 // Copyright 2015 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.
 
 #include "platform/graphics/compositing/PaintArtifactCompositor.h"
 
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/playback/compositing_display_item.h"
@@ skipping 266 matching lines @@
 static void applyClipsBetweenStates(const PropertyTreeState& localState,
                                     const PropertyTreeState& ancestorState,
                                     cc::DisplayItemList& ccList,
                                     Vector<EndDisplayItemType>& endDisplayItems,
                                     GeometryMapper& geometryMapper) {
   DCHECK(localState.transform() == ancestorState.transform());
 #ifdef DCHECK_IS_ON
   const TransformPaintPropertyNode* transformNode =
       localState.clip()->localTransformSpace();
   if (transformNode != ancestorState.transform()) {
-    bool success = false;
     const TransformationMatrix& localToAncestorMatrix =
-        geometryMapper.localToAncestorMatrix(
-            transformNode, ancestorState.transform(), success);
-    DCHECK(success);
+        geometryMapper.localToAncestorMatrix(transformNode,
+                                             ancestorState.transform());
     // Clips are only in descendant spaces that are transformed by one
     // or more scrolls.
     DCHECK(localToAncestorMatrix.isIdentityOrTranslation());
   }
 #endif
 
-  FloatRect combinedClip;
-  bool success = false;
-  combinedClip = geometryMapper.localToAncestorClipRect(localState,
-                                                        ancestorState, success);
-  DCHECK(success);
+  FloatRect combinedClip =
+      geometryMapper.localToAncestorClipRect(localState, ancestorState);
 
   ccList.CreateAndAppendPairedBeginItem<cc::FloatClipDisplayItem>(
       gfx::RectF(combinedClip));
   endDisplayItems.push_back(EndClip);
 }
 
 static void recordPairedBeginDisplayItems(
     const Vector<PropertyTreeState>& pairedStates,
     const PropertyTreeState& pendingLayerState,
     cc::DisplayItemList& ccList,
@@ skipping 49 matching lines @@
       case PropertyTreeState::Effect: {
         // TODO(chrishtr): skip effect and/or compositing display items if
         // not necessary.
 
         FloatRect clipRect =
             pairedState->effect()->outputClip()->clipRect().rect();
         // TODO(chrishtr): specify origin of the filter.
         FloatPoint filterOrigin;
         if (pairedState->effect()->localTransformSpace() !=
             pairedState->transform()) {
-          bool success = false;
           const TransformPaintPropertyNode* transformNode =
               pairedState->effect()->localTransformSpace();
           const TransformationMatrix& localToAncestorMatrix =
-              geometryMapper.localToAncestorMatrix(
-                  transformNode, pairedState->transform(), success);
-          DCHECK(success);
+              geometryMapper.localToAncestorMatrix(transformNode,
+                                                   pairedState->transform());
           // Effects are only in descendant spaces that are transformed by one
           // or more scrolls.
           DCHECK(localToAncestorMatrix.isIdentityOrTranslation());
 
           clipRect = localToAncestorMatrix.mapRect(clipRect);
           filterOrigin = localToAncestorMatrix.mapPoint(filterOrigin);
         }
 
         const bool kLcdTextRequiresOpaqueLayer = true;
         ccList.CreateAndAppendPairedBeginItem<cc::CompositingDisplayItem>(
@@ skipping 686 matching lines @@
 }
 
 bool PaintArtifactCompositor::mightOverlap(
     const PaintChunk& paintChunk,
     const PendingLayer& candidatePendingLayer,
     GeometryMapper& geometryMapper) {
   PropertyTreeState rootPropertyTreeState(
       TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
       EffectPaintPropertyNode::root(), ScrollPaintPropertyNode::root());
 
-  bool success = false;
   FloatRect paintChunkScreenVisualRect =
       geometryMapper.localToAncestorVisualRect(
           paintChunk.bounds, paintChunk.properties.propertyTreeState,
-          rootPropertyTreeState, success);
-  DCHECK(success);
+          rootPropertyTreeState);
 
-  success = false;
   FloatRect pendingLayerScreenVisualRect =
       geometryMapper.localToAncestorVisualRect(
           candidatePendingLayer.bounds, candidatePendingLayer.propertyTreeState,
-          rootPropertyTreeState, success);
-  DCHECK(success);
+          rootPropertyTreeState);
 
   return paintChunkScreenVisualRect.intersects(pendingLayerScreenVisualRect);
 }
 
 PaintArtifactCompositor::PendingLayer::PendingLayer(
     const PaintChunk& firstPaintChunk)
     : bounds(firstPaintChunk.bounds),
       knownToBeOpaque(firstPaintChunk.knownToBeOpaque),
       backfaceHidden(firstPaintChunk.properties.backfaceHidden),
       propertyTreeState(firstPaintChunk.properties.propertyTreeState) {
   paintChunks.push_back(&firstPaintChunk);
 }
 
 void PaintArtifactCompositor::PendingLayer::add(
     const PaintChunk& paintChunk,
     GeometryMapper* geometryMapper) {
   DCHECK(paintChunk.properties.backfaceHidden == backfaceHidden);
   paintChunks.push_back(&paintChunk);
   FloatRect mappedBounds = paintChunk.bounds;
   if (geometryMapper) {
-    bool success = false;
     mappedBounds = geometryMapper->localToAncestorRect(
         mappedBounds, paintChunk.properties.propertyTreeState.transform(),
-        propertyTreeState.transform(), success);
-    DCHECK(success);
+        propertyTreeState.transform());
   }
   bounds.unite(mappedBounds);
   if (bounds.size() != paintChunks[0]->bounds.size()) {
     if (bounds.size() != paintChunk.bounds.size())
       knownToBeOpaque = false;
     else
       knownToBeOpaque = paintChunk.knownToBeOpaque;
   }
 }
 
@@ skipping 98 matching lines @@
 #ifndef NDEBUG
 void PaintArtifactCompositor::showDebugData() {
   LOG(ERROR) << layersAsJSON(LayerTreeIncludesDebugInfo)
                     ->toPrettyJSONString()
                     .utf8()
                     .data();
 }
 #endif
 
 }  // namespace blink