Pass the argument of DrawingArea::shouldUseTiledBackingForFrameView by reference
[WebKit-https.git] / Source / WebKit2 / WebProcess / WebPage / mac / RemoteLayerTreeDrawingArea.h
index 06fc6df..020eec2 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2012-2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef RemoteLayerTreeDrawingArea_h
-#define RemoteLayerTreeDrawingArea_h
+#pragma once
 
 #include "DrawingArea.h"
 #include "GraphicsLayerCARemote.h"
+#include "RemoteLayerTreeTransaction.h"
 #include <WebCore/GraphicsLayerClient.h>
+#include <WebCore/Timer.h>
+#include <atomic>
+#include <dispatch/dispatch.h>
 #include <wtf/HashMap.h>
+#include <wtf/WeakPtr.h>
 
 namespace WebCore {
 class PlatformCALayer;
@@ -38,47 +42,137 @@ class PlatformCALayer;
 namespace WebKit {
 
 class RemoteLayerTreeContext;
+class RemoteLayerTreeDisplayRefreshMonitor;
 
 class RemoteLayerTreeDrawingArea : public DrawingArea, public WebCore::GraphicsLayerClient {
+    friend class RemoteLayerTreeDisplayRefreshMonitor;
 public:
-    RemoteLayerTreeDrawingArea(WebPage*, const WebPageCreationParameters&);
+    RemoteLayerTreeDrawingArea(WebPage&, const WebPageCreationParameters&);
     virtual ~RemoteLayerTreeDrawingArea();
 
+    uint64_t nextTransactionID() const { return m_currentTransactionID + 1; }
+    uint64_t lastCommittedTransactionID() const { return m_currentTransactionID; }
+
+    WeakPtr<RemoteLayerTreeDrawingArea> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }
+
 private:
     // DrawingArea
-    virtual void setNeedsDisplay() OVERRIDE;
-    virtual void setNeedsDisplayInRect(const WebCore::IntRect&) OVERRIDE;
-    virtual void scroll(const WebCore::IntRect& scrollRect, const WebCore::IntSize& scrollDelta) OVERRIDE;
-    virtual void updateGeometry(const WebCore::IntSize& viewSize, const WebCore::IntSize& layerPosition) OVERRIDE;
+    void setNeedsDisplay() override;
+    void setNeedsDisplayInRect(const WebCore::IntRect&) override;
+    void scroll(const WebCore::IntRect& scrollRect, const WebCore::IntSize& scrollDelta) override;
+    void updateGeometry(const WebCore::IntSize& viewSize, const WebCore::IntSize& layerPosition, bool flushSynchronously, const WebCore::MachSendRight& fencePort) override;
 
-    virtual WebCore::GraphicsLayerFactory* graphicsLayerFactory() OVERRIDE;
-    virtual void setRootCompositingLayer(WebCore::GraphicsLayer*) OVERRIDE;
-    virtual void scheduleCompositingLayerFlush() OVERRIDE;
+    WebCore::GraphicsLayerFactory* graphicsLayerFactory() override;
+    void setRootCompositingLayer(WebCore::GraphicsLayer*) override;
+    void scheduleCompositingLayerFlush() override;
+    void scheduleCompositingLayerFlushImmediately() override;
+    void attachViewOverlayGraphicsLayer(WebCore::Frame*, WebCore::GraphicsLayer*) override;
 
-    virtual bool shouldUseTiledBackingForFrameView(const WebCore::FrameView*) OVERRIDE;
+    void addTransactionCallbackID(uint64_t callbackID) override;
 
-    virtual void updatePreferences(const WebPreferencesStore&) OVERRIDE;
+    RefPtr<WebCore::DisplayRefreshMonitor> createDisplayRefreshMonitor(WebCore::PlatformDisplayID) override;
+    void willDestroyDisplayRefreshMonitor(WebCore::DisplayRefreshMonitor*);
 
-    virtual void didInstallPageOverlay(PageOverlay*) OVERRIDE;
-    virtual void didUninstallPageOverlay(PageOverlay*) OVERRIDE;
-    virtual void setPageOverlayNeedsDisplay(PageOverlay*, const WebCore::IntRect&) OVERRIDE;
-    virtual void setPageOverlayOpacity(PageOverlay*, float) OVERRIDE;
+    bool shouldUseTiledBackingForFrameView(const WebCore::FrameView&) override;
 
-    // WebCore::GraphicsLayerClient
-    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time) OVERRIDE { }
-    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*) OVERRIDE { }
-    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect) OVERRIDE;
-    virtual float deviceScaleFactor() const OVERRIDE;
-    virtual void didCommitChangesForLayer(const WebCore::GraphicsLayer*) const OVERRIDE { }
+    void updatePreferences(const WebPreferencesStore&) override;
 
-    std::unique_ptr<RemoteLayerTreeContext> m_remoteLayerTreeContext;
-    RefPtr<WebCore::PlatformCALayer> m_rootLayer;
+    bool supportsAsyncScrolling() override { return true; }
+
+    void setLayerTreeStateIsFrozen(bool) override;
+
+    void forceRepaint() override;
+    bool forceRepaintAsync(uint64_t) override { return false; }
+
+    void setViewExposedRect(std::optional<WebCore::FloatRect>) override;
+    std::optional<WebCore::FloatRect> viewExposedRect() const override { return m_scrolledViewExposedRect; }
+
+    void acceleratedAnimationDidStart(uint64_t layerID, const String& key, double startTime) override;
+    void acceleratedAnimationDidEnd(uint64_t layerID, const String& key) override;
+
+#if PLATFORM(IOS)
+    WebCore::FloatRect exposedContentRect() const override;
+    void setExposedContentRect(const WebCore::FloatRect&) override;
+#endif
+
+    void didUpdate() override;
+
+#if PLATFORM(IOS)
+    void setDeviceScaleFactor(float) override;
+#endif
+
+    void mainFrameContentSizeChanged(const WebCore::IntSize&) override;
+
+    void activityStateDidChange(WebCore::ActivityState::Flags changed, bool wantsDidUpdateActivityState, const Vector<uint64_t>& callbackIDs) override;
+
+    bool adjustLayerFlushThrottling(WebCore::LayerFlushThrottleState::Flags) override;
+
+    bool dispatchDidReachLayoutMilestone(WebCore::LayoutMilestones) override;
+
+    void updateScrolledExposedRect();
+    void updateRootLayers();
+
+    void flushLayers();
+
+    WebCore::TiledBacking* mainFrameTiledBacking() const;
 
-    HashMap<PageOverlay*, std::unique_ptr<GraphicsLayerCARemote>> m_pageOverlayLayers;
+    uint64_t takeNextTransactionID() { return ++m_currentTransactionID; }
+
+    bool markLayersVolatileImmediatelyIfPossible() override;
+
+    class BackingStoreFlusher : public ThreadSafeRefCounted<BackingStoreFlusher> {
+    public:
+        static Ref<BackingStoreFlusher> create(IPC::Connection*, std::unique_ptr<IPC::Encoder>, Vector<RetainPtr<CGContextRef>>);
+
+        void flush();
+        bool hasFlushed() const { return m_hasFlushed; }
+
+    private:
+        BackingStoreFlusher(IPC::Connection*, std::unique_ptr<IPC::Encoder>, Vector<RetainPtr<CGContextRef>>);
+
+        RefPtr<IPC::Connection> m_connection;
+        std::unique_ptr<IPC::Encoder> m_commitEncoder;
+        Vector<RetainPtr<CGContextRef>> m_contextsToFlush;
+
+        std::atomic<bool> m_hasFlushed;
+    };
+
+    std::unique_ptr<RemoteLayerTreeContext> m_remoteLayerTreeContext;
+    std::unique_ptr<WebCore::GraphicsLayer> m_rootLayer;
 
     WebCore::IntSize m_viewSize;
+
+    std::optional<WebCore::FloatRect> m_viewExposedRect;
+    std::optional<WebCore::FloatRect> m_scrolledViewExposedRect;
+
+    WebCore::Timer m_layerFlushTimer;
+    bool m_isFlushingSuspended { false };
+    bool m_hasDeferredFlush { false };
+    bool m_isThrottlingLayerFlushes { false };
+    bool m_isLayerFlushThrottlingTemporarilyDisabledForInteraction { false };
+    bool m_isInitialThrottledLayerFlush { false };
+
+    bool m_waitingForBackingStoreSwap { false };
+    bool m_hadFlushDeferredWhileWaitingForBackingStoreSwap { false };
+    bool m_nextFlushIsForImmediatePaint { false };
+
+    dispatch_queue_t m_commitQueue;
+    RefPtr<BackingStoreFlusher> m_pendingBackingStoreFlusher;
+
+    HashSet<RemoteLayerTreeDisplayRefreshMonitor*> m_displayRefreshMonitors;
+    HashSet<RemoteLayerTreeDisplayRefreshMonitor*>* m_displayRefreshMonitorsToNotify { nullptr };
+
+    uint64_t m_currentTransactionID { 0 };
+    Vector<RemoteLayerTreeTransaction::TransactionCallbackID> m_pendingCallbackIDs;
+
+    WebCore::LayoutMilestones m_pendingNewlyReachedLayoutMilestones { 0 };
+
+    WebCore::GraphicsLayer* m_contentLayer { nullptr };
+    WebCore::GraphicsLayer* m_viewOverlayRootLayer { nullptr };
+    
+    WeakPtrFactory<RemoteLayerTreeDrawingArea> m_weakPtrFactory;
 };
 
 } // namespace WebKit
 
-#endif // RemoteLayerTreeDrawingArea_h
+SPECIALIZE_TYPE_TRAITS_DRAWING_AREA(RemoteLayerTreeDrawingArea, DrawingAreaTypeRemoteLayerTree)