Remove static thread pointers from CC

cc/test/layer_tree_test_common.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "CCThreadedTest.h"
 
 #include "CCActiveAnimation.h"
 #include "base/stl_util.h"
 #include "cc/content_layer.h"
 #include "cc/input_handler.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/scoped_thread_proxy.h"
 #include "cc/settings.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_web_compositor_output_surface.h"
 #include "cc/test/fake_web_graphics_context_3d.h"
 #include "cc/test/occlusion_tracker_test_common.h"
 #include "cc/test/test_common.h"
 #include "cc/test/tiled_layer_test_common.h"
 #include "cc/thread_task.h"
 #include "cc/timing_function.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "webkit/compositor_bindings/ccthread_impl.h"
 #include <public/Platform.h>
 #include <public/WebCompositorSupport.h>
 #include <public/WebFilterOperation.h>
 #include <public/WebFilterOperations.h>
 #include <public/WebThread.h>
 
 using namespace cc;
 using namespace WebKit;
 
 namespace WebKitTests {
@@ skipping 48 matching lines @@
 bool TestHooks::prepareToDrawOnThread(cc::LayerTreeHostImpl*)
 {
     return true;
 }
 
 scoped_ptr<WebCompositorOutputSurface> TestHooks::createOutputSurface()
 {
     return FakeWebCompositorOutputSurface::create(CompositorFakeWebGraphicsContext3DWithTextureTracking::create(WebGraphicsContext3D::Attributes()).PassAs<WebKit::WebGraphicsContext3D>()).PassAs<WebKit::WebCompositorOutputSurface>();
 }
 
-scoped_ptr<MockLayerTreeHostImpl> MockLayerTreeHostImpl::create(TestHooks* testHooks, const LayerTreeSettings& settings, LayerTreeHostImplClient* client)
+scoped_ptr<MockLayerTreeHostImpl> MockLayerTreeHostImpl::create(TestHooks* testHooks, const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
 {
-    return make_scoped_ptr(new MockLayerTreeHostImpl(testHooks, settings, client));
+    return make_scoped_ptr(new MockLayerTreeHostImpl(testHooks, settings, client, proxy));
 }
 
 void MockLayerTreeHostImpl::beginCommit()
 {
     LayerTreeHostImpl::beginCommit();
     m_testHooks->beginCommitOnThread(this);
 }
 
 void MockLayerTreeHostImpl::commitComplete()
 {
@@ skipping 20 matching lines @@
     m_testHooks->willAnimateLayers(this, monotonicTime);
     LayerTreeHostImpl::animateLayers(monotonicTime, wallClockTime);
     m_testHooks->animateLayers(this, monotonicTime);
 }
 
 base::TimeDelta MockLayerTreeHostImpl::lowFrequencyAnimationInterval() const
 {
     return base::TimeDelta::FromMilliseconds(16);
 }
 
-MockLayerTreeHostImpl::MockLayerTreeHostImpl(TestHooks* testHooks, const LayerTreeSettings& settings, LayerTreeHostImplClient* client)
-    : LayerTreeHostImpl(settings, client)
+MockLayerTreeHostImpl::MockLayerTreeHostImpl(TestHooks* testHooks, const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
+    : LayerTreeHostImpl(settings, client, proxy)
     , m_testHooks(testHooks)
 {
 }
 
 // Adapts LayerTreeHost for test. Injects MockLayerTreeHostImpl.
 class MockLayerTreeHost : public cc::LayerTreeHost {
 public:
-    static scoped_ptr<MockLayerTreeHost> create(TestHooks* testHooks, cc::LayerTreeHostClient* client, scoped_refptr<cc::Layer> rootLayer, const cc::LayerTreeSettings& settings)
+    static scoped_ptr<MockLayerTreeHost> create(TestHooks* testHooks, cc::LayerTreeHostClient* client, scoped_refptr<cc::Layer> rootLayer, const cc::LayerTreeSettings& settings, cc::Thread* implThread)
     {
         scoped_ptr<MockLayerTreeHost> layerTreeHost(new MockLayerTreeHost(testHooks, client, settings));
-        bool success = layerTreeHost->initialize();
+        bool success = layerTreeHost->initialize(implThread);
         EXPECT_TRUE(success);
         layerTreeHost->setRootLayer(rootLayer);
 
         // LayerTreeHostImpl won't draw if it has 1x1 viewport.
         layerTreeHost->setViewportSize(IntSize(1, 1), IntSize(1, 1));
 
         layerTreeHost->rootLayer()->setLayerAnimationDelegate(testHooks);
 
         return layerTreeHost.Pass();
     }
 
     virtual scoped_ptr<cc::LayerTreeHostImpl> createLayerTreeHostImpl(cc::LayerTreeHostImplClient* client)
     {
-        return MockLayerTreeHostImpl::create(m_testHooks, settings(), client).PassAs<cc::LayerTreeHostImpl>();
+        return MockLayerTreeHostImpl::create(m_testHooks, settings(), client, proxy()).PassAs<cc::LayerTreeHostImpl>();
     }
 
     virtual void didAddAnimation() OVERRIDE
     {
         LayerTreeHost::didAddAnimation();
         m_testHooks->didAddAnimation();
     }
 
     virtual void setNeedsCommit() OVERRIDE
     {
@@ skipping 135 matching lines @@
     ThreadedTest* m_test;
 };
 
 ThreadedTest::ThreadedTest()
     : m_beginning(false)
     , m_endWhenBeginReturns(false)
     , m_timedOut(false)
     , m_finished(false)
     , m_scheduled(false)
     , m_started(false)
+    , m_implThread(0)
 {
 }
 
 ThreadedTest::~ThreadedTest()
 {
 }
 
 void ThreadedTest::endTest()
 {
     m_finished = true;
@@ skipping 51 matching lines @@
     m_mainThreadProxy->postTask(createThreadTask(this, &ThreadedTest::dispatchSetVisible, visible));
 }
 
 void ThreadedTest::postDidAddAnimationToMainThread()
 {
     m_mainThreadProxy->postTask(createThreadTask(this, &ThreadedTest::dispatchDidAddAnimation));
 }
 
 void ThreadedTest::doBeginTest()
 {
-    DCHECK(Proxy::isMainThread());

[danakj, 2012/10/25 05:06:06]

Why not call proxy()->isMainThread() etc for all these checks in this file?

     m_client = ThreadedMockLayerTreeHostClient::create(this);
 
     scoped_refptr<Layer> rootLayer = Layer::create();
-    m_layerTreeHost = MockLayerTreeHost::create(this, m_client.get(), rootLayer, m_settings);
+    m_layerTreeHost = MockLayerTreeHost::create(this, m_client.get(), rootLayer, m_settings, m_implThread);
     ASSERT_TRUE(m_layerTreeHost.get());
     rootLayer->setLayerTreeHost(m_layerTreeHost.get());
     m_layerTreeHost->setSurfaceReady();
 
     m_started = true;
     m_beginning = true;
     beginTest();
     m_beginning = false;
     if (m_endWhenBeginReturns)
         realEndTest();
@@ skipping 13 matching lines @@
 void ThreadedTest::scheduleComposite()
 {
     if (!m_started || m_scheduled || m_finished)
         return;
     m_scheduled = true;
     m_mainThreadProxy->postTask(createThreadTask(this, &ThreadedTest::dispatchComposite));
 }
 
 void ThreadedTest::realEndTest()
 {
-    DCHECK(Proxy::isMainThread());
     WebKit::Platform::current()->currentThread()->exitRunLoop();
 }
 
 void ThreadedTest::dispatchSetNeedsAnimate()
 {
-    DCHECK(Proxy::isMainThread());
-
     if (m_finished)
         return;
 
     if (m_layerTreeHost.get())
         m_layerTreeHost->setNeedsAnimate();
 }
 
 void ThreadedTest::dispatchAddInstantAnimation()
 {
-    DCHECK(Proxy::isMainThread());
-
     if (m_finished)
         return;
 
     if (m_layerTreeHost.get() && m_layerTreeHost->rootLayer())
         addOpacityTransitionToLayer(*m_layerTreeHost->rootLayer(), 0, 0, 0.5, false);
 }
 
 void ThreadedTest::dispatchAddAnimation()
 {
-    DCHECK(Proxy::isMainThread());
-
     if (m_finished)
         return;
 
     if (m_layerTreeHost.get() && m_layerTreeHost->rootLayer())
         addOpacityTransitionToLayer(*m_layerTreeHost->rootLayer(), 10, 0, 0.5, true);
 }
 
 void ThreadedTest::dispatchSetNeedsAnimateAndCommit()
 {
-    DCHECK(Proxy::isMainThread());
-
     if (m_finished)
         return;
 
     if (m_layerTreeHost.get()) {
         m_layerTreeHost->setNeedsAnimate();
         m_layerTreeHost->setNeedsCommit();
     }
 }
 
 void ThreadedTest::dispatchSetNeedsCommit()
 {
-    DCHECK(Proxy::isMainThread());
-
     if (m_finished)
         return;
 
     if (m_layerTreeHost.get())
         m_layerTreeHost->setNeedsCommit();
 }
 
 void ThreadedTest::dispatchAcquireLayerTextures()
 {
-    DCHECK(Proxy::isMainThread());
-
     if (m_finished)
         return;
 
     if (m_layerTreeHost.get())
         m_layerTreeHost->acquireLayerTextures();
 }
 
 void ThreadedTest::dispatchSetNeedsRedraw()
 {
-    DCHECK(Proxy::isMainThread());
-
     if (m_finished)
         return;
 
     if (m_layerTreeHost.get())
         m_layerTreeHost->setNeedsRedraw();
 }
 
 void ThreadedTest::dispatchSetVisible(bool visible)
 {
-    DCHECK(Proxy::isMainThread());
-
     if (m_finished)
         return;
 
     if (m_layerTreeHost.get())
         m_layerTreeHost->setVisible(visible);
 }
 
 void ThreadedTest::dispatchComposite()
 {
     m_scheduled = false;
     if (m_layerTreeHost.get() && !m_finished)
         m_layerTreeHost->composite();
 }
 
 void ThreadedTest::dispatchDidAddAnimation()
 {
-    DCHECK(Proxy::isMainThread());
-
     if (m_finished)
         return;
 
     if (m_layerTreeHost.get())
         m_layerTreeHost->didAddAnimation();
 }
 
 void ThreadedTest::runTest(bool threaded)
 {
     // For these tests, we will enable threaded animations.
     ScopedSettings scopedSettings;
     Settings::setAcceleratedAnimationEnabled(true);
 
     if (threaded) {
-        m_webThread.reset(WebKit::Platform::current()->createThread("ThreadedTest"));
-        Platform::current()->compositorSupport()->initialize(m_webThread.get());
-    } else
-        Platform::current()->compositorSupport()->initialize(0);
+        m_webImplThread.reset(WebKit::Platform::current()->createThread("ThreadedTest"));
+        m_implThread = CCThreadImpl::createForDifferentThread(m_webImplThread.get()).release();
+    }
 
-    DCHECK(Proxy::isMainThread());
-    m_mainThreadProxy = ScopedThreadProxy::create(Proxy::mainThread());
+    m_mainThreadProxy = ScopedThreadProxy::create(WebKit::CCThreadImpl::createForCurrentThread().release());
 
     initializeSettings(m_settings);
 
     m_beginTask = new BeginTask(this);
     WebKit::Platform::current()->currentThread()->postDelayedTask(m_beginTask, 0); // postDelayedTask takes ownership of the task
     m_timeoutTask = new TimeoutTask(this);
     WebKit::Platform::current()->currentThread()->postDelayedTask(m_timeoutTask, 5000);
     WebKit::Platform::current()->currentThread()->enterRunLoop();
 
     if (m_layerTreeHost.get() && m_layerTreeHost->rootLayer())
         m_layerTreeHost->rootLayer()->setLayerTreeHost(0);
     m_layerTreeHost.reset();
 
     if (m_timeoutTask)
         m_timeoutTask->clearTest();
 
     ASSERT_FALSE(m_layerTreeHost.get());
     m_client.reset();
     if (m_timedOut) {
         FAIL() << "Test timed out";
-        Platform::current()->compositorSupport()->shutdown();
         return;
     }
     afterTest();
-    Platform::current()->compositorSupport()->shutdown();
 }
 
 }  // namespace WebKitTests