Finish the rename from cc::GraphicsContext to cc::OutputSurface

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 "cc/layer_tree_host.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.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"
@@ skipping 117 matching lines @@
         }
     }
 }
 
 LayerTreeSettings::~LayerTreeSettings()
 {
 }
 
 RendererCapabilities::RendererCapabilities()
     : bestTextureFormat(0)
-    , contextHasCachedFrontBuffer(false)
-    , usingPartialSwap(false)
     , usingAcceleratedPainting(false)
     , usingSetVisibility(false)
     , usingSwapCompleteCallback(false)
     , usingGpuMemoryManager(false)
     , usingDiscardFramebuffer(false)
     , usingEglImage(false)
     , maxTextureSize(0)
 {
 }
 
@@ skipping 15 matching lines @@
 }
 
 LayerTreeHost::LayerTreeHost(LayerTreeHostClient* client, const LayerTreeSettings& settings)
     : m_animating(false)
     , m_needsAnimateLayers(false)
     , m_needsFullTreeSync(true)
     , m_client(client)
     , m_commitNumber(0)
     , m_renderingStats()
     , m_rendererInitialized(false)
-    , m_contextLost(false)
+    , m_outputSurfaceLost(false)
     , m_numTimesRecreateShouldFail(0)
     , m_numFailedRecreateAttempts(0)
     , m_settings(settings)
     , m_debugState(settings.initialDebugState)
     , 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)
 {
     numLayerTreeInstances++;
 }
 
 bool LayerTreeHost::initialize(scoped_ptr<Thread> implThread)
 {
     TRACE_EVENT0("cc", "LayerTreeHost::initialize");
 
     if (implThread)
         m_proxy = ThreadProxy::create(this, implThread.Pass());
     else
         m_proxy = SingleThreadProxy::create(this);
     m_proxy->start();
 
-    return m_proxy->initializeContext();
+    return m_proxy->initializeOutputSurface();
 }
 
 LayerTreeHost::~LayerTreeHost()
 {
     if (m_rootLayer)
         m_rootLayer->setLayerTreeHost(0);
     DCHECK(m_proxy);
     DCHECK(m_proxy->isMainThread());
     TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
     m_proxy->stop();
     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.
+        // Uh oh, better tell the client that we can't do anything with this output surface.
         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 = PrioritizedResourceManager::create(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));
 }
 
-LayerTreeHost::RecreateResult LayerTreeHost::recreateContext()
+LayerTreeHost::RecreateResult LayerTreeHost::recreateOutputSurface()
 {
-    TRACE_EVENT0("cc", "LayerTreeHost::recreateContext");
-    DCHECK(m_contextLost);
+    TRACE_EVENT0("cc", "LayerTreeHost::recreateOutputSurface");
+    DCHECK(m_outputSurfaceLost);
 
     bool recreated = false;
     if (!m_numTimesRecreateShouldFail)
-        recreated = m_proxy->recreateContext();
+        recreated = m_proxy->recreateOutputSurface();
     else
         m_numTimesRecreateShouldFail--;
 
     if (recreated) {
         m_client->didRecreateOutputSurface(true);
-        m_contextLost = false;
+        m_outputSurfaceLost = false;
         return RecreateSucceeded;
     }
 
     // Tolerate a certain number of recreation failures to work around races
-    // in the context-lost machinery.
+    // in the output-surface-lost machinery.
     m_numFailedRecreateAttempts++;
     if (m_numFailedRecreateAttempts < 5) {
-        // FIXME: The single thread does not self-schedule context
+        // FIXME: The single thread does not self-schedule output surface
         // recreation. So force another recreation attempt to happen by requesting
         // another commit.
         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.
+    // We have tried too many times to recreate the output surface. Tell the
+    // host to fall back to software rendering.
     m_client->didRecreateOutputSurface(false);
     return RecreateFailedAndGaveUp;
 }
 
 void LayerTreeHost::deleteContentsTexturesOnImplThread(ResourceProvider* resourceProvider)
 {
     DCHECK(m_proxy->isImplThread());
     if (m_rendererInitialized)
         m_contentsTextureManager->clearAllMemory(resourceProvider);
 }
@@ skipping 105 matching lines @@
         m_hudLayer->removeFromParent();
         m_hudLayer = 0;
     }
 }
 
 void LayerTreeHost::commitComplete()
 {
     m_client->didCommit();
 }
 
-scoped_ptr<GraphicsContext> LayerTreeHost::createContext()
+scoped_ptr<OutputSurface> LayerTreeHost::createOutputSurface()
 {
     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, m_proxy.get());
 }
 
-void LayerTreeHost::didLoseContext()
+void LayerTreeHost::didLoseOutputSurface()
 {
-    TRACE_EVENT0("cc", "LayerTreeHost::didLoseContext");
+    TRACE_EVENT0("cc", "LayerTreeHost::didLoseOutputSurface");
     DCHECK(m_proxy->isMainThread());
-    m_contextLost = true;
+    m_outputSurfaceLost = 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;
     return ret;
@@ skipping 127 matching lines @@
         return;
     m_visible = visible;
     m_proxy->setVisible(visible);
 }
 
 void LayerTreeHost::startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration)
 {
     m_proxy->startPageScaleAnimation(targetOffset, useAnchor, scale, duration);
 }
 
-void LayerTreeHost::loseContext(int numTimes)
+void LayerTreeHost::loseOutputSurface(int numTimes)
 {
-    TRACE_EVENT1("cc", "LayerTreeHost::loseCompositorContext", "numTimes", numTimes);
+    TRACE_EVENT1("cc", "LayerTreeHost::loseCompositorOutputSurface", "numTimes", numTimes);
     m_numTimesRecreateShouldFail = numTimes - 1;
-    m_proxy->loseContext();
+    m_proxy->loseOutputSurface();
 }
 
 PrioritizedResourceManager* LayerTreeHost::contentsTextureManager() const
 {
     return m_contentsTextureManager.get();
 }
 
 void LayerTreeHost::composite()
 {
     if (!m_proxy->hasImplThread())
         static_cast<SingleThreadProxy*>(m_proxy.get())->compositeImmediately();
     else
         setNeedsCommit();
 }
 
 void LayerTreeHost::scheduleComposite()
 {
     m_client->scheduleComposite();
 }
 
 bool LayerTreeHost::initializeRendererIfNeeded()
 {
     if (!m_rendererInitialized) {
         initializeRenderer();
         // If we couldn't initialize, then bail since we're returning to software mode.
         if (!m_rendererInitialized)
             return false;
     }
-    if (m_contextLost) {
-        if (recreateContext() != RecreateSucceeded)
+    if (m_outputSurfaceLost) {
+        if (recreateOutputSurface() != RecreateSucceeded)
             return false;
     }
     return true;
 }
 
 void LayerTreeHost::updateLayers(ResourceUpdateQueue& queue, size_t memoryAllocationLimitBytes)
 {
     DCHECK(m_rendererInitialized);
 
     if (!rootLayer())
@@ skipping 332 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