Changeset 96481 in webkit

Timestamp:

Oct 2, 2011 6:11:45 PM (13 years ago)

Author:

commit-queue@webkit.org

Message:

[chromium] Add WebWidget API for accessing the current WebCompositor
​https://bugs.webkit.org/show_bug.cgi?id=69181

Patch by James Robinson <​jamesr@chromium.org> on 2011-10-02
Reviewed by Darin Fisher.

Add new WebWidgetClient::did(Activate|Deactivate)Compositor calls intended to replace
didActivateAccleratedCompositing(bool) so that the enable call can be parameterized.

Add a WebCompositor identifier parameter to didEnableAcceleratedCompositing that can be used on the compositor
thread to get access to a WebCompositor pointer.

• public/WebWidget.h:

(WebKit::WebWidget::compositor):

• src/WebViewImpl.cpp:

(WebKit::WebViewImpl::compositor):
(WebKit::WebViewImpl::setIsAcceleratedCompositingActive):

• src/WebViewImpl.h:

Location:

trunk/Source/WebKit/chromium

Files:

• ChangeLog (modified) (1 diff)
• WebKit.gypi (modified) (1 diff)
• public/WebCompositor.h (modified) (1 diff)
• public/WebWidgetClient.h (modified) (1 diff)
• src/WebCompositorImpl.cpp (modified) (3 diffs)
• src/WebCompositorImpl.h (modified) (3 diffs)
• src/WebViewImpl.cpp (modified) (5 diffs)
• src/WebViewImpl.h (modified) (2 diffs)
• tests/CCLayerTreeHostTest.cpp (modified) (1 diff)
• tests/WebCompositorImplTest.cpp (copied) (copied from trunk/Source/WebKit/chromium/src/WebCompositorImpl.cpp) (1 diff)

trunk/Source/WebKit/chromium/ChangeLog

@@ +1 @@
+2011-10-02  James Robinson  <jamesr@chromium.org>
+
+        [chromium] Add WebWidget API for accessing the current WebCompositor
+        https://bugs.webkit.org/show_bug.cgi?id=69181
+
+        Reviewed by Darin Fisher.
+
+        Add new WebWidgetClient::did(Activate|Deactivate)Compositor calls intended to replace
+        didActivateAccleratedCompositing(bool) so that the enable call can be parameterized.
+
+        Add a WebCompositor identifier parameter to didEnableAcceleratedCompositing that can be used on the compositor
+        thread to get access to a WebCompositor pointer.
+
+        * public/WebWidget.h:
+        (WebKit::WebWidget::compositor):
+        * src/WebViewImpl.cpp:
+        (WebKit::WebViewImpl::compositor):
+        (WebKit::WebViewImpl::setIsAcceleratedCompositingActive):
+        * src/WebViewImpl.h:
+
 2011-09-30  Adrienne Walker  <enne@google.com>
 

trunk/Source/WebKit/chromium/WebKit.gypi

@@ -77 +77 @@
             'tests/TreeTestHelpers.cpp',
             'tests/TreeTestHelpers.h',
+            'tests/WebCompositorImplTest.cpp',
             'tests/WebFrameTest.cpp',
             'tests/WebURLRequestTest.cpp',

trunk/Source/WebKit/chromium/public/WebCompositor.h

@@ -41 +41 @@
     // This must be called once with a non-null WebThread before any compositors attempt to initialize.
     WEBKIT_EXPORT static void setThread(WebThread*);
+    WEBKIT_EXPORT static WebCompositor* fromIdentifier(int);
 
     virtual void setClient(WebCompositorClient*) = 0;

trunk/Source/WebKit/chromium/public/WebWidgetClient.h

@@ -53 +53 @@
 
     // Called when the compositor enables or disables.
+    // FIXME: Remove when all implementations switch over to didEnable.../didDisable...
     virtual void didActivateAcceleratedCompositing(bool active) { }
+
+    // Called when the compositor is enabled or disabled.
+    // The WebCompositor identifier can be used on the compositor thread to get access
+    // to the WebCompositor instance associated with this WebWidget.
+    virtual void didActivateCompositor(int compositorIdentifier) { }
+    virtual void didDeactivateCompositor() { }
 
     // Called when a call to WebWidget::composite is required

trunk/Source/WebKit/chromium/src/WebCompositorImpl.cpp

@@ -32 +32 @@
 #include "WebInputEvent.h"
 #include "cc/CCThreadProxy.h"
+#include <wtf/ThreadingPrimitives.h>
 
 using namespace WebCore;
@@ -43 +44 @@
 }
 
+int WebCompositorImpl::s_nextAvailableIdentifier = 1;
+
+// These data structures are always allocated from the main thread, but may
+// be accessed and mutated on the main or compositor thread.
+// s_compositors is deleted when it has no elements. s_compositorsLock is never
+// deleted.
+HashSet<WebCompositorImpl*>* WebCompositorImpl::s_compositors = 0;
+Mutex* WebCompositorImpl::s_compositorsLock = 0;
+
+WebCompositor* WebCompositor::fromIdentifier(int identifier)
+{
+    return WebCompositorImpl::fromIdentifier(identifier);
+}
+
+WebCompositor* WebCompositorImpl::fromIdentifier(int identifier)
+{
+    ASSERT(CCProxy::isImplThread());
+    if (!s_compositorsLock)
+        return 0;
+
+    MutexLocker lock(*s_compositorsLock);
+    if (!s_compositors)
+        return 0;
+
+    for (HashSet<WebCompositorImpl*>::iterator it = s_compositors->begin(); it != s_compositors->end(); ++it) {
+        if ((*it)->identifier() == identifier)
+            return *it;
+    }
+    return 0;
+}
+
 WebCompositorImpl::WebCompositorImpl()
     : m_client(0)
+    , m_identifier(s_nextAvailableIdentifier++)
 {
+    ASSERT(CCProxy::isMainThread());
+    if (!s_compositorsLock)
+        s_compositorsLock = new Mutex;
+    MutexLocker lock(*s_compositorsLock);
+    if (!s_compositors)
+        s_compositors = new HashSet<WebCompositorImpl*>;
+    s_compositors->add(this);
 }
 
 WebCompositorImpl::~WebCompositorImpl()
 {
+    ASSERT(s_compositorsLock);
+    MutexLocker lock(*s_compositorsLock);
+    ASSERT(s_compositors);
+    s_compositors->remove(this);
+    if (!s_compositors->size()) {
+        delete s_compositors;
+        s_compositors = 0;
+    }
 }
 
 void WebCompositorImpl::setClient(WebCompositorClient* client)
 {
+    ASSERT(CCProxy::isImplThread());
     ASSERT(client);
     m_client = client;
@@ -60 +109 @@
 void WebCompositorImpl::handleInputEvent(const WebInputEvent& event)
 {
+    ASSERT(CCProxy::isImplThread());
     // FIXME: Do something interesting with the event here.
     m_client->didHandleInputEvent(false);

trunk/Source/WebKit/chromium/src/WebCompositorImpl.h

@@ -28 +28 @@
 
 #include "WebCompositor.h"
+
+#include <wtf/HashSet.h>
 #include <wtf/Noncopyable.h>
 #include <wtf/PassOwnPtr.h>
+
+namespace WTF {
+class Mutex;
+}
 
 namespace WebKit {
@@ -38 +44 @@
     WTF_MAKE_NONCOPYABLE(WebCompositorImpl);
 public:
+    static WebCompositor* fromIdentifier(int identifier);
+
     static PassOwnPtr<WebCompositorImpl> create()
     {
@@ -48 +56 @@
     virtual void handleInputEvent(const WebInputEvent&);
 
+    int identifier() const { return m_identifier; }
+
 private:
     WebCompositorImpl();
 
     WebCompositorClient* m_client;
+    int m_identifier;
+
+    static HashSet<WebCompositorImpl*>* s_compositors;
+    static Mutex* s_compositorsLock;
+
+    static int s_nextAvailableIdentifier;
 };
 

trunk/Source/WebKit/chromium/src/WebViewImpl.cpp

@@ -104 +104 @@
 #include "WebAccessibilityObject.h"
 #include "WebAutofillClient.h"
+#include "WebCompositorImpl.h"
 #include "WebDevToolsAgentImpl.h"
 #include "WebDevToolsAgentPrivate.h"
@@ -2646 +2647 @@
             m_layerTreeHost->finishAllRendering();
         m_client->didActivateAcceleratedCompositing(false);
+        m_client->didDeactivateCompositor();
     } else if (m_layerTreeHost) {
         m_isAcceleratedCompositingActive = true;
@@ -2651 +2653 @@
 
         m_client->didActivateAcceleratedCompositing(true);
+        m_client->didActivateCompositor(m_webCompositorImpl->identifier());
     } else {
         TRACE_EVENT("WebViewImpl::setIsAcceleratedCompositingActive(true)", this, 0);
@@ -2668 +2671 @@
         m_layerTreeHost = CCLayerTreeHost::create(this, m_nonCompositedContentHost->topLevelRootLayer()->platformLayer(), ccSettings);
         if (m_layerTreeHost) {
+            m_webCompositorImpl = WebCompositorImpl::create();
+            // FIXME: Hook the m_webCompositorImpl up with the CCLayerTreeHost somehow.
             updateLayerTreeViewport();
             m_client->didActivateAcceleratedCompositing(true);
+            m_client->didActivateCompositor(m_webCompositorImpl->identifier());
             m_isAcceleratedCompositingActive = true;
             m_compositorCreationFailed = false;
@@ -2677 +2683 @@
             m_isAcceleratedCompositingActive = false;
             m_client->didActivateAcceleratedCompositing(false);
+            m_client->didDeactivateCompositor();
             m_compositorCreationFailed = true;
         }

trunk/Source/WebKit/chromium/src/WebViewImpl.h

@@ -83 +83 @@
 class SpeechInputClientImpl;
 class WebAccessibilityObject;
+class WebCompositorImpl;
 class WebDevToolsAgentClient;
 class WebDevToolsAgentPrivate;
@@ -576 +577 @@
     OwnPtr<WebCore::NonCompositedContentHost> m_nonCompositedContentHost;
     RefPtr<WebCore::CCLayerTreeHost> m_layerTreeHost;
+    OwnPtr<WebCompositorImpl> m_webCompositorImpl;
     WebCore::GraphicsLayer* m_rootGraphicsLayer;
     bool m_isAcceleratedCompositingActive;

trunk/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp

@@ -118 +118 @@
         bool success = initialize();
         ASSERT(success);
+        UNUSED_PARAM(success);
     }
 

trunk/Source/WebKit/chromium/tests/WebCompositorImplTest.cpp

@@ -28 +28 @@
 #include "WebCompositorImpl.h"
 
-#include "CCThreadImpl.h"
-#include "WebCompositorClient.h"
-#include "WebInputEvent.h"
-#include "cc/CCThreadProxy.h"
+#include "cc/CCProxy.h"
 
-using namespace WebCore;
+#include <gtest/gtest.h>
+#include <wtf/OwnPtr.h>
 
-namespace WebKit {
+using WebKit::WebCompositor;
+using WebKit::WebCompositorImpl;
 
-void WebCompositor::setThread(WebThread* compositorThread)
+namespace {
+
+TEST(WebCompositorImpl, fromIdentifier)
 {
-    ASSERT(compositorThread);
-    CCThreadProxy::setThread(CCThreadImpl::create(compositorThread).leakPtr());
-}
+#ifndef NDEBUG
+    // WebCompositor APIs can only be called from the compositor thread.
+    WebCore::CCProxy::setImplThread(true);
+#endif
 
-WebCompositorImpl::WebCompositorImpl()
-    : m_client(0)
-{
-}
+    // Before creating any WebCompositors, lookups for any value should fail and not crash.
+    EXPECT_EQ(0, WebCompositor::fromIdentifier(2));
+    EXPECT_EQ(0, WebCompositor::fromIdentifier(0));
+    EXPECT_EQ(0, WebCompositor::fromIdentifier(-1));
 
-WebCompositorImpl::~WebCompositorImpl()
-{
-}
+    int compositorIdentifier = -1;
+    {
+#ifndef NDEBUG
+        WebCore::CCProxy::setImplThread(false);
+#endif
+        OwnPtr<WebCompositorImpl> comp = WebCompositorImpl::create();
+#ifndef NDEBUG
+        WebCore::CCProxy::setImplThread(true);
+#endif
+        compositorIdentifier = comp->identifier();
+        // The compositor we just created should be locatable.
+        EXPECT_EQ(comp.get(), WebCompositor::fromIdentifier(compositorIdentifier));
 
-void WebCompositorImpl::setClient(WebCompositorClient* client)
-{
-    ASSERT(client);
-    m_client = client;
-}
+        // But nothing else.
+        EXPECT_EQ(0, WebCompositor::fromIdentifier(comp->identifier() + 10));
+    }
 
-void WebCompositorImpl::handleInputEvent(const WebInputEvent& event)
-{
-    // FIXME: Do something interesting with the event here.
-    m_client->didHandleInputEvent(false);
+    // After the compositor is destroyed, its entry should be removed from the map.
+    EXPECT_EQ(0, WebCompositor::fromIdentifier(compositorIdentifier));
 }
 
 }
-