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

cc/layer_tree_host_impl.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_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 261 matching lines @@
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw no renderer");
         return false;
     }
     if (m_contentsTexturesPurged) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw contents textures purged");
         return false;
     }
     return true;
 }
 
-GraphicsContext* LayerTreeHostImpl::context() const
+OutputSurface* LayerTreeHostImpl::outputSurface() const
 {
-    return m_context.get();
+    return m_outputSurface.get();
 }
 
 void LayerTreeHostImpl::animate(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
     animatePageScale(monotonicTime);
     animateLayers(monotonicTime, wallClockTime);
     animateScrollbars(monotonicTime);
 }
 
 void LayerTreeHostImpl::manageTiles()
@@ skipping 589 matching lines @@
 const gfx::Size& LayerTreeHostImpl::deviceViewportSize() const
 {
     return m_deviceViewportSize;
 }
 
 const LayerTreeSettings& LayerTreeHostImpl::settings() const
 {
     return m_settings;
 }
 
-void LayerTreeHostImpl::didLoseContext()
+void LayerTreeHostImpl::didLoseOutputSurface()
 {
-    m_client->didLoseContextOnImplThread();
+    m_client->didLoseOutputSurfaceOnImplThread();
 }
 
 void LayerTreeHostImpl::onSwapBuffersComplete()
 {
     m_client->onSwapBuffersCompleteOnImplThread();
 }
 
 void LayerTreeHostImpl::readback(void* pixels, const gfx::Rect& rect)
 {
     DCHECK(m_renderer);
@@ skipping 69 matching lines @@
     enforceManagedMemoryPolicy(m_managedMemoryPolicy);
 
     if (!m_renderer)
         return;
 
     m_renderer->setVisible(visible);
 
     setBackgroundTickingEnabled(!m_visible && m_needsAnimateLayers);
 }
 
-bool LayerTreeHostImpl::initializeRenderer(scoped_ptr<GraphicsContext> context)
+bool LayerTreeHostImpl::initializeRenderer(scoped_ptr<OutputSurface> outputSurface)
 {
     // Since we will create a new resource provider, we cannot continue to use
     // the old resources (i.e. renderSurfaces and texture IDs). Clear them
     // before we destroy the old resource provider.
     if (m_rootLayerImpl) {
         clearRenderSurfaces();
-        sendDidLoseContextRecursive(m_rootLayerImpl.get());
+        sendDidLoseOutputSurfaceRecursive(m_rootLayerImpl.get());
     }
     // Note: order is important here.
     m_renderer.reset();
     m_tileManager.reset();
     m_resourceProvider.reset();
-    m_context.reset();
+    m_outputSurface.reset();
 
-    if (!context->bindToClient(this))
+    if (!outputSurface->bindToClient(this))
         return false;
 
-    scoped_ptr<ResourceProvider> resourceProvider = ResourceProvider::create(context.get());
+    scoped_ptr<ResourceProvider> resourceProvider = ResourceProvider::create(outputSurface.get());
     if (!resourceProvider)
         return false;
 
     if (m_settings.implSidePainting)
       m_tileManager.reset(new TileManager(this, resourceProvider.get(), m_settings.numRasterThreads));
 
-    if (context->context3D())
+    if (outputSurface->context3D())
         m_renderer = GLRenderer::create(this, resourceProvider.get());
-    else if (context->softwareDevice())
-        m_renderer = SoftwareRenderer::create(this, resourceProvider.get(), context->softwareDevice());
+    else if (outputSurface->softwareDevice())
+        m_renderer = SoftwareRenderer::create(this, resourceProvider.get(), outputSurface->softwareDevice());
     if (!m_renderer)
         return false;
 
     m_resourceProvider = resourceProvider.Pass();
-    m_context = context.Pass();
+    m_outputSurface = outputSurface.Pass();
 
     if (!m_visible)
         m_renderer->setVisible(m_visible);
 
     m_client->onCanDrawStateChanged(canDraw());
 
     return true;
 }
 
 void LayerTreeHostImpl::setContentsTexturesPurged()
@@ skipping 519 matching lines @@
         m_client->setNeedsRedrawOnImplThread();
 
     setBackgroundTickingEnabled(!m_visible && m_needsAnimateLayers);
 }
 
 base::TimeDelta LayerTreeHostImpl::lowFrequencyAnimationInterval() const
 {
     return base::TimeDelta::FromSeconds(1);
 }
 
-void LayerTreeHostImpl::sendDidLoseContextRecursive(LayerImpl* current)
+void LayerTreeHostImpl::sendDidLoseOutputSurfaceRecursive(LayerImpl* current)
 {
     DCHECK(current);
-    current->didLoseContext();
+    current->didLoseOutputSurface();
     if (current->maskLayer())
-        sendDidLoseContextRecursive(current->maskLayer());
+        sendDidLoseOutputSurfaceRecursive(current->maskLayer());
     if (current->replicaLayer())
-        sendDidLoseContextRecursive(current->replicaLayer());
+        sendDidLoseOutputSurfaceRecursive(current->replicaLayer());
     for (size_t i = 0; i < current->children().size(); ++i)
-        sendDidLoseContextRecursive(current->children()[i]);
+        sendDidLoseOutputSurfaceRecursive(current->children()[i]);
 }
 
 static void clearRenderSurfacesOnLayerImplRecursive(LayerImpl* current)
 {
     DCHECK(current);
     for (size_t i = 0; i < current->children().size(); ++i)
         clearRenderSurfacesOnLayerImplRecursive(current->children()[i]);
     current->clearRenderSurface();
 }
 
@@ skipping 53 matching lines @@
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 }  // namespace cc