1 files changed, 51 insertions, 19 deletions

diff --git a/Source/WebKit2/UIProcess/DrawingAreaProxy.h b/Source/WebKit2/UIProcess/DrawingAreaProxy.h
index 81cf05990..ee97f0c85 100644
--- a/Source/WebKit2/UIProcess/DrawingAreaProxy.h
+++ b/Source/WebKit2/UIProcess/DrawingAreaProxy.h
@@ -28,19 +28,26 @@
 #define DrawingAreaProxy_h
 
 #include "DrawingAreaInfo.h"
+#include "GenericCallback.h"
 #include "MessageReceiver.h"
 #include <WebCore/FloatRect.h>
 #include <WebCore/IntRect.h>
 #include <WebCore/IntSize.h>
-#include <WebCore/Timer.h>
 #include <chrono>
 #include <stdint.h>
 #include <wtf/Noncopyable.h>
+#include <wtf/RunLoop.h>
+#include <wtf/TypeCasts.h>
+
+#if PLATFORM(COCOA)
+namespace WebCore {
+class MachSendRight;
+}
+#endif
 
 namespace WebKit {
 
 class LayerTreeContext;
-class CoordinatedLayerTreeHostProxy;
 class UpdateInfo;
 class WebPageProxy;
 
@@ -60,12 +67,12 @@ public:
     virtual void waitForBackingStoreUpdateOnNextPaint() { }
 
     const WebCore::IntSize& size() const { return m_size; }
-    void setSize(const WebCore::IntSize&, const WebCore::IntSize&, const WebCore::IntSize& scrollOffset);
+    bool setSize(const WebCore::IntSize&, const WebCore::IntSize&, const WebCore::IntSize& scrollOffset);
 
     // The timeout we use when waiting for a DidUpdateGeometry message.
-    static constexpr std::chrono::milliseconds didUpdateBackingStoreStateTimeout() { return std::chrono::milliseconds(500); }
+    static constexpr Seconds didUpdateBackingStoreStateTimeout() { return Seconds::fromMilliseconds(500); }
 
-    virtual void waitForPossibleGeometryUpdate(std::chrono::milliseconds = didUpdateBackingStoreStateTimeout()) { }
+    virtual void waitForPossibleGeometryUpdate(Seconds = didUpdateBackingStoreStateTimeout()) { }
 
     virtual void colorSpaceDidChange() { }
     virtual void minimumLayoutSizeDidChange() { }
@@ -74,25 +81,45 @@ public:
     virtual void commitTransientZoom(double, WebCore::FloatPoint) { }
 
 #if PLATFORM(MAC)
-    void setExposedRect(const WebCore::FloatRect&);
-    WebCore::FloatRect exposedRect() const { return m_exposedRect; }
-    void exposedRectChangedTimerFired(WebCore::Timer<DrawingAreaProxy>*);
+    virtual void setViewExposedRect(std::optional<WebCore::FloatRect>);
+    std::optional<WebCore::FloatRect> viewExposedRect() const { return m_viewExposedRect; }
+    void viewExposedRectChangedTimerFired();
+#endif
+
+    virtual void updateDebugIndicator() { }
+
+    virtual void waitForDidUpdateActivityState() { }
     
-    void setCustomFixedPositionRect(const WebCore::FloatRect&);
+    virtual void dispatchAfterEnsuringDrawing(std::function<void (CallbackBase::Error)>) { ASSERT_NOT_REACHED(); }
+
+    // Hide the content until the currently pending update arrives.
+    virtual void hideContentUntilPendingUpdate() { ASSERT_NOT_REACHED(); }
+
+    // Hide the content until any update arrives.
+    virtual void hideContentUntilAnyUpdate() { ASSERT_NOT_REACHED(); }
+
+    virtual bool hasVisibleContent() const { return true; }
+
+    virtual void willSendUpdateGeometry() { }
+
+    virtual void prepareForAppSuspension() { }
+
+#if PLATFORM(COCOA)
+    virtual WebCore::MachSendRight createFence();
 #endif
 
 protected:
-    explicit DrawingAreaProxy(DrawingAreaType, WebPageProxy*);
+    explicit DrawingAreaProxy(DrawingAreaType, WebPageProxy&);
 
     DrawingAreaType m_type;
-    WebPageProxy* m_webPageProxy;
+    WebPageProxy& m_webPageProxy;
 
     WebCore::IntSize m_size;
     WebCore::IntSize m_layerPosition;
     WebCore::IntSize m_scrollOffset;
 
     // IPC::MessageReceiver
-    virtual void didReceiveMessage(IPC::Connection*, IPC::MessageDecoder&) override;
+    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
 
 private:
     virtual void sizeDidChange() = 0;
@@ -101,21 +128,26 @@ private:
     // FIXME: These should be pure virtual.
     virtual void update(uint64_t /* backingStoreStateID */, const UpdateInfo&) { }
     virtual void didUpdateBackingStoreState(uint64_t /* backingStoreStateID */, const UpdateInfo&, const LayerTreeContext&) { }
-#if USE(ACCELERATED_COMPOSITING)
     virtual void enterAcceleratedCompositingMode(uint64_t /* backingStoreStateID */, const LayerTreeContext&) { }
     virtual void exitAcceleratedCompositingMode(uint64_t /* backingStoreStateID */, const UpdateInfo&) { }
     virtual void updateAcceleratedCompositingMode(uint64_t /* backingStoreStateID */, const LayerTreeContext&) { }
-#endif
-#if PLATFORM(MAC)
+#if PLATFORM(COCOA)
     virtual void didUpdateGeometry() { }
-    virtual void intrinsicContentSizeDidChange(const WebCore::IntSize& newIntrinsicContentSize) { }
+    virtual void intrinsicContentSizeDidChange(const WebCore::IntSize&) { }
 
-    WebCore::Timer<DrawingAreaProxy> m_exposedRectChangedTimer;
-    WebCore::FloatRect m_exposedRect;
-    WebCore::FloatRect m_lastSentExposedRect;
+#if PLATFORM(MAC)
+    RunLoop::Timer<DrawingAreaProxy> m_viewExposedRectChangedTimer;
+    std::optional<WebCore::FloatRect> m_viewExposedRect;
+    std::optional<WebCore::FloatRect> m_lastSentViewExposedRect;
+#endif // PLATFORM(MAC)
 #endif
 };
 
 } // namespace WebKit
 
+#define SPECIALIZE_TYPE_TRAITS_DRAWING_AREA_PROXY(ToValueTypeName, ProxyType) \
+SPECIALIZE_TYPE_TRAITS_BEGIN(WebKit::ToValueTypeName) \
+    static bool isType(const WebKit::DrawingAreaProxy& proxy) { return proxy.type() == WebKit::ProxyType; } \
+SPECIALIZE_TYPE_TRAITS_END()
+
 #endif // DrawingAreaProxy_h