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

Source/web/WebGraphicsContextImpl.h

+// Copyright 2015 The Chromium Authors. All rights reserved.

[pdr., 2015/02/10 23:47:08]

Can we combine this with WebGraphicsContext?

[jbroman, 2015/02/11 00:32:54]

The interface/impl pattern seems to be more common, from what I can tell. It's
not impossible, but it would also require:

1. guarding references to GraphicsContext with BLINK_IMPLEMENTATION or similar
2. declaring DisplayItemClient (and you cannot forward-declare typedefs nor can
you include platform/graphics from public/, so this would require
forward-declaring DisplayItemClientInternalVoid as well)
3. declaring DisplayItem::Type (and enums within classes cannot be
forward-declared, so this would require the full definition of DisplayItem,
which cannot be included from here)

2 and 3 could be fixed by with another level of indirection (the so-called PIMPL
pattern; forward-declaring a private struct, holding it in an OwnPtr in
WebGraphicsContext, and then providing the definition in a source file). That
would look something like:

class WebGraphicsContext {
public:
    // ...
private:
    struct PrivateData;
    WebPrivateOwnPtr<PrivateData> m_privateData;
};

I'm not sure that's a win in readability, though. It also would make it harder
to mock out WebGraphicsContext for test (for example, the Chromium-side
implementations of WebPageOverlay could be unit tested by providing a mock
implementation of WebGraphicsContext).

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef WebGraphicsContextImpl_h
+#define WebGraphicsContextImpl_h
+
+#include "platform/graphics/paint/DisplayItem.h"
+#include "platform/graphics/paint/DisplayItemClient.h"
+#include "public/web/WebGraphicsContext.h"
+#include "wtf/OwnPtr.h"
+
+namespace blink {
+
+class DrawingRecorder;
+class GraphicsContext;
+
+// Wraps a blink::GraphicsContext.
+// Internal consumers can extract the underlying context (via WebGraphicsContextImpl).
+// External consumers can make a single drawing using a WebCanvas.
+class WebGraphicsContextImpl : public WebGraphicsContext {
+public:
+    WebGraphicsContextImpl(GraphicsContext&, DisplayItemClient, DisplayItem::Type);
+    ~WebGraphicsContextImpl();
+    GraphicsContext& graphicsContext() { return m_graphicsContext; }
+
+    // blink::WebGraphicsContext
+    WebCanvas* beginDrawing(const WebFloatRect& bounds) override;
+    void endDrawing() override;
+
+private:
+    GraphicsContext& m_graphicsContext;
+    DisplayItemClient m_client;
+    DisplayItem::Type m_type;
+    OwnPtr<DrawingRecorder> m_drawingRecorder;
+#ifndef NDEBUG
+    bool m_hasBegunDrawing;
+#endif
+};
+
+// Source/web/ assumes that WebGraphicsContextImpl is the only implementation.
+DEFINE_TYPE_CASTS(WebGraphicsContextImpl, WebGraphicsContext, webGraphicsContext, true, true);
+
+} // namespace blink
+
+#endif