[Slimming Paint] Paint the inspector overlay with GraphicsLayer DisplayList.

Source/web/PageOverlayList.cpp

 /*
  * Copyright (C) 2011 Google 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.
  *
@@ skipping 33 matching lines @@
     : m_viewImpl(viewImpl)
 {
 }
 
 PageOverlayList::~PageOverlayList()
 {
 }
 
 bool PageOverlayList::add(WebPageOverlay* overlay, int zOrder)
 {
-    bool added = false;
-    size_t index = find(overlay);
-    if (index == WTF::kNotFound) {
-        OwnPtr<PageOverlay> pageOverlay = PageOverlay::create(m_viewImpl, overlay);
-        m_pageOverlays.append(pageOverlay.release());
-        index = m_pageOverlays.size() - 1;
-        added = true;
-    }
-
-    PageOverlay* pageOverlay = m_pageOverlays[index].get();
-    pageOverlay->setZOrder(zOrder);
-
-    // Adjust page overlay list order based on their z-order numbers. We first
-    // check if we need to move the overlay up and do so if needed. Otherwise,
-    // check if we need to move it down.
-    bool zOrderChanged = false;
-    for (size_t i = index; i + 1 < m_pageOverlays.size(); ++i) {
-        if (m_pageOverlays[i]->zOrder() >= m_pageOverlays[i + 1]->zOrder()) {
-            m_pageOverlays[i].swap(m_pageOverlays[i + 1]);
-            zOrderChanged = true;
-        }
-    }
-
-    if (!zOrderChanged) {
-        for (size_t i = index; i >= 1; --i) {
-            if (m_pageOverlays[i]->zOrder() < m_pageOverlays[i - 1]->zOrder()) {
-                m_pageOverlays[i].swap(m_pageOverlays[i - 1]);
-                zOrderChanged = true;
-            }
-        }
-    }
-
-    // If we did move the overlay, that means z-order is changed and we need to
-    // update overlay layers' z-order. Otherwise, just update current overlay.
-    if (zOrderChanged) {
-        for (size_t i = 0; i < m_pageOverlays.size(); ++i)
-            m_pageOverlays[i]->clear();
-        update();
-    } else
-        pageOverlay->update();
-
+    bool added;
+    size_t index = findOrAdd(overlay, added);
+    m_pageOverlays[index]->setZOrder(zOrder);
+    updateForZOrder(index);
     return added;
 }
 
+bool PageOverlayList::add(PageOverlay::Painter* overlayPainter, int zOrder)
+{
+    bool added;
+    size_t index = findOrAdd(overlayPainter, added);
+    m_pageOverlays[index]->setZOrder(zOrder);
+    updateForZOrder(index);
+    return added;
+}
+
 bool PageOverlayList::remove(WebPageOverlay* overlay)
 {
     size_t index = find(overlay);
     if (index == WTF::kNotFound)
         return false;
 
     m_pageOverlays[index]->clear();
     m_pageOverlays.remove(index);
     return true;
 }
 
+bool PageOverlayList::remove(PageOverlay::Painter* overlayPainter)
+{
+    size_t index = find(overlayPainter);
+    if (index == WTF::kNotFound)
+        return false;
+
+    m_pageOverlays[index]->clear();
+    m_pageOverlays.remove(index);
+    return true;
+}
+
 void PageOverlayList::update()
 {
     for (size_t i = 0; i < m_pageOverlays.size(); ++i)
         m_pageOverlays[i]->update();
 }
 
 void PageOverlayList::paintWebFrame(GraphicsContext& gc)
 {
+    // If accelerated compositing is active, page overlays are painted through
+    // their corresponding GraphicsLayer.
+    ASSERT(!m_viewImpl->isAcceleratedCompositingActive());
+
     for (size_t i = 0; i < m_pageOverlays.size(); ++i)
         m_pageOverlays[i]->paintWebFrame(gc);
 }
 
 size_t PageOverlayList::find(WebPageOverlay* overlay)
 {
+    if (!overlay)
+        return WTF::kNotFound;
     for (size_t i = 0; i < m_pageOverlays.size(); ++i) {
         if (m_pageOverlays[i]->overlay() == overlay)
             return i;
     }
     return WTF::kNotFound;
 }
 
+size_t PageOverlayList::find(PageOverlay::Painter* overlayPainter)
+{
+    if (!overlayPainter)
+        return WTF::kNotFound;
+    for (size_t i = 0; i < m_pageOverlays.size(); ++i) {
+        if (m_pageOverlays[i]->overlayPainter() == overlayPainter)
+            return i;
+    }
+    return WTF::kNotFound;
+}
+
 size_t PageOverlayList::findGraphicsLayer(GraphicsLayer* layer)
 {
     for (size_t i = 0; i < m_pageOverlays.size(); ++i) {
         if (m_pageOverlays[i]->graphicsLayer() == layer)
             return i;
     }
     return WTF::kNotFound;
 }
 
+GraphicsLayer* PageOverlayList::graphicsLayerForTesting() const
+{
+    return m_pageOverlays.isEmpty() ? nullptr : m_pageOverlays[0]->graphicsLayer();
+}
+
+template <typename T>
+size_t PageOverlayList::findOrAdd(T* client, bool& added)
+{
+    size_t index = find(client);
+    if (index != WTF::kNotFound) {
+        added = false;
+        return index;
+    }
+    m_pageOverlays.append(PageOverlay::create(m_viewImpl, client));
+    added = true;
+    return m_pageOverlays.size() - 1;
+}
+
+void PageOverlayList::updateForZOrder(size_t indexOfChangedOverlay)
+{
+    // Adjust page overlay list order based on their z-order numbers. We first
+    // check if we need to move the overlay up and do so if needed. Otherwise,
+    // check if we need to move it down.
+    bool zOrderChanged = false;
+    for (size_t i = indexOfChangedOverlay; i + 1 < m_pageOverlays.size(); ++i) {
+        if (m_pageOverlays[i]->zOrder() >= m_pageOverlays[i + 1]->zOrder()) {
+            m_pageOverlays[i].swap(m_pageOverlays[i + 1]);
+            zOrderChanged = true;
+        }
+    }
+
+    if (!zOrderChanged) {
+        for (size_t i = indexOfChangedOverlay; i >= 1; --i) {
+            if (m_pageOverlays[i]->zOrder() < m_pageOverlays[i - 1]->zOrder()) {
+                m_pageOverlays[i].swap(m_pageOverlays[i - 1]);
+                zOrderChanged = true;
+            }
+        }
+    }
+
+    // If we did move the overlay, that means z-order is changed and we need to
+    // update overlay layers' z-order. Otherwise, just update current overlay.
+    if (zOrderChanged) {
+        for (size_t i = 0; i < m_pageOverlays.size(); ++i)
+            m_pageOverlays[i]->clear();
+        update();
+    } else {
+        m_pageOverlays[indexOfChangedOverlay]->update();
+    }
+}
+
 } // namespace blink