Changeset 101488 in webkit


Ignore:
Timestamp:
Nov 30, 2011 4:31:02 AM (12 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r101440 and r101442.
​http://trac.webkit.org/changeset/101440
​http://trac.webkit.org/changeset/101442
​https://bugs.webkit.org/show_bug.cgi?id=73429

multiple crashes on layout tests (Requested by hayato on
#webkit).

Patch by Sheriff Bot <​webkit.review.bot@gmail.com> on 2011-11-30

Source/WebCore:

  • platform/graphics/chromium/LayerRendererChromium.cpp:

(WebCore::LayerRendererChromium::initialize):

  • platform/graphics/chromium/WebGLLayerChromium.cpp:

(WebCore::WebGLLayerChromium::layerRendererContext):

  • platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:

(WebCore::CCHeadsUpDisplay::enabled):

  • platform/graphics/chromium/cc/CCLayerTreeHost.cpp:

(WebCore::CCLayerTreeHost::CCLayerTreeHost):
(WebCore::CCLayerTreeHost::initialize):
(WebCore::CCLayerTreeHost::~CCLayerTreeHost):
(WebCore::CCLayerTreeHost::context):
(WebCore::CCLayerTreeHost::setNeedsAnimate):
(WebCore::CCLayerTreeHost::setNeedsCommit):
(WebCore::CCLayerTreeHost::setNeedsRedraw):
(WebCore::CCLayerTreeHost::composite):

  • platform/graphics/chromium/cc/CCLayerTreeHost.h:

(WebCore::CCSettings::CCSettings):

  • platform/graphics/chromium/cc/CCProxy.cpp:

(WebCore::CCProxy::isMainThread):
(WebCore::CCProxy::isImplThread):
(WebCore::CCProxy::setImplThread):

  • platform/graphics/chromium/cc/CCProxy.h:
  • platform/graphics/chromium/cc/CCSingleThreadProxy.h:

(WebCore::DebugScopedSetImplThread::DebugScopedSetImplThread):
(WebCore::DebugScopedSetImplThread::~DebugScopedSetImplThread):

Source/WebKit/chromium:

  • WebKit.gyp:
  • WebKit.gypi:
  • public/WebCompositor.h:
  • public/WebCompositorClient.h:
  • public/WebCompositorInputHandler.h: Removed.
  • public/WebCompositorInputHandlerClient.h: Removed.
  • public/WebLayerTreeView.h:

(WebKit::WebLayerTreeView::Settings::Settings):

  • public/WebSettings.h:
  • src/WebCompositorImpl.cpp:

(WebCore::CCInputHandler::create):
(WebKit::WebCompositor::setThread):
(WebKit::WebCompositor::fromIdentifier):
(WebKit::WebCompositorImpl::fromIdentifier):
(WebKit::WebCompositorImpl::WebCompositorImpl):
(WebKit::WebCompositorImpl::~WebCompositorImpl):
(WebKit::WebCompositorImpl::setClient):
(WebKit::WebCompositorImpl::handleInputEvent):
(WebKit::WebCompositorImpl::identifier):
(WebKit::WebCompositorImpl::willDraw):

  • src/WebCompositorImpl.h:

(WebKit::WebCompositorImpl::create):

  • src/WebCompositorInputHandlerImpl.cpp: Removed.
  • src/WebCompositorInputHandlerImpl.h: Removed.
  • src/WebKit.cpp:

(WebKit::initializeWithoutV8):
(WebKit::shutdown):

  • src/WebLayerTreeView.cpp:

(WebKit::WebLayerTreeView::Settings::operator CCSettings):
(WebKit::WebLayerTreeView::composite):

  • src/WebLayerTreeViewImpl.cpp:

(WebKit::WebLayerTreeViewImpl::createLayerTreeHostContext3D):

  • src/WebSettingsImpl.cpp:

(WebKit::WebSettingsImpl::WebSettingsImpl):
(WebKit::WebSettingsImpl::setUseThreadedCompositor):

  • src/WebSettingsImpl.h:

(WebKit::WebSettingsImpl::useThreadedCompositor):

  • src/WebViewImpl.cpp:

(WebKit::WebViewImpl::animate):
(WebKit::WebViewImpl::composite):
(WebKit::WebViewImpl::scheduleAnimation):
(WebKit::WebViewImpl::setIsAcceleratedCompositingActive):
(WebKit::WebViewImpl::createLayerTreeHostContext3D):
(WebKit::WebViewImpl::scheduleComposite):
(WebKit::WebViewImpl::graphicsContext3D):

  • tests/CCLayerTreeHostTest.cpp:

(WTF::CCLayerTreeHostTest::CCLayerTreeHostTest):
(WTF::CCLayerTreeHostTest::onEndTest):
(WTF::CCLayerTreeHostTest::runTest):
(WTF::CCLayerTreeHostTest::doBeginTest):
(WTF::CCLayerTreeHostTestShortlived1::beginTest):
(WTF::CCLayerTreeHostTestShortlived2::beginTest):
(WTF::CCLayerTreeHostTestShortlived3::beginTest):
(WTF::CCLayerTreeHostTestCommitingWithContinuousRedraw::beginTest):
(WTF::CCLayerTreeHostTestOpacityChange::afterTest):

  • tests/WebCompositorImplTest.cpp: Renamed from Source/WebKit/chromium/tests/WebCompositorInputHandlerImplTest.cpp.

Tools:

  • DumpRenderTree/chromium/TestShell.cpp:

(TestShell::resetWebSettings):

  • DumpRenderTree/chromium/TestShell.h:
  • DumpRenderTree/chromium/WebPreferences.cpp:

(WebPreferences::reset):
(WebPreferences::applyTo):

  • DumpRenderTree/chromium/WebPreferences.h:
  • DumpRenderTree/chromium/WebViewHost.cpp:

(WebViewHost::WebViewHost):
(WebViewHost::~WebViewHost):

Location:
trunk
Files:
4 deleted
31 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r101486 r101488  
     12011-11-30  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r101440 and r101442.
     4        http://trac.webkit.org/changeset/101440
     5        http://trac.webkit.org/changeset/101442
     6        https://bugs.webkit.org/show_bug.cgi?id=73429
     7
     8        multiple crashes on layout tests (Requested by hayato on
     9        #webkit).
     10
     11        * platform/graphics/chromium/LayerRendererChromium.cpp:
     12        (WebCore::LayerRendererChromium::initialize):
     13        * platform/graphics/chromium/WebGLLayerChromium.cpp:
     14        (WebCore::WebGLLayerChromium::layerRendererContext):
     15        * platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:
     16        (WebCore::CCHeadsUpDisplay::enabled):
     17        * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
     18        (WebCore::CCLayerTreeHost::CCLayerTreeHost):
     19        (WebCore::CCLayerTreeHost::initialize):
     20        (WebCore::CCLayerTreeHost::~CCLayerTreeHost):
     21        (WebCore::CCLayerTreeHost::context):
     22        (WebCore::CCLayerTreeHost::setNeedsAnimate):
     23        (WebCore::CCLayerTreeHost::setNeedsCommit):
     24        (WebCore::CCLayerTreeHost::setNeedsRedraw):
     25        (WebCore::CCLayerTreeHost::composite):
     26        * platform/graphics/chromium/cc/CCLayerTreeHost.h:
     27        (WebCore::CCSettings::CCSettings):
     28        * platform/graphics/chromium/cc/CCProxy.cpp:
     29        (WebCore::CCProxy::isMainThread):
     30        (WebCore::CCProxy::isImplThread):
     31        (WebCore::CCProxy::setImplThread):
     32        * platform/graphics/chromium/cc/CCProxy.h:
     33        * platform/graphics/chromium/cc/CCSingleThreadProxy.h:
     34        (WebCore::DebugScopedSetImplThread::DebugScopedSetImplThread):
     35        (WebCore::DebugScopedSetImplThread::~DebugScopedSetImplThread):
     36
    1372011-11-30  Alexey Proskuryakov  <ap@apple.com>
    238

  • trunk/Source/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp

    r101440 r101488  
    201201
    202202    // Use the swapBuffers callback only with the threaded proxy.
    203     if (CCProxy::hasImplThread())
     203    if (settings().enableCompositorThread)
    204204        m_capabilities.usingSwapCompleteCallback = extensions->supports("GL_CHROMIUM_swapbuffers_complete_callback");
    205205    if (m_capabilities.usingSwapCompleteCallback) {

  • trunk/Source/WebCore/platform/graphics/chromium/WebGLLayerChromium.cpp

    r101440 r101488  
    163163    // FIXME: In the threaded case, paintRenderedResultsToCanvas must be
    164164    // refactored to be asynchronous. Currently this is unimplemented.
    165     if (!layerTreeHost() || CCProxy::hasImplThread())
     165    if (!layerTreeHost() || layerTreeHost()->settings().enableCompositorThread)
    166166        return 0;
    167167    return layerTreeHost()->context();

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp

    r101440 r101488  
    9191{
    9292    // FIXME: HUD does not work in compositor thread mode.
    93     if (CCProxy::hasImplThread())
     93    if (settings().enableCompositorThread)
    9494        return false;
    9595    return settings().showPlatformLayerTree || settings().showFPSCounter;

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp

    r101440 r101488  
    3838#include "cc/CCThreadProxy.h"
    3939
    40 namespace {
    41 static int numLayerTreeInstances;
    42 }
    43 
    4440namespace WebCore {
    45 
    46 bool CCLayerTreeHost::anyLayerTreeHostInstanceExists()
    47 {
    48     return numLayerTreeInstances > 0;
    49 }
    5041
    5142PassRefPtr<CCLayerTreeHost> CCLayerTreeHost::create(CCLayerTreeHostClient* client, const CCSettings& settings)
    … …  
    7061{
    7162    ASSERT(CCProxy::isMainThread());
    72     numLayerTreeInstances++;
    7363}
    7464
    … …  
    7666{
    7767    TRACE_EVENT("CCLayerTreeHost::initialize", this, 0);
    78     if (CCProxy::hasImplThread()) {
     68    if (m_settings.enableCompositorThread) {
    7969        // The HUD does not work in threaded mode. Turn it off.
    8070        m_settings.showFPSCounter = false;
    … …  
    10696    m_proxy.clear();
    10797    clearPendingUpdate();
    108     numLayerTreeInstances--;
    10998}
    11099
    … …  
    181170GraphicsContext3D* CCLayerTreeHost::context()
    182171{
    183     ASSERT(!CCProxy::hasImplThread());
     172    ASSERT(!m_settings.enableCompositorThread);
    184173    return m_proxy->context();
    185174}
    … …  
    212201void CCLayerTreeHost::setNeedsAnimate()
    213202{
    214     ASSERT(CCProxy::hasImplThread());
     203    ASSERT(m_settings.enableCompositorThread);
    215204    m_proxy->setNeedsAnimate();
    216205}
    … …  
    218207void CCLayerTreeHost::setNeedsCommit()
    219208{
    220     if (CCThreadProxy::implThread()) {
     209    if (m_settings.enableCompositorThread) {
    221210        TRACE_EVENT("CCLayerTreeHost::setNeedsCommit", this, 0);
    222211        m_proxy->setNeedsCommit();
    … …  
    227216void CCLayerTreeHost::setNeedsRedraw()
    228217{
    229     if (CCThreadProxy::implThread())
     218    if (m_settings.enableCompositorThread)
    230219        m_proxy->setNeedsRedraw();
    231220    else
    … …  
    307296void CCLayerTreeHost::composite()
    308297{
    309     ASSERT(!CCThreadProxy::implThread());
     298    ASSERT(!m_settings.enableCompositorThread);
    310299    static_cast<CCSingleThreadProxy*>(m_proxy.get())->compositeImmediately();
    311300}

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h

    r101440 r101488  
    7373            , compositeOffscreen(false)
    7474            , discardAllTextures(false)
     75            , enableCompositorThread(false)
    7576            , showFPSCounter(false)
    7677            , showPlatformLayerTree(false)
    … …  
    8182    bool compositeOffscreen;
    8283    bool discardAllTextures;
     84    bool enableCompositorThread;
    8385    bool showFPSCounter;
    8486    bool showPlatformLayerTree;
    … …  
    113115    static PassRefPtr<CCLayerTreeHost> create(CCLayerTreeHostClient*, const CCSettings&);
    114116    virtual ~CCLayerTreeHost();
    115 
    116     // Returns true if any CCLayerTreeHost is alive.
    117     static bool anyLayerTreeHostInstanceExists();
    118117
    119118    // CCLayerTreeHost interface to CCProxy.

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCProxy.cpp

    r101440 r101488  
    3838namespace {
    3939#ifndef NDEBUG
    40 bool implThreadIsOverridden = false;
    41 ThreadIdentifier threadIDOverridenToBeImplThread;
     40bool fakeImplThread = false;
    4241#endif
    4342CCThread* s_mainThread = 0;
    … …  
    5352{
    5453    return s_mainThread;
    55 }
    56 
    57 bool CCProxy::hasImplThread()
    58 {
    59     return s_implThread;
    6054}
    6155
    … …  
    7468{
    7569    ASSERT(s_mainThread);
    76     if (implThreadIsOverridden && currentThread() == threadIDOverridenToBeImplThread)
    77         return false;
    78     return currentThread() == s_mainThread->threadID();
     70    return !fakeImplThread && currentThread() == s_mainThread->threadID();
    7971}
    8072
    … …  
    8274{
    8375    WTF::ThreadIdentifier implThreadID = s_implThread ? s_implThread->threadID() : 0;
    84     if (implThreadIsOverridden && currentThread() == threadIDOverridenToBeImplThread)
    85         return true;
    86     return currentThread() == implThreadID;
     76    return fakeImplThread || currentThread() == implThreadID;
    8777}
    8878
    89 void CCProxy::setCurrentThreadIsImplThread(bool isImplThread)
     79void CCProxy::setImplThread(bool isImplThread)
    9080{
    91     implThreadIsOverridden = isImplThread;
    92     if (isImplThread)
    93         threadIDOverridenToBeImplThread = currentThread();
     81    fakeImplThread = isImplThread;
    9482}
    9583#endif

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCProxy.h

    r101440 r101488  
    5454    static CCThread* mainThread();
    5555
    56     static bool hasImplThread();
    5756    static void setImplThread(CCThread*);
    5857    static CCThread* implThread();
    … …  
    9392
    9493#ifndef NDEBUG
    95     static void setCurrentThreadIsImplThread(bool);
     94    static void setImplThread(bool);
    9695#endif
    9796

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCSingleThreadProxy.h

    r101440 r101488  
    9292    {
    9393#if !ASSERT_DISABLED
    94         CCProxy::setCurrentThreadIsImplThread(true);
     94        CCProxy::setImplThread(true);
    9595#endif
    9696    }
    … …  
    9898    {
    9999#if !ASSERT_DISABLED
    100         CCProxy::setCurrentThreadIsImplThread(false);
     100        CCProxy::setImplThread(false);
    101101#endif
    102102    }

  • trunk/Source/WebKit/chromium/ChangeLog

    r101472 r101488  
     12011-11-30  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r101440 and r101442.
     4        http://trac.webkit.org/changeset/101440
     5        http://trac.webkit.org/changeset/101442
     6        https://bugs.webkit.org/show_bug.cgi?id=73429
     7
     8        multiple crashes on layout tests (Requested by hayato on
     9        #webkit).
     10
     11        * WebKit.gyp:
     12        * WebKit.gypi:
     13        * public/WebCompositor.h:
     14        * public/WebCompositorClient.h:
     15        * public/WebCompositorInputHandler.h: Removed.
     16        * public/WebCompositorInputHandlerClient.h: Removed.
     17        * public/WebLayerTreeView.h:
     18        (WebKit::WebLayerTreeView::Settings::Settings):
     19        * public/WebSettings.h:
     20        * src/WebCompositorImpl.cpp:
     21        (WebCore::CCInputHandler::create):
     22        (WebKit::WebCompositor::setThread):
     23        (WebKit::WebCompositor::fromIdentifier):
     24        (WebKit::WebCompositorImpl::fromIdentifier):
     25        (WebKit::WebCompositorImpl::WebCompositorImpl):
     26        (WebKit::WebCompositorImpl::~WebCompositorImpl):
     27        (WebKit::WebCompositorImpl::setClient):
     28        (WebKit::WebCompositorImpl::handleInputEvent):
     29        (WebKit::WebCompositorImpl::identifier):
     30        (WebKit::WebCompositorImpl::willDraw):
     31        * src/WebCompositorImpl.h:
     32        (WebKit::WebCompositorImpl::create):
     33        * src/WebCompositorInputHandlerImpl.cpp: Removed.
     34        * src/WebCompositorInputHandlerImpl.h: Removed.
     35        * src/WebKit.cpp:
     36        (WebKit::initializeWithoutV8):
     37        (WebKit::shutdown):
     38        * src/WebLayerTreeView.cpp:
     39        (WebKit::WebLayerTreeView::Settings::operator CCSettings):
     40        (WebKit::WebLayerTreeView::composite):
     41        * src/WebLayerTreeViewImpl.cpp:
     42        (WebKit::WebLayerTreeViewImpl::createLayerTreeHostContext3D):
     43        * src/WebSettingsImpl.cpp:
     44        (WebKit::WebSettingsImpl::WebSettingsImpl):
     45        (WebKit::WebSettingsImpl::setUseThreadedCompositor):
     46        * src/WebSettingsImpl.h:
     47        (WebKit::WebSettingsImpl::useThreadedCompositor):
     48        * src/WebViewImpl.cpp:
     49        (WebKit::WebViewImpl::animate):
     50        (WebKit::WebViewImpl::composite):
     51        (WebKit::WebViewImpl::scheduleAnimation):
     52        (WebKit::WebViewImpl::setIsAcceleratedCompositingActive):
     53        (WebKit::WebViewImpl::createLayerTreeHostContext3D):
     54        (WebKit::WebViewImpl::scheduleComposite):
     55        (WebKit::WebViewImpl::graphicsContext3D):
     56        * tests/CCLayerTreeHostTest.cpp:
     57        (WTF::CCLayerTreeHostTest::CCLayerTreeHostTest):
     58        (WTF::CCLayerTreeHostTest::onEndTest):
     59        (WTF::CCLayerTreeHostTest::runTest):
     60        (WTF::CCLayerTreeHostTest::doBeginTest):
     61        (WTF::CCLayerTreeHostTestShortlived1::beginTest):
     62        (WTF::CCLayerTreeHostTestShortlived2::beginTest):
     63        (WTF::CCLayerTreeHostTestShortlived3::beginTest):
     64        (WTF::CCLayerTreeHostTestCommitingWithContinuousRedraw::beginTest):
     65        (WTF::CCLayerTreeHostTestOpacityChange::afterTest):
     66        * tests/WebCompositorImplTest.cpp: Renamed from Source/WebKit/chromium/tests/WebCompositorInputHandlerImplTest.cpp.
     67
    1682011-11-30  Daniel Sievers  <sievers@chromium.org>
    269

  • trunk/Source/WebKit/chromium/WebKit.gyp

    r101464 r101488  
    137137                'public/WebCompositorClient.h',
    138138                'public/WebCompositor.h',
    139                 'public/WebCompositorInputHandlerClient.h',
    140                 'public/WebCompositorInputHandler.h',
    141139                'public/WebConsoleMessage.h',
    142140                'public/WebContentLayer.h',
    … …  
    476474                'src/WebCompositorImpl.cpp',
    477475                'src/WebCompositorImpl.h',
    478                 'src/WebCompositorInputHandlerImpl.cpp',
    479                 'src/WebCompositorInputHandlerImpl.h',
    480476                'src/WebContentLayer.cpp',
    481477                'src/WebContentLayerImpl.cpp',

  • trunk/Source/WebKit/chromium/WebKit.gypi

    r101440 r101488  
    9090            'tests/TreeTestHelpers.cpp',
    9191            'tests/TreeTestHelpers.h',
    92             'tests/WebCompositorInputHandlerImplTest.cpp',
     92            'tests/WebCompositorImplTest.cpp',
    9393            'tests/WebFrameTest.cpp',
    9494            'tests/WebLayerTest.cpp',

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

    r101440 r101488  
    2828
    2929#include "platform/WebCommon.h"
    30 #include "WebCompositorInputHandler.h"
    3130
    3231namespace WebKit {
    3332
     33class WebCompositorClient;
    3434class WebInputEvent;
    3535class WebThread;
    3636
    37 #define WEBCOMPOSITOR_HAS_INITIALIZE
     37// This represents the compositor associated with a WebWidget. All calls to the WebCompositor must
     38// be made from the compositor thread.
     39class WebCompositor {
     40public:
     41    // This must be called once with a non-null WebThread before any compositors attempt to initialize.
     42    WEBKIT_EXPORT static void setThread(WebThread*);
     43    WEBKIT_EXPORT static WebCompositor* fromIdentifier(int);
    3844
    39 // This class contains global routines for interacting with the
    40 // compositor.
    41 //
    42 // All calls to the WebCompositor must be made from the main thread.
    43 //
    44 // This class currently temporarily inherits from WebCompositorInputHandler
    45 // while we migrate downstream code to use WebCompositorInputHandler directly.
    46 class WebCompositor : public WebCompositorInputHandler {
    47 public:
    48     // Initializes the compositor. Threaded compositing is enabled by passing in
    49     // a non-null WebThread. No compositor classes or methods should be used
    50     // prior to calling initialize.
    51     WEBKIT_EXPORT static void initialize(WebThread*);
    52 
    53     // Shuts down the compositor. This must be called when all compositor data
    54     // types have been deleted. No compositor classes or methods should be used
    55     // after shutdown.
    56     WEBKIT_EXPORT static void shutdown();
     45    virtual void setClient(WebCompositorClient*) = 0;
     46    virtual void handleInputEvent(const WebInputEvent&) = 0;
    5747
    5848protected:

  • trunk/Source/WebKit/chromium/public/WebCompositorClient.h

    r101440 r101488  
    2727#define WebCompositorClient_h
    2828
    29 #include "WebCompositorInputHandlerClient.h"
    30 
    3129namespace WebKit {
    3230
    33 // This class will go away once downstream code has transitioned
    34 // to WebCompositorInputHandlerClient.
    35 class WebCompositorClient : public WebCompositorInputHandlerClient {
     31class WebCompositorClient {
    3632public:
     33    // Callbacks invoked from the compositor thread.
     34    virtual void willShutdown() = 0;
     35
     36    // Exactly one of the following two callbacks will be invoked after every call to WebCompositor::handleInputEvent():
     37
     38    // Called when the WebCompositor handled the input event and no further processing is required.
     39    virtual void didHandleInputEvent() = 0;
     40
     41    // Called when the WebCompositor did not handle the input event. If sendToWidget is true, the input event
     42    // should be forwarded to the WebWidget associated with this compositor for further processing.
     43    virtual void didNotHandleInputEvent(bool sendToWidget) = 0;
     44
    3745protected:
    3846    virtual ~WebCompositorClient() { }

  • trunk/Source/WebKit/chromium/public/WebLayerTreeView.h

    r101440 r101488  
    4747            : acceleratePainting(false)
    4848            , compositeOffscreen(false)
     49            , enableCompositorThread(false)
    4950            , showFPSCounter(false)
    5051            , showPlatformLayerTree(false) { }
    … …  
    5253        bool acceleratePainting;
    5354        bool compositeOffscreen;
     55        bool enableCompositorThread;
    5456        bool showFPSCounter;
    5557        bool showPlatformLayerTree;
    … …  
    7375    WEBKIT_EXPORT bool equals(const WebLayerTreeView&) const;
    7476
    75     // Triggers a compositing pass. If the compositor thread was not
    76     // enabled via WebCompositor::initialize, the compositing pass happens
     77    // Triggers a compositing pass. If the compositor thread is disabled
     78    // (enableCompositorThread == false), the compositing pass happens
    7779    // immediately. If it is enabled, the compositing pass will happen at a
    7880    // later time. Before the compositing pass happens (i.e. before composite()

  • trunk/Source/WebKit/chromium/public/WebSettings.h

    r101440 r101488  
    118118    virtual void setMinimumAccelerated2dCanvasSize(int) = 0;
    119119    virtual void setAcceleratedDrawingEnabled(bool) = 0;
     120    virtual void setUseThreadedCompositor(bool) = 0;
     121    virtual bool useThreadedCompositor() const = 0;
    120122    virtual void setMemoryInfoEnabled(bool) = 0;
    121123    virtual void setHyperlinkAuditingEnabled(bool) = 0;

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

    r101442 r101488  
    2929
    3030#include "CCThreadImpl.h"
    31 #include "WebKit.h"
    32 #include "WebKitPlatformSupport.h"
    3331#include "WebCompositorClient.h"
    3432#include "WebInputEvent.h"
    35 #include "cc/CCProxy.h"
    36 #include "cc/CCLayerTreeHost.h"
     33#include "cc/CCInputHandler.h"
     34#include "cc/CCThreadProxy.h"
    3735#include <wtf/ThreadingPrimitives.h>
    3836
    3937using namespace WebCore;
    4038
    41 namespace WebKit {
     39namespace WebCore {
    4240
    43 bool WebCompositorImpl::s_initialized = false;
    44 CCThread* WebCompositorImpl::s_mainThread = 0;
    45 CCThread* WebCompositorImpl::s_implThread = 0;
    46 
    47 void WebCompositor::initialize(WebThread* implThread)
     41PassOwnPtr<CCInputHandler> CCInputHandler::create(CCInputHandlerClient* inputHandlerClient)
    4842{
    49     WebCompositorImpl::initialize(implThread);
    50 }
    51 void WebCompositor::shutdown()
    52 {
    53     WebCompositorImpl::shutdown();
    54 }
    55 
    56 void WebCompositorImpl::initialize(WebThread* implThread)
    57 {
    58     ASSERT(!s_initialized);
    59     s_initialized = true;
    60 
    61     s_mainThread = CCThreadImpl::create(webKitPlatformSupport()->currentThread()).leakPtr();
    62     CCProxy::setMainThread(s_mainThread);
    63     if (implThread) {
    64         s_implThread = CCThreadImpl::create(implThread).leakPtr();
    65         CCProxy::setImplThread(s_implThread);
    66     } else
    67         CCProxy::setImplThread(0);
    68 }
    69 
    70 bool WebCompositorImpl::initialized()
    71 {
    72     return s_initialized;
    73 }
    74 
    75 void WebCompositorImpl::shutdown()
    76 {
    77     ASSERT(s_initialized);
    78     ASSERT(!CCLayerTreeHost::anyLayerTreeHostInstanceExists());
    79 
    80     if (s_implThread) {
    81         delete s_implThread;
    82         s_implThread = 0;
    83     }
    84     delete s_mainThread;
    85     s_mainThread = 0;
    86     CCProxy::setImplThread(0);
    87     CCProxy::setMainThread(0);
    88     s_initialized = false;
     43    return WebKit::WebCompositorImpl::create(inputHandlerClient);
    8944}
    9045
    9146}
     47
     48namespace WebKit {
     49
     50void WebCompositor::setThread(WebThread* compositorThread)
     51{
     52    ASSERT(compositorThread);
     53    CCThreadProxy::setImplThread(CCThreadImpl::create(compositorThread).leakPtr());
     54}
     55
     56
     57// These statics may only be accessed from the compositor thread.
     58int WebCompositorImpl::s_nextAvailableIdentifier = 1;
     59HashSet<WebCompositorImpl*>* WebCompositorImpl::s_compositors = 0;
     60
     61WebCompositor* WebCompositor::fromIdentifier(int identifier)
     62{
     63    ASSERT(CCProxy::isImplThread());
     64    return WebCompositorImpl::fromIdentifier(identifier);
     65}
     66
     67WebCompositor* WebCompositorImpl::fromIdentifier(int identifier)
     68{
     69    ASSERT(CCProxy::isImplThread());
     70
     71    if (!s_compositors)
     72        return 0;
     73
     74    for (HashSet<WebCompositorImpl*>::iterator it = s_compositors->begin(); it != s_compositors->end(); ++it) {
     75        if ((*it)->identifier() == identifier)
     76            return *it;
     77    }
     78    return 0;
     79}
     80
     81WebCompositorImpl::WebCompositorImpl(CCInputHandlerClient* inputHandlerClient)
     82    : m_client(0)
     83    , m_identifier(s_nextAvailableIdentifier++)
     84    , m_inputHandlerClient(inputHandlerClient)
     85{
     86    ASSERT(CCProxy::isImplThread());
     87
     88    if (!s_compositors)
     89        s_compositors = new HashSet<WebCompositorImpl*>;
     90    s_compositors->add(this);
     91}
     92
     93WebCompositorImpl::~WebCompositorImpl()
     94{
     95    ASSERT(CCProxy::isImplThread());
     96    if (m_client)
     97        m_client->willShutdown();
     98
     99    ASSERT(s_compositors);
     100    s_compositors->remove(this);
     101    if (!s_compositors->size()) {
     102        delete s_compositors;
     103        s_compositors = 0;
     104    }
     105}
     106
     107void WebCompositorImpl::setClient(WebCompositorClient* client)
     108{
     109    ASSERT(CCProxy::isImplThread());
     110    // It's valid to set a new client if we've never had one or to clear the client, but it's not valid to change from having one client to a different one.
     111    ASSERT(!m_client || !client);
     112    m_client = client;
     113}
     114
     115void WebCompositorImpl::handleInputEvent(const WebInputEvent& event)
     116{
     117    ASSERT(CCProxy::isImplThread());
     118    ASSERT(m_client);
     119
     120    if (event.type == WebInputEvent::MouseWheel && !m_inputHandlerClient->haveWheelEventHandlers()) {
     121        const WebMouseWheelEvent& wheelEvent = *static_cast<const WebMouseWheelEvent*>(&event);
     122        m_inputHandlerClient->scrollRootLayer(IntSize(-wheelEvent.deltaX, -wheelEvent.deltaY));
     123        m_client->didHandleInputEvent();
     124        return;
     125    }
     126    m_client->didNotHandleInputEvent(true /* sendToWidget */);
     127}
     128
     129int WebCompositorImpl::identifier() const
     130{
     131    ASSERT(CCProxy::isImplThread());
     132    return m_identifier;
     133}
     134
     135void WebCompositorImpl::willDraw(double frameBeginTimeMs)
     136{
     137}
     138
     139}

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

    r101442 r101488  
    2929#include "WebCompositor.h"
    3030
     31#include "cc/CCInputHandler.h"
    3132#include <wtf/HashSet.h>
    3233#include <wtf/Noncopyable.h>
    33 #include <wtf/OwnPtr.h>
     34#include <wtf/PassOwnPtr.h>
    3435
    35 namespace WebCore {
    36 class CCThread;
     36namespace WTF {
     37class Mutex;
    3738}
    3839
    3940namespace WebKit {
    4041
    41 class WebThread;
     42class WebCompositorClient;
    4243
    43 class WebCompositorImpl : public WebCompositor {
     44class WebCompositorImpl : public WebCompositor, public WebCore::CCInputHandler {
    4445    WTF_MAKE_NONCOPYABLE(WebCompositorImpl);
    4546public:
    46     static bool initialized();
     47    static WebCompositor* fromIdentifier(int identifier);
     48
     49    static PassOwnPtr<WebCompositorImpl> create(WebCore::CCInputHandlerClient* client)
     50    {
     51        return adoptPtr(new WebCompositorImpl(client));
     52    }
     53
     54    virtual ~WebCompositorImpl();
     55
     56    // WebCompositor implementation
     57    virtual void setClient(WebCompositorClient*);
     58    virtual void handleInputEvent(const WebInputEvent&);
     59
     60    // WebCore::CCInputHandler implementation
     61    virtual int identifier() const;
     62    virtual void willDraw(double frameBeginTime);
    4763
    4864private:
     65    explicit WebCompositorImpl(WebCore::CCInputHandlerClient*);
    4966
    50     friend class WebCompositor;
    51     static void initialize(WebThread* implThread);
    52     static void shutdown();
     67    WebCompositorClient* m_client;
     68    int m_identifier;
     69    WebCore::CCInputHandlerClient* m_inputHandlerClient;
    5370
    54     static bool s_initialized;
    55     static WebCore::CCThread* s_mainThread;
    56     static WebCore::CCThread* s_implThread;
     71    static int s_nextAvailableIdentifier;
     72    static HashSet<WebCompositorImpl*>* s_compositors;
    5773};
    5874

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

    r101440 r101488  
    3232#include "WebKit.h"
    3333
     34#include "CCThreadImpl.h"
     35#include "cc/CCProxy.h"
    3436#include "Logging.h"
    3537#include "Page.h"
    … …  
    9799    // this, initializing this lazily probably doesn't buy us much.
    98100    WebCore::UTF8Encoding();
     101
     102    WebCore::CCProxy::setMainThread(CCThreadImpl::create(webKitPlatformSupport->currentThread()).leakPtr());
    99103}
    100104
    … …  
    102106void shutdown()
    103107{
     108    delete WebCore::CCProxy::mainThread();
     109    WebCore::CCProxy::setMainThread(0);
    104110    s_webKitPlatformSupport = 0;
    105111}

  • trunk/Source/WebKit/chromium/src/WebLayerTreeView.cpp

    r101440 r101488  
    4040    settings.acceleratePainting = acceleratePainting;
    4141    settings.compositeOffscreen = compositeOffscreen;
     42    settings.enableCompositorThread = enableCompositorThread;
    4243    settings.showFPSCounter = showFPSCounter;
    4344    settings.showPlatformLayerTree = showPlatformLayerTree;
    44 
    45     // FIXME: showFPSCounter / showPlatformLayerTree aren't supported currently.
    46     settings.showFPSCounter = false;
    47     settings.showPlatformLayerTree = false;
    4845    return settings;
    4946}
    … …  
    7168void WebLayerTreeView::composite()
    7269{
    73     if (CCProxy::hasImplThread())
     70    if (m_private->settings().enableCompositorThread)
    7471        m_private->setNeedsCommit();
    7572    else

  • trunk/Source/WebKit/chromium/src/WebLayerTreeViewImpl.cpp

    r101440 r101488  
    3636#include "WebSize.h"
    3737#include "WebThread.h"
    38 #include "cc/CCThreadProxy.h"
    3938
    4039using namespace WebCore;
    … …  
    9493
    9594    GraphicsContext3D::RenderStyle style = GraphicsContext3D::RenderDirectlyToHostWindow;
    96     GraphicsContext3DPrivate::ThreadUsage usage = CCProxy::hasImplThread() ? GraphicsContext3DPrivate::ForUseOnAnotherThread : GraphicsContext3DPrivate::ForUseOnThisThread;
     95    GraphicsContext3DPrivate::ThreadUsage usage = settings().enableCompositorThread ? GraphicsContext3DPrivate::ForUseOnAnotherThread : GraphicsContext3DPrivate::ForUseOnThisThread;
    9796    return GraphicsContext3DPrivate::createGraphicsContextFromWebContext(webContext.release(), attributes, 0, style, usage);
    9897}

  • trunk/Source/WebKit/chromium/src/WebSettingsImpl.cpp

    r101440 r101488  
    5151    , m_showFPSCounter(false)
    5252    , m_showPlatformLayerTree(false)
     53    , m_useThreadedCompositor(false)
    5354{
    5455    ASSERT(settings);
    … …  
    379380}
    380381
     382void WebSettingsImpl::setUseThreadedCompositor(bool useThreadedCompositor)
     383{
     384    m_useThreadedCompositor = useThreadedCompositor;
     385}
     386
    381387void WebSettingsImpl::setMemoryInfoEnabled(bool enabled)
    382388{

  • trunk/Source/WebKit/chromium/src/WebSettingsImpl.h

    r101440 r101488  
    110110    virtual void setMinimumAccelerated2dCanvasSize(int);
    111111    virtual void setAcceleratedDrawingEnabled(bool);
     112    virtual void setUseThreadedCompositor(bool);
     113    virtual bool useThreadedCompositor() const { return m_useThreadedCompositor; }
    112114    virtual void setMemoryInfoEnabled(bool);
    113115    virtual void setHyperlinkAuditingEnabled(bool);
    … …  
    131133    bool m_showFPSCounter;
    132134    bool m_showPlatformLayerTree;
     135    bool m_useThreadedCompositor;
    133136};
    134137

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

    r101440 r101488  
    135135#include "WebVector.h"
    136136#include "WebViewClient.h"
    137 #include "cc/CCProxy.h"
     137#include "cc/CCHeadsUpDisplay.h"
    138138#include <wtf/ByteArray.h>
    139139#include <wtf/CurrentTime.h>
    … …  
    11431143        FrameView* view = webframe->frameView();
    11441144        if (view) {
    1145             if (!CCProxy::hasImplThread() && m_layerTreeHost)
     1145            if (!settings()->useThreadedCompositor() && m_layerTreeHost)
    11461146                m_layerTreeHost->setAnimating(true);
    11471147
    11481148            view->serviceScriptedAnimations(convertSecondsToDOMTimeStamp(frameBeginTime));
    11491149
    1150             if (!CCProxy::hasImplThread() && m_layerTreeHost)
     1150            if (!settings()->useThreadedCompositor() && m_layerTreeHost)
    11511151                m_layerTreeHost->setAnimating(false);
    11521152        }
    … …  
    12501250{
    12511251#if USE(ACCELERATED_COMPOSITING)
    1252     if (CCProxy::hasImplThread())
     1252    if (settings()->useThreadedCompositor())
    12531253        m_layerTreeHost->setNeedsRedraw();
    12541254    else {
    … …  
    27762776{
    27772777    if (isAcceleratedCompositingActive()) {
    2778         if (CCProxy::hasImplThread()) {
     2778        if (settings()->useThreadedCompositor()) {
    27792779            ASSERT(m_layerTreeHost);
    27802780            m_layerTreeHost->setNeedsAnimate();
    … …  
    28472847        ccSettings.acceleratePainting = page()->settings()->acceleratedDrawingEnabled();
    28482848        ccSettings.compositeOffscreen = settings()->compositeToTextureEnabled();
     2849        ccSettings.enableCompositorThread = settings()->useThreadedCompositor();
    28492850        ccSettings.showFPSCounter = settings()->showFPSCounter();
    28502851        ccSettings.showPlatformLayerTree = settings()->showPlatformLayerTree();
    … …  
    28832884    RefPtr<GraphicsContext3D> context = m_temporaryOnscreenGraphicsContext3D.release();
    28842885    if (!context) {
    2885         if (CCProxy::hasImplThread())
     2886        if (settings()->useThreadedCompositor())
    28862887            context = GraphicsContext3DPrivate::createGraphicsContextForAnotherThread(getCompositorContextAttributes(), m_page->chrome(), GraphicsContext3D::RenderDirectlyToHostWindow);
    28872888        else
    … …  
    29512952void WebViewImpl::scheduleComposite()
    29522953{
    2953     ASSERT(!CCProxy::hasImplThread());
     2954    ASSERT(!settings()->useThreadedCompositor());
    29542955    m_client->scheduleComposite();
    29552956}
    … …  
    29832984                return webContext;
    29842985        }
    2985         if (CCProxy::hasImplThread())
     2986        if (settings()->useThreadedCompositor())
    29862987            m_temporaryOnscreenGraphicsContext3D = GraphicsContext3DPrivate::createGraphicsContextForAnotherThread(getCompositorContextAttributes(), m_page->chrome(), GraphicsContext3D::RenderDirectlyToHostWindow);
    29872988        else
    … …  
    29932994    return 0;
    29942995}
     2996
    29952997
    29962998void WebViewImpl::setVisibilityState(WebPageVisibilityState visibilityState,

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

    r101440 r101488  
    250250        : m_beginning(false)
    251251        , m_endWhenBeginReturns(false)
    252         , m_timedOut(false) { }
     252        , m_timedOut(false)
     253    {
     254        m_webThread = adoptPtr(webKitPlatformSupport()->createThread("CCLayerTreeHostTest"));
     255        ASSERT(CCProxy::mainThread());
     256
     257        WebCompositor::setThread(m_webThread.get());
     258        ASSERT(CCProxy::isMainThread());
     259        m_mainThreadProxy = CCScopedThreadProxy::create(CCProxy::mainThread());
     260    }
    253261
    254262    void doBeginTest();
    … …  
    264272        webkit_support::QuitMessageLoop();
    265273        webkit_support::RunAllPendingMessages();
     274        CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self);
     275        ASSERT_TRUE(test);
     276        test->m_layerTreeHost.clear();
    266277    }
    267278
    … …  
    352363    virtual void runTest(bool threaded)
    353364    {
     365        m_settings.enableCompositorThread = threaded;
    354366        m_settings.refreshRate = 100.0;
    355 
    356         if (threaded) {
    357             m_webThread = adoptPtr(webKitPlatformSupport()->createThread("CCLayerTreeHostTest"));
    358             WebCompositor::initialize(m_webThread.get());
    359         } else
    360             WebCompositor::initialize(0);
    361 
    362         ASSERT(CCProxy::isMainThread());
    363         m_mainThreadProxy = CCScopedThreadProxy::create(CCProxy::mainThread());
    364 
    365367        webkit_support::PostDelayedTask(CCLayerTreeHostTest::onBeginTest, static_cast<void*>(this), 0);
    366368        m_timeoutTask = new TimeoutTask(this);
    … …  
    369371        webkit_support::RunAllPendingMessages();
    370372
    371         if (m_layerTreeHost && m_layerTreeHost->rootLayer())
    372             m_layerTreeHost->rootLayer()->setLayerTreeHost(0);
    373         m_layerTreeHost.clear();
    374 
    375373        if (m_timeoutTask)
    376374            m_timeoutTask->clearTest();
    … …  
    380378        if (m_timedOut) {
    381379            FAIL() << "Test timed out";
    382             WebCompositor::shutdown();
    383380            return;
    384381        }
     382        m_rootLayer->setLayerTreeHost(0);
    385383        afterTest();
    386         WebCompositor::shutdown();
    387384    }
    388385
    … …  
    396393    bool m_timedOut;
    397394
     395    RefPtr<LayerChromium> m_rootLayer;
    398396    OwnPtr<WebThread> m_webThread;
    399397    RefPtr<CCScopedThreadProxy> m_mainThreadProxy;
    … …  
    406404    m_client = MockLayerTreeHostClient::create(this);
    407405
    408     RefPtr<LayerChromium> rootLayer = LayerChromium::create(0);
    409     m_layerTreeHost = MockLayerTreeHost::create(this, m_client.get(), rootLayer, m_settings);
     406    m_rootLayer = LayerChromium::create(0);
     407    m_layerTreeHost = MockLayerTreeHost::create(this, m_client.get(), m_rootLayer, m_settings);
    410408    ASSERT_TRUE(m_layerTreeHost);
    411     rootLayer->setLayerTreeHost(m_layerTreeHost.get());
     409    m_rootLayer->setLayerTreeHost(m_layerTreeHost.get());
    412410
    413411    m_beginning = true;
    … …  
    448446    virtual void beginTest()
    449447    {
    450         // Kill the layerTreeHost immediately.
    451         m_layerTreeHost->rootLayer()->setLayerTreeHost(0);
    452         m_layerTreeHost.clear();
    453 
    454448        endTest();
    455449    }
    … …  
    480474    {
    481475        postSetNeedsCommitToMainThread();
    482 
    483         // Kill the layerTreeHost immediately.
    484         m_layerTreeHost->rootLayer()->setLayerTreeHost(0);
    485         m_layerTreeHost.clear();
    486 
    487476        endTest();
    488477    }
    … …  
    503492    {
    504493        postSetNeedsRedrawToMainThread();
    505 
    506         // Kill the layerTreeHost immediately.
    507         m_layerTreeHost->rootLayer()->setLayerTreeHost(0);
    508         m_layerTreeHost.clear();
    509 
    510494        endTest();
    511495    }
    … …  
    518502SINGLE_AND_MULTI_THREAD_TEST_F(CCLayerTreeHostTestShortlived3)
    519503
    520 // Test interleaving of redraws and commits
    521 class CCLayerTreeHostTestCommitingWithContinuousRedraw : public CCLayerTreeHostTestThreadOnly {
     504// Constantly redrawing layerTreeHosts shouldn't die when they commit
     505class CCLayerTreeHostTestCommitingWithContinuousRedraw : public CCLayerTreeHostTest {
    522506public:
    523507    CCLayerTreeHostTestCommitingWithContinuousRedraw()
    … …  
    530514    {
    531515        postSetNeedsCommitToMainThread();
     516        endTest();
    532517    }
    533518
    … …  
    556541};
    557542
    558 TEST_F(CCLayerTreeHostTestCommitingWithContinuousRedraw, runMultiThread)
    559 {
    560     runTestThreaded();
    561 }
     543SINGLE_AND_MULTI_THREAD_TEST_F(CCLayerTreeHostTestCommitingWithContinuousRedraw)
    562544
    563545// Two setNeedsCommits in a row should lead to at least 1 commit and at least 1
    … …  
    1010992        EXPECT_EQ(m_updateCheckLayer->paintContentsCount(),
    1011993                  m_updateCheckLayer->updateCount());
    1012 
    1013         // clear m_updateCheckLayer so CCLayerTreeHost dies.
    1014         m_updateCheckLayer.clear();
    1015994    }
    1016995

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

    r101487 r101488  
    2626#include "config.h"
    2727
    28 #include "WebCompositorInputHandlerImpl.h"
     28#include "WebCompositorImpl.h"
    2929
    30 #include "WebCompositor.h"
    3130#include "cc/CCSingleThreadProxy.h"
    3231
    … …  
    3433#include <wtf/OwnPtr.h>
    3534
    36 using WebKit::WebCompositorInputHandler;
    37 using WebKit::WebCompositorInputHandlerImpl;
     35using WebKit::WebCompositor;
     36using WebKit::WebCompositorImpl;
    3837
    3938namespace {
    4039
    41 TEST(WebCompositorInputHandlerImpl, fromIdentifier)
     40TEST(WebCompositorImpl, fromIdentifier)
    4241{
    43     WebKit::WebCompositor::initialize(0);
    4442#ifndef NDEBUG
    45     // WebCompositorInputHandler APIs can only be called from the compositor thread.
     43    // WebCompositor APIs can only be called from the compositor thread.
    4644    WebCore::DebugScopedSetImplThread alwaysImplThread;
    4745#endif
    4846
    49     // Before creating any WebCompositorInputHandlers, lookups for any value should fail and not crash.
    50     EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(2));
    51     EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(0));
    52     EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(-1));
     47    // Before creating any WebCompositors, lookups for any value should fail and not crash.
     48    EXPECT_EQ(0, WebCompositor::fromIdentifier(2));
     49    EXPECT_EQ(0, WebCompositor::fromIdentifier(0));
     50    EXPECT_EQ(0, WebCompositor::fromIdentifier(-1));
    5351
    5452    int compositorIdentifier = -1;
    5553    {
    56         OwnPtr<WebCompositorInputHandlerImpl> comp = WebCompositorInputHandlerImpl::create(0);
     54        OwnPtr<WebCompositorImpl> comp = WebCompositorImpl::create(0);
    5755        compositorIdentifier = comp->identifier();
    5856        // The compositor we just created should be locatable.
    59         EXPECT_EQ(comp.get(), WebCompositorInputHandler::fromIdentifier(compositorIdentifier));
     57        EXPECT_EQ(comp.get(), WebCompositor::fromIdentifier(compositorIdentifier));
    6058
    6159        // But nothing else.
    62         EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(comp->identifier() + 10));
     60        EXPECT_EQ(0, WebCompositor::fromIdentifier(comp->identifier() + 10));
    6361    }
    6462
    6563    // After the compositor is destroyed, its entry should be removed from the map.
    66     EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(compositorIdentifier));
    67 
    68     WebKit::WebCompositor::shutdown();
     64    EXPECT_EQ(0, WebCompositor::fromIdentifier(compositorIdentifier));
    6965}
    7066

  • trunk/Tools/ChangeLog

    r101464 r101488  
     12011-11-30  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r101440 and r101442.
     4        http://trac.webkit.org/changeset/101440
     5        http://trac.webkit.org/changeset/101442
     6        https://bugs.webkit.org/show_bug.cgi?id=73429
     7
     8        multiple crashes on layout tests (Requested by hayato on
     9        #webkit).
     10
     11        * DumpRenderTree/chromium/TestShell.cpp:
     12        (TestShell::resetWebSettings):
     13        * DumpRenderTree/chromium/TestShell.h:
     14        * DumpRenderTree/chromium/WebPreferences.cpp:
     15        (WebPreferences::reset):
     16        (WebPreferences::applyTo):
     17        * DumpRenderTree/chromium/WebPreferences.h:
     18        * DumpRenderTree/chromium/WebViewHost.cpp:
     19        (WebViewHost::WebViewHost):
     20        (WebViewHost::~WebViewHost):
     21
    1222011-11-30  Fady Samuel  <fsamuel@chromium.org>
    223

  • trunk/Tools/DumpRenderTree/chromium/TestShell.cpp

    r101440 r101488  
    202202    m_prefs.acceleratedCompositingEnabled = true;
    203203    m_prefs.acceleratedCompositingForVideoEnabled = m_acceleratedCompositingForVideoEnabled;
     204    m_prefs.threadedCompositingEnabled = m_threadedCompositingEnabled;
    204205    m_prefs.compositeToTexture = m_compositeToTexture;
    205206    m_prefs.forceCompositingMode = m_forceCompositingMode;

  • trunk/Tools/DumpRenderTree/chromium/TestShell.h

    r101440 r101488  
    133133    void setAcceleratedCompositingForVideoEnabled(bool enabled) { m_acceleratedCompositingForVideoEnabled = enabled; }
    134134    void setThreadedCompositingEnabled(bool enabled) { m_threadedCompositingEnabled = enabled; }
    135     bool threadedCompositingEnabled() const { return m_threadedCompositingEnabled; }
    136135    void setCompositeToTexture(bool enabled) { m_compositeToTexture = enabled; }
    137136    void setForceCompositingMode(bool enabled) { m_forceCompositingMode = enabled; }

  • trunk/Tools/DumpRenderTree/chromium/WebPreferences.cpp

    r101440 r101488  
    110110    acceleratedCompositingForVideoEnabled = false;
    111111    acceleratedCompositingEnabled = false;
     112    threadedCompositingEnabled = false;
    112113    compositeToTexture = false;
    113114    accelerated2dCanvasEnabled = false;
    … …  
    213214    settings->setAcceleratedCompositingEnabled(acceleratedCompositingEnabled);
    214215    settings->setAcceleratedCompositingForVideoEnabled(acceleratedCompositingForVideoEnabled);
     216    settings->setUseThreadedCompositor(threadedCompositingEnabled);
    215217    settings->setCompositeToTextureEnabled(compositeToTexture);
    216218    settings->setForceCompositingMode(forceCompositingMode);

  • trunk/Tools/DumpRenderTree/chromium/WebPreferences.h

    r101440 r101488  
    103103    bool acceleratedCompositingForVideoEnabled;
    104104    bool acceleratedCompositingEnabled;
     105    bool threadedCompositingEnabled;
    105106    bool compositeToTexture;
    106107    bool forceCompositingMode;

  • trunk/Tools/DumpRenderTree/chromium/WebViewHost.cpp

    r101440 r101488  
    12121212    WTF::initializeThreading();
    12131213
    1214     if (shell->threadedCompositingEnabled()) {
    1215         m_compositorThread = adoptPtr(WebKit::webKitPlatformSupport()->createThread("Compositor"));
    1216         WebCompositor::initialize(m_compositorThread.get());
    1217     } else
    1218         WebCompositor::initialize(0);
     1214    m_compositorThread = adoptPtr(WebKit::webKitPlatformSupport()->createThread("Compositor"));
     1215    WebCompositor::setThread(m_compositorThread.get());
    12191216
    12201217    reset();
    … …  
    12381235    if (m_inModalLoop)
    12391236        webkit_support::QuitMessageLoop();
    1240 
    1241     WebCompositor::shutdown();
    12421237}
    12431238
Note: See TracChangeset for help on using the changeset viewer.