Remove static thread pointers from CC

cc/layer_tree_host.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/layer_tree_host.h"
 
 #include "Region.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "cc/font_atlas.h"
 #include "cc/graphics_context.h"
 #include "cc/heads_up_display_layer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_tree_host_client.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/math_util.h"
 #include "cc/occlusion_tracker.h"
 #include "cc/overdraw_metrics.h"
 #include "cc/settings.h"
 #include "cc/single_thread_proxy.h"
+#include "cc/thread.h"
 #include "cc/thread_proxy.h"
 #include "cc/tree_synchronizer.h"
 
 using namespace std;
 
 namespace {
 static int numLayerTreeInstances;
 }
 
 namespace cc {
@@ skipping 39 matching lines @@
 
 RendererCapabilities::~RendererCapabilities()
 {
 }
 
 bool LayerTreeHost::anyLayerTreeHostInstanceExists()
 {
     return numLayerTreeInstances > 0;
 }
 
-scoped_ptr<LayerTreeHost> LayerTreeHost::create(LayerTreeHostClient* client, const LayerTreeSettings& settings)
+scoped_ptr<LayerTreeHost> LayerTreeHost::create(LayerTreeHostClient* client, const LayerTreeSettings& settings, scoped_ptr<Thread> implThread)
 {
     scoped_ptr<LayerTreeHost> layerTreeHost(new LayerTreeHost(client, settings));
-    if (!layerTreeHost->initialize())
+    if (!layerTreeHost->initialize(implThread.Pass()))
         return scoped_ptr<LayerTreeHost>();
     return layerTreeHost.Pass();
 }
 
 LayerTreeHost::LayerTreeHost(LayerTreeHostClient* client, const LayerTreeSettings& settings)
     : m_animating(false)
     , m_needsAnimateLayers(false)
     , m_client(client)
     , m_commitNumber(0)
     , m_renderingStats()
     , m_rendererInitialized(false)
     , m_contextLost(false)
     , m_numTimesRecreateShouldFail(0)
     , m_numFailedRecreateAttempts(0)
     , m_settings(settings)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_pageScaleFactor(1)
     , m_minPageScaleFactor(1)
     , m_maxPageScaleFactor(1)
     , m_triggerIdleUpdates(true)
     , m_backgroundColor(SK_ColorWHITE)
     , m_hasTransparentBackground(false)
     , m_partialTextureUpdateRequests(0)
 {
-    DCHECK(Proxy::isMainThread());
     numLayerTreeInstances++;
 }
 
-bool LayerTreeHost::initialize()
+bool LayerTreeHost::initialize(scoped_ptr<Thread> implThread)
 {
     TRACE_EVENT0("cc", "LayerTreeHost::initialize");
 
-    if (Proxy::hasImplThread())
-        m_proxy = ThreadProxy::create(this);
+    if (implThread)
+        m_proxy = ThreadProxy::create(this, implThread.Pass());
     else
         m_proxy = SingleThreadProxy::create(this);
     m_proxy->start();
 
     return m_proxy->initializeContext();
 }
 
 LayerTreeHost::~LayerTreeHost()
 {
     if (m_rootLayer)
         m_rootLayer->setLayerTreeHost(0);
-    DCHECK(Proxy::isMainThread());
+    DCHECK(m_proxy);
+    DCHECK(m_proxy->isMainThread());
     TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
-    DCHECK(m_proxy.get());
     m_proxy->stop();
-    m_proxy.reset();
     numLayerTreeInstances--;
     RateLimiterMap::iterator it = m_rateLimiters.begin();
     if (it != m_rateLimiters.end())
         it->second->stop();
 }
 
 void LayerTreeHost::setSurfaceReady()
 {
     m_proxy->setSurfaceReady();
 }
 
 void LayerTreeHost::initializeRenderer()
 {
     TRACE_EVENT0("cc", "LayerTreeHost::initializeRenderer");
     if (!m_proxy->initializeRenderer()) {
         // Uh oh, better tell the client that we can't do anything with this context.
         m_client->didRecreateOutputSurface(false);
         return;
     }
 
     // Update m_settings based on capabilities that we got back from the renderer.
     m_settings.acceleratePainting = m_proxy->rendererCapabilities().usingAcceleratedPainting;
 
     // Update m_settings based on partial update capability.
     m_settings.maxPartialTextureUpdates = min(m_settings.maxPartialTextureUpdates, m_proxy->maxPartialTextureUpdates());
 
-    m_contentsTextureManager = PrioritizedTextureManager::create(0, m_proxy->rendererCapabilities().maxTextureSize, Renderer::ContentPool);
+    m_contentsTextureManager = PrioritizedTextureManager::create(0, m_proxy->rendererCapabilities().maxTextureSize, Renderer::ContentPool, m_proxy.get());
     m_surfaceMemoryPlaceholder = m_contentsTextureManager->createTexture(gfx::Size(), GL_RGBA);
 
     m_rendererInitialized = true;
 
     m_settings.defaultTileSize = gfx::Size(min(m_settings.defaultTileSize.width(), m_proxy->rendererCapabilities().maxTextureSize),
                                            min(m_settings.defaultTileSize.height(), m_proxy->rendererCapabilities().maxTextureSize));
     m_settings.maxUntiledLayerSize = gfx::Size(min(m_settings.maxUntiledLayerSize.width(), m_proxy->rendererCapabilities().maxTextureSize),
                                                min(m_settings.maxUntiledLayerSize.height(), m_proxy->rendererCapabilities().maxTextureSize));
 }
 
@@ skipping 14 matching lines @@
         return RecreateSucceeded;
     }
 
     // Tolerate a certain number of recreation failures to work around races
     // in the context-lost machinery.
     m_numFailedRecreateAttempts++;
     if (m_numFailedRecreateAttempts < 5) {
         // FIXME: The single thread does not self-schedule context
         // recreation. So force another recreation attempt to happen by requesting
         // another commit.
-        if (!Proxy::hasImplThread())
+        if (!m_proxy->hasImplThread())
             setNeedsCommit();
         return RecreateFailedButTryAgain;
     }
 
     // We have tried too many times to recreate the context. Tell the host to fall
     // back to software rendering.
     m_client->didRecreateOutputSurface(false);
     return RecreateFailedAndGaveUp;
 }
 
 void LayerTreeHost::deleteContentsTexturesOnImplThread(ResourceProvider* resourceProvider)
 {
-    DCHECK(Proxy::isImplThread());
+    DCHECK(m_proxy->isImplThread());
     if (m_rendererInitialized)
         m_contentsTextureManager->clearAllMemory(resourceProvider);
 }
 
 void LayerTreeHost::acquireLayerTextures()
 {
-    DCHECK(Proxy::isMainThread());
+    DCHECK(m_proxy->isMainThread());
     m_proxy->acquireLayerTextures();
 }
 
 void LayerTreeHost::updateAnimations(base::TimeTicks frameBeginTime)
 {
     m_animating = true;
     m_client->animate((frameBeginTime - base::TimeTicks()).InSecondsF());
     animateLayers(frameBeginTime);
     m_animating = false;
 
     m_renderingStats.numAnimationFrames++;
 }
 
 void LayerTreeHost::layout()
 {
     m_client->layout();
 }
 
 void LayerTreeHost::beginCommitOnImplThread(LayerTreeHostImpl* hostImpl)
 {
-    DCHECK(Proxy::isImplThread());
+    DCHECK(m_proxy->isImplThread());
     TRACE_EVENT0("cc", "LayerTreeHost::commitTo");
 }
 
 // This function commits the LayerTreeHost to an impl tree. When modifying
 // this function, keep in mind that the function *runs* on the impl thread! Any
 // code that is logically a main thread operation, e.g. deletion of a Layer,
 // should be delayed until the LayerTreeHost::commitComplete, which will run
 // after the commit, but on the main thread.
 void LayerTreeHost::finishCommitOnImplThread(LayerTreeHostImpl* hostImpl)
 {
-    DCHECK(Proxy::isImplThread());
+    DCHECK(m_proxy->isImplThread());
 
     m_contentsTextureManager->updateBackingsInDrawingImplTree();
     ResourceProvider::debugNotifyEnterZone(0xA000000);
     m_contentsTextureManager->reduceMemory(hostImpl->resourceProvider());
     ResourceProvider::debugNotifyLeaveZone();
 
     hostImpl->setRootLayer(TreeSynchronizer::synchronizeTrees(rootLayer(), hostImpl->detachLayerTree(), hostImpl));
 
     if (m_rootLayer && m_hudLayer)
         hostImpl->setHudLayer(static_cast<HeadsUpDisplayLayerImpl*>(LayerTreeHostCommon::findLayerInSubtree(hostImpl->rootLayer(), m_hudLayer->id())));
@@ skipping 46 matching lines @@
     return m_client->createOutputSurface();
 }
 
 scoped_ptr<InputHandler> LayerTreeHost::createInputHandler()
 {
     return m_client->createInputHandler();
 }
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHost::createLayerTreeHostImpl(LayerTreeHostImplClient* client)
 {
-    return LayerTreeHostImpl::create(m_settings, client);
+    return LayerTreeHostImpl::create(m_settings, client, m_proxy.get());
 }
 
 void LayerTreeHost::didLoseContext()
 {
     TRACE_EVENT0("cc", "LayerTreeHost::didLoseContext");
-    DCHECK(Proxy::isMainThread());
+    DCHECK(m_proxy->isMainThread());
     m_contextLost = true;
     m_numFailedRecreateAttempts = 0;
     setNeedsCommit();
 }
 
 bool LayerTreeHost::compositeAndReadback(void *pixels, const gfx::Rect& rect)
 {
     m_triggerIdleUpdates = false;
     bool ret = m_proxy->compositeAndReadback(pixels, rect);
     m_triggerIdleUpdates = true;
@@ skipping 22 matching lines @@
     m_proxy->renderingStats(stats);
 }
 
 const RendererCapabilities& LayerTreeHost::rendererCapabilities() const
 {
     return m_proxy->rendererCapabilities();
 }
 
 void LayerTreeHost::setNeedsAnimate()
 {
-    DCHECK(Proxy::hasImplThread());
+    DCHECK(m_proxy->hasImplThread());
     m_proxy->setNeedsAnimate();
 }
 
 void LayerTreeHost::setNeedsCommit()
 {
     if (!m_prepaintCallback.IsCancelled()) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHost::setNeedsCommit::cancel prepaint");
         m_prepaintCallback.Cancel();
     }
     m_proxy->setNeedsCommit();
 }
 
 void LayerTreeHost::setNeedsRedraw()
 {
     m_proxy->setNeedsRedraw();
-    if (!ThreadProxy::implThread())
+    if (!m_proxy->implThread())
         m_client->scheduleComposite();
 }
 
 bool LayerTreeHost::commitRequested() const
 {
     return m_proxy->commitRequested();
 }
 
 void LayerTreeHost::setAnimationEvents(scoped_ptr<AnimationEventsVector> events, base::Time wallClockTime)
 {
-    DCHECK(ThreadProxy::isMainThread());
+    DCHECK(m_proxy->isMainThread());
     setAnimationEventsRecursive(*events.get(), m_rootLayer.get(), wallClockTime);
 }
 
 void LayerTreeHost::didAddAnimation()
 {
     m_needsAnimateLayers = true;
     m_proxy->didAddAnimation();
 }
 
 void LayerTreeHost::setRootLayer(scoped_refptr<Layer> rootLayer)
@@ skipping 55 matching lines @@
     m_proxy->loseContext();
 }
 
 PrioritizedTextureManager* LayerTreeHost::contentsTextureManager() const
 {
     return m_contentsTextureManager.get();
 }
 
 void LayerTreeHost::composite()
 {
-    DCHECK(!ThreadProxy::implThread());
+    DCHECK(!m_proxy->implThread());
     static_cast<SingleThreadProxy*>(m_proxy.get())->compositeImmediately();
 }
 
 void LayerTreeHost::scheduleComposite()
 {
     m_client->scheduleComposite();
 }
 
 bool LayerTreeHost::initializeRendererIfNeeded()
 {
@@ skipping 254 matching lines @@
 void LayerTreeHost::startRateLimiter(WebKit::WebGraphicsContext3D* context)
 {
     if (m_animating)
         return;
 
     DCHECK(context);
     RateLimiterMap::iterator it = m_rateLimiters.find(context);
     if (it != m_rateLimiters.end())
         it->second->start();
     else {
-        scoped_refptr<RateLimiter> rateLimiter = RateLimiter::create(context, this);
+        scoped_refptr<RateLimiter> rateLimiter = RateLimiter::create(context, this, m_proxy->mainThread());
         m_rateLimiters[context] = rateLimiter;
         rateLimiter->start();
     }
 }
 
 void LayerTreeHost::stopRateLimiter(WebKit::WebGraphicsContext3D* context)
 {
     RateLimiterMap::iterator it = m_rateLimiters.find(context);
     if (it != m_rateLimiters.end()) {
         it->second->stop();
@@ skipping 74 matching lines @@
             else
                 layer->notifyAnimationFinished(wallClockTime.ToDoubleT());
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 } // namespace cc