client-goodbye

third_party/WebKit/Source/platform/graphics/GraphicsLayer.cpp

 /*
  * Copyright (C) 2009 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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/graphics/GraphicsLayer.h"
 
+#include <algorithm>
+#include <cmath>
+#include <memory>
+#include <utility>
 #include "SkImageFilter.h"
 #include "SkMatrix44.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/layers/layer.h"
 #include "platform/DragImage.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/geometry/Region.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/CompositorFilterOperations.h"
 #include "platform/graphics/FirstPaintInvalidationTracking.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/Image.h"
+#include "platform/graphics/InvalidationDebugging.h"
 #include "platform/graphics/LinkHighlight.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 #include "platform/graphics/paint/PaintCanvas.h"
 #include "platform/graphics/paint/PaintController.h"
 #include "platform/graphics/paint/RasterInvalidationTracking.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/json/JSONValues.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "platform/text/TextStream.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebFloatPoint.h"
 #include "public/platform/WebFloatRect.h"
 #include "public/platform/WebLayer.h"
 #include "public/platform/WebPoint.h"
 #include "public/platform/WebSize.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/StringUTF8Adaptor.h"
 #include "wtf/text/WTFString.h"
-#include <algorithm>
-#include <cmath>
-#include <memory>
-#include <utility>
 
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 namespace blink {
 
 template class RasterInvalidationTrackingMap<const GraphicsLayer>;
 static RasterInvalidationTrackingMap<const GraphicsLayer>&
 rasterInvalidationTrackingMap() {
@@ skipping 431 matching lines @@
   if (auto* tracking = getRasterInvalidationTracking())
     return !tracking->trackedRasterInvalidations.isEmpty();
   return false;
 }
 
 const RasterInvalidationTracking* GraphicsLayer::getRasterInvalidationTracking()
     const {
   return rasterInvalidationTrackingMap().find(this);
 }
 
-void GraphicsLayer::trackRasterInvalidation(const DisplayItemClient& client,
+void GraphicsLayer::trackRasterInvalidation(const InvalidationDebugging& debug,
                                             const IntRect& rect,
                                             PaintInvalidationReason reason) {
   if (!isTrackingOrCheckingRasterInvalidations() || rect.isEmpty())
     return;
 
   RasterInvalidationTracking& tracking =
       rasterInvalidationTrackingMap().add(this);
 
   if (m_isTrackingRasterInvalidations) {
     RasterInvalidationInfo info;
-    info.client = &client;
-    info.clientDebugName = client.debugName();
+    info.source = &debug;
+    info.clientDebugName = debug.invalidationName();
     info.rect = rect;
     info.reason = reason;
     tracking.trackedRasterInvalidations.push_back(info);
   }
 
   if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
     // TODO(crbug.com/496260): Some antialiasing effects overflow the paint
     // invalidation rect.
     IntRect r = rect;
     r.inflate(1);
@@ skipping 473 matching lines @@
   platformLayer()->setBlendMode(blendMode);
 }
 
 void GraphicsLayer::setIsRootForIsolatedGroup(bool isolated) {
   if (m_isRootForIsolatedGroup == isolated)
     return;
   m_isRootForIsolatedGroup = isolated;
   platformLayer()->setIsRootForIsolatedGroup(isolated);
 }
 
+class GraphicsLayerInvalidationDebugging : public InvalidationDebugging {
+ public:
+  explicit GraphicsLayerInvalidationDebugging(GraphicsLayerClient* c,
+                                              GraphicsLayer* g)
+      : m_client(c), m_layer(g) {}
+
+  WTF::String invalidationName() const final {
+    return m_client->debugName(m_layer);
+  }
+
+ private:
+  GraphicsLayerClient* m_client;
+  GraphicsLayer* m_layer;
+};
+
 void GraphicsLayer::setContentsNeedsDisplay() {
   if (WebLayer* contentsLayer = contentsLayerIfRegistered()) {
     contentsLayer->invalidate();
-    trackRasterInvalidation(*this, m_contentsRect, PaintInvalidationFull);
+    GraphicsLayerInvalidationDebugging debug(m_client, this);
+    trackRasterInvalidation(debug, m_contentsRect, PaintInvalidationFull);
   }
 }
 
 void GraphicsLayer::setNeedsDisplay() {
   if (!drawsContent())
     return;
 
   // TODO(chrishtr): Stop invalidating the rects once
   // FrameView::paintRecursively() does so.
   m_layer->layer()->invalidate();
   for (size_t i = 0; i < m_linkHighlights.size(); ++i)
     m_linkHighlights[i]->invalidate();
   getPaintController().invalidateAll();
 
-  trackRasterInvalidation(*this, IntRect(IntPoint(), expandedIntSize(m_size)),
+  GraphicsLayerInvalidationDebugging debug(m_client, this);
+  trackRasterInvalidation(debug, IntRect(IntPoint(), expandedIntSize(m_size)),
                           PaintInvalidationFull);
 }
 
 DISABLE_CFI_PERF
 void GraphicsLayer::setNeedsDisplayInRect(
     const IntRect& rect,
     PaintInvalidationReason invalidationReason,
-    const DisplayItemClient& client) {
+    const InvalidationDebugging& debug) {
   if (!drawsContent())
     return;
 
   m_layer->layer()->invalidateRect(rect);
   if (FirstPaintInvalidationTracking::isEnabled())
     m_debugInfo.appendAnnotatedInvalidateRect(rect, invalidationReason);
   for (size_t i = 0; i < m_linkHighlights.size(); ++i)
     m_linkHighlights[i]->invalidate();
 
-  trackRasterInvalidation(client, rect, invalidationReason);
+  trackRasterInvalidation(debug, rect, invalidationReason);
 }
 
 void GraphicsLayer::setContentsRect(const IntRect& rect) {
   if (rect == m_contentsRect)
     return;
 
   m_contentsRect = rect;
   updateContentsRect();
 }
 
@@ skipping 248 matching lines @@
 void showGraphicsLayerTree(const blink::GraphicsLayer* layer) {
   if (!layer) {
     LOG(INFO) << "Cannot showGraphicsLayerTree for (nil).";
     return;
   }
 
   String output = layer->layerTreeAsText(blink::LayerTreeIncludesDebugInfo);
   LOG(INFO) << output.utf8().data();
 }
 #endif