Remove static thread pointers from CC

cc/thread_proxy.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 "cc/thread_proxy.h"
 
 #include "CCDelayBasedTimeSource.h"
 #include "CCDrawQuad.h"
 #include "CCFrameRateController.h"
 #include "CCGraphicsContext.h"
 #include "base/debug/trace_event.h"
 #include "cc/input_handler.h"
 #include "cc/layer_tree_host.h"
 #include "cc/scheduler.h"
 #include "cc/scoped_thread_proxy.h"
+#include "cc/thread.h"
 #include "cc/thread_task.h"
 #include <public/WebSharedGraphicsContext3D.h>
 #include <wtf/CurrentTime.h>
 
 using WebKit::WebSharedGraphicsContext3D;
 
 namespace {
 
 // Measured in seconds.
 const double contextRecreationTickRate = 0.03;
 
 }  // namespace
 
 namespace cc {
 
-scoped_ptr<Proxy> ThreadProxy::create(LayerTreeHost* layerTreeHost)
+scoped_ptr<Proxy> ThreadProxy::create(LayerTreeHost* layerTreeHost, Thread* implThread)
 {
-    return make_scoped_ptr(new ThreadProxy(layerTreeHost)).PassAs<Proxy>();
+    return make_scoped_ptr(new ThreadProxy(layerTreeHost, implThread)).PassAs<Proxy>();
 }
 
-ThreadProxy::ThreadProxy(LayerTreeHost* layerTreeHost)
-    : m_animateRequested(false)
+ThreadProxy::ThreadProxy(LayerTreeHost* layerTreeHost, Thread* implThread)
+    : Proxy(implThread)
+    , m_animateRequested(false)
     , m_commitRequested(false)
     , m_commitRequestSentToImplThread(false)
     , m_forcedCommitRequested(false)
     , m_layerTreeHost(layerTreeHost)
     , m_rendererInitialized(false)
     , m_started(false)
     , m_texturesAcquired(true)
     , m_inCompositeAndReadback(false)
     , m_mainThreadProxy(ScopedThreadProxy::create(Proxy::mainThread()))
     , m_beginFrameCompletionEventOnImplThread(0)
@@ skipping 22 matching lines @@
     DCHECK(m_layerTreeHost);
 
     if (!m_layerTreeHost->initializeRendererIfNeeded()) {
         TRACE_EVENT0("cc", "compositeAndReadback_EarlyOut_LR_Uninitialized");
         return false;
     }
 
 
     // Perform a synchronous commit.
     {
-        DebugScopedSetMainThreadBlocked mainThreadBlocked;
+        DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
         CompletionEvent beginFrameCompletion;
         Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::forceBeginFrameOnImplThread, &beginFrameCompletion));
         beginFrameCompletion.wait();
     }
     m_inCompositeAndReadback = true;
     beginFrame();
     m_inCompositeAndReadback = false;
 
     // Perform a synchronous readback.
     ReadbackRequest request;
     request.rect = rect;
     request.pixels = pixels;
     {
-        DebugScopedSetMainThreadBlocked mainThreadBlocked;
+        DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
         Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::requestReadbackOnImplThread, &request));
         request.completion.wait();
     }
     return request.success;
 }
 
 void ThreadProxy::requestReadbackOnImplThread(ReadbackRequest* request)
 {
     DCHECK(Proxy::isImplThread());
     DCHECK(!m_readbackRequestOnImplThread);
@@ skipping 19 matching lines @@
     DCHECK(Proxy::isImplThread());
     if (m_layerTreeHostImpl.get())
         m_layerTreeHostImpl->startPageScaleAnimation(targetPosition, useAnchor, scale, monotonicallyIncreasingTime(), duration);
 }
 
 void ThreadProxy::finishAllRendering()
 {
     DCHECK(Proxy::isMainThread());
 
     // Make sure all GL drawing is finished on the impl thread.
-    DebugScopedSetMainThreadBlocked mainThreadBlocked;
+    DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     CompletionEvent completion;
     Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::finishAllRenderingOnImplThread, &completion));
     completion.wait();
 }
 
 bool ThreadProxy::isStarted() const
 {
     DCHECK(Proxy::isMainThread());
     return m_started;
 }
@@ skipping 18 matching lines @@
 
 void ThreadProxy::setSurfaceReadyOnImplThread()
 {
     TRACE_EVENT0("cc", "ThreadProxy::setSurfaceReadyOnImplThread");
     m_schedulerOnImplThread->setCanBeginFrame(true);
 }
 
 void ThreadProxy::setVisible(bool visible)
 {
     TRACE_EVENT0("cc", "ThreadProxy::setVisible");
-    DebugScopedSetMainThreadBlocked mainThreadBlocked;
+    DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     CompletionEvent completion;
     Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::setVisibleOnImplThread, &completion, visible));
     completion.wait();
 }
 
 void ThreadProxy::setVisibleOnImplThread(CompletionEvent* completion, bool visible)
 {
     TRACE_EVENT0("cc", "ThreadProxy::setVisibleOnImplThread");
     m_layerTreeHostImpl->setVisible(visible);
     m_schedulerOnImplThread->setVisible(visible);
     completion->signal();
 }
 
 bool ThreadProxy::initializeRenderer()
 {
     TRACE_EVENT0("cc", "ThreadProxy::initializeRenderer");
     // Make a blocking call to initializeRendererOnImplThread. The results of that call
     // are pushed into the initializeSucceeded and capabilities local variables.
     CompletionEvent completion;
     bool initializeSucceeded = false;
     RendererCapabilities capabilities;
-    DebugScopedSetMainThreadBlocked mainThreadBlocked;
+    DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::initializeRendererOnImplThread,
                                                        &completion,
                                                        &initializeSucceeded,
                                                        &capabilities));
     completion.wait();
 
     if (initializeSucceeded) {
         m_rendererInitialized = true;
         m_RendererCapabilitiesMainThreadCopy = capabilities;
     }
@@ skipping 12 matching lines @@
     if (m_layerTreeHost->needsSharedContext())
         if (!WebSharedGraphicsContext3D::createCompositorThreadContext())
             return false;
 
     // Make a blocking call to recreateContextOnImplThread. The results of that
     // call are pushed into the recreateSucceeded and capabilities local
     // variables.
     CompletionEvent completion;
     bool recreateSucceeded = false;
     RendererCapabilities capabilities;
-    DebugScopedSetMainThreadBlocked mainThreadBlocked;
+    DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::recreateContextOnImplThread,
                                                        &completion,
                                                        context.release(),
                                                        &recreateSucceeded,
                                                        &capabilities));
     completion.wait();
 
     if (recreateSucceeded)
         m_RendererCapabilitiesMainThreadCopy = capabilities;
     return recreateSucceeded;
 }
 
 void ThreadProxy::renderingStats(RenderingStats* stats)
 {
     DCHECK(isMainThread());
 
-    DebugScopedSetMainThreadBlocked mainThreadBlocked;
+    DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     CompletionEvent completion;
     Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::renderingStatsOnImplThread,
                                                        &completion,
                                                        stats));
     stats->totalCommitTimeInSeconds = m_totalCommitTime.InSecondsF();
     stats->totalCommitCount = m_totalCommitCount;
 
     completion.wait();
 }
 
@@ skipping 126 matching lines @@
     DCHECK(isImplThread());
     TRACE_EVENT0("cc", "ThreadProxy::setNeedsRedrawOnImplThread");
     m_schedulerOnImplThread->setNeedsRedraw();
 }
 
 void ThreadProxy::start()
 {
     DCHECK(isMainThread());
     DCHECK(Proxy::implThread());
     // Create LayerTreeHostImpl.
-    DebugScopedSetMainThreadBlocked mainThreadBlocked;
+    DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     CompletionEvent completion;
     scoped_ptr<InputHandler> handler = m_layerTreeHost->createInputHandler();
     Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::initializeImplOnImplThread, &completion, handler.release()));
     completion.wait();
 
     m_started = true;
 }
 
 void ThreadProxy::stop()
 {
     TRACE_EVENT0("cc", "ThreadProxy::stop");
     DCHECK(isMainThread());
     DCHECK(m_started);
 
     // Synchronously deletes the impl.
     {
-        DebugScopedSetMainThreadBlocked mainThreadBlocked;
+        DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
 
         CompletionEvent completion;
         Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::layerTreeHostClosedOnImplThread, &completion));
         completion.wait();
     }
 
     m_mainThreadProxy->shutdown(); // Stop running tasks posted to us.
 
     DCHECK(!m_layerTreeHostImpl.get()); // verify that the impl deleted.
     m_layerTreeHost = 0;
     m_started = false;
 }
 
 void ThreadProxy::forceSerializeOnSwapBuffers()
 {
-    DebugScopedSetMainThreadBlocked mainThreadBlocked;
+    DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     CompletionEvent completion;
     Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::forceSerializeOnSwapBuffersOnImplThread, &completion));
     completion.wait();
 }
 
 void ThreadProxy::forceSerializeOnSwapBuffersOnImplThread(CompletionEvent* completion)
 {
     if (m_rendererInitialized)
         m_layerTreeHostImpl->renderer()->doNoOp();
     completion->signal();
@@ skipping 125 matching lines @@
         setNeedsAnimate();
     }
 
     // Notify the impl thread that the beginFrame has completed. This will
     // begin the commit process, which is blocking from the main thread's
     // point of view, but asynchronously performed on the impl thread,
     // coordinated by the Scheduler.
     {
         TRACE_EVENT0("cc", "commit");
 
-        DebugScopedSetMainThreadBlocked mainThreadBlocked;
+        DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
 
         base::TimeTicks startTime = base::TimeTicks::HighResNow();
         CompletionEvent completion;
         Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::beginFrameCompleteOnImplThread, &completion, queue.release()));
         completion.wait();
         base::TimeTicks endTime = base::TimeTicks::HighResNow();
 
         m_totalCommitTime += endTime - startTime;
         m_totalCommitCount++;
     }
@@ skipping 22 matching lines @@
         // Clear any uploads we were making to textures linked to evicted
         // resources
         queue->clearUploadsToEvictedResources();
         // Some textures in the layer tree are invalid. Kick off another commit
         // to fill them again.
         setNeedsCommitOnImplThread();
     }
 
     m_layerTreeHost->contentsTextureManager()->pushTexturePrioritiesToBackings();
 
-    m_currentTextureUpdateControllerOnImplThread = TextureUpdateController::create(this, Proxy::implThread(), queue.Pass(), m_layerTreeHostImpl->resourceProvider());
+    m_currentTextureUpdateControllerOnImplThread = TextureUpdateController::create(this, Proxy::implThread(), queue.Pass(), m_layerTreeHostImpl->resourceProvider(), hasImplThread());
     m_currentTextureUpdateControllerOnImplThread->performMoreUpdates(
         m_schedulerOnImplThread->anticipatedDrawTime());
 
     m_commitCompletionEventOnImplThread = completion;
 }
 
 void ThreadProxy::beginFrameAbortedOnImplThread()
 {
     TRACE_EVENT0("cc", "ThreadProxy::beginFrameAbortedOnImplThread");
     DCHECK(isImplThread());
@@ skipping 111 matching lines @@
     // directly by the compositor.
     // This method will block until the next compositor draw if there is a
     // previously committed frame that is still undrawn. This is necessary to
     // ensure that the main thread does not monopolize access to the textures.
     DCHECK(isMainThread());
 
     if (m_texturesAcquired)
         return;
 
     TRACE_EVENT0("cc", "ThreadProxy::acquireLayerTextures");
-    DebugScopedSetMainThreadBlocked mainThreadBlocked;
+    DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     CompletionEvent completion;
     Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::acquireLayerTexturesForMainThreadOnImplThread, &completion));
     completion.wait(); // Block until it is safe to write to layer textures from the main thread.
 
     m_texturesAcquired = true;
 }
 
 void ThreadProxy::acquireLayerTexturesForMainThreadOnImplThread(CompletionEvent* completion)
 {
     DCHECK(isImplThread());
@@ skipping 65 matching lines @@
 public:
     static scoped_ptr<ThreadProxyContextRecreationTimer> create(ThreadProxy* proxy) { return make_scoped_ptr(new ThreadProxyContextRecreationTimer(proxy)); }
 
     virtual void onTimerFired() OVERRIDE
     {
         m_proxy->tryToRecreateContext();
     }
 
 private:
     explicit ThreadProxyContextRecreationTimer(ThreadProxy* proxy)
-        : Timer(Proxy::mainThread(), this)
+        : Timer(proxy->mainThread(), this)
         , m_proxy(proxy)
     {
     }
 
     ThreadProxy* m_proxy;
 };
 
 void ThreadProxy::beginContextRecreation()
 {
     TRACE_EVENT0("cc", "ThreadProxy::beginContextRecreation");
@@ skipping 103 matching lines @@
 ThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState()
     : monotonicFrameBeginTime(0)
 {
 }
 
 ThreadProxy::BeginFrameAndCommitState::~BeginFrameAndCommitState()
 {
 }
 
 }  // namespace cc