cc: Rename TextureUpdate to ResourceUpdate.

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 "base/debug/trace_event.h"
 #include "cc/delay_based_time_source.h"
@@ skipping 345 matching lines @@
         return false;
 
     ResourceProvider::debugNotifyEnterZone(0x1000000);
     bool reduceResult = m_layerTreeHost->contentsTextureManager()->reduceMemoryOnImplThread(limitBytes, priorityCutoff, m_layerTreeHostImpl->resourceProvider());
     ResourceProvider::debugNotifyLeaveZone();
     if (!reduceResult)
         return false;
 
     // The texture upload queue may reference textures that were just purged, clear
     // them from the queue.
-    if (m_currentTextureUpdateControllerOnImplThread.get())
-        m_currentTextureUpdateControllerOnImplThread->discardUploadsToEvictedResources();
+    if (m_currentResourceUpdateControllerOnImplThread.get())
+        m_currentResourceUpdateControllerOnImplThread->discardUploadsToEvictedResources();
     return true;
 }
 
 void ThreadProxy::setNeedsRedraw()
 {
     DCHECK(isMainThread());
     TRACE_EVENT0("cc", "ThreadProxy::setNeedsRedraw");
     Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::setFullRootLayerDamageOnImplThread));
     Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::setNeedsRedrawOnImplThread));
 }
@@ skipping 162 matching lines @@
     m_commitRequestSentToImplThread = false;
     m_forcedCommitRequested = false;
 
     if (!m_layerTreeHost->initializeRendererIfNeeded()) {
         TRACE_EVENT0("cc", "EarlyOut_InitializeFailed");
         return;
     }
 
     m_layerTreeHost->contentsTextureManager()->unlinkEvictedBackings(request->evictedContentsTexturesBackings);
 
-    scoped_ptr<TextureUpdateQueue> queue = make_scoped_ptr(new TextureUpdateQueue);
+    scoped_ptr<ResourceUpdateQueue> queue = make_scoped_ptr(new ResourceUpdateQueue);
     m_layerTreeHost->updateLayers(*(queue.get()), request->memoryAllocationLimitBytes);
 
     // Once single buffered layers are committed, they cannot be modified until
     // they are drawn by the impl thread.
     m_texturesAcquired = false;
 
     m_layerTreeHost->willCommit();
     // Before applying scrolls and calling animate, we set m_animateRequested to
     // false. If it is true now, it means setNeedAnimate was called again, but
     // during a state when m_commitRequestSentToImplThread = true. We need to
@@ skipping 21 matching lines @@
         base::TimeTicks endTime = base::TimeTicks::HighResNow();
 
         m_totalCommitTime += endTime - startTime;
         m_totalCommitCount++;
     }
 
     m_layerTreeHost->commitComplete();
     m_layerTreeHost->didBeginFrame();
 }
 
-void ThreadProxy::beginFrameCompleteOnImplThread(CompletionEvent* completion, TextureUpdateQueue* rawQueue)
+void ThreadProxy::beginFrameCompleteOnImplThread(CompletionEvent* completion, ResourceUpdateQueue* rawQueue)
 {
-    scoped_ptr<TextureUpdateQueue> queue(rawQueue);
+    scoped_ptr<ResourceUpdateQueue> queue(rawQueue);
 
     TRACE_EVENT0("cc", "ThreadProxy::beginFrameCompleteOnImplThread");
     DCHECK(!m_commitCompletionEventOnImplThread);
     DCHECK(isImplThread() && isMainThreadBlocked());
     DCHECK(m_schedulerOnImplThread);
     DCHECK(m_schedulerOnImplThread->commitPending());
 
     if (!m_layerTreeHostImpl.get()) {
         TRACE_EVENT0("cc", "EarlyOut_NoLayerTree");
         completion->signal();
         return;
     }
 
     if (m_layerTreeHost->contentsTextureManager()->linkedEvictedBackingsExist()) {
         // 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_currentResourceUpdateControllerOnImplThread = ResourceUpdateController::create(this, Proxy::implThread(), queue.Pass(), m_layerTreeHostImpl->resourceProvider());
     ResourceProvider::debugNotifyEnterZone(0x2000000);
-    m_currentTextureUpdateControllerOnImplThread->performMoreUpdates(
+    m_currentResourceUpdateControllerOnImplThread->performMoreUpdates(
         m_schedulerOnImplThread->anticipatedDrawTime());
     ResourceProvider::debugNotifyLeaveZone();
 
     m_commitCompletionEventOnImplThread = completion;
 }
 
 void ThreadProxy::beginFrameAbortedOnImplThread()
 {
     TRACE_EVENT0("cc", "ThreadProxy::beginFrameAbortedOnImplThread");
     DCHECK(isImplThread());
     DCHECK(m_schedulerOnImplThread);
     DCHECK(m_schedulerOnImplThread->commitPending());
 
     m_schedulerOnImplThread->beginFrameAborted();
 }
 
 void ThreadProxy::scheduledActionCommit()
 {
     TRACE_EVENT0("cc", "ThreadProxy::scheduledActionCommit");
     DCHECK(isImplThread());
     DCHECK(m_commitCompletionEventOnImplThread);
-    DCHECK(m_currentTextureUpdateControllerOnImplThread);
+    DCHECK(m_currentResourceUpdateControllerOnImplThread);
 
     // Complete all remaining texture updates.
     ResourceProvider::debugNotifyEnterZone(0x3000000);
-    m_currentTextureUpdateControllerOnImplThread->finalize();
+    m_currentResourceUpdateControllerOnImplThread->finalize();
     ResourceProvider::debugNotifyLeaveZone();
-    m_currentTextureUpdateControllerOnImplThread.reset();
+    m_currentResourceUpdateControllerOnImplThread.reset();
 
     // If there are linked evicted backings, these backings' resources may be put into the
     // impl tree, so we can't draw yet. Determine this before clearing all evicted backings.
     bool newImplTreeHasNoEvictedResources = !m_layerTreeHost->contentsTextureManager()->linkedEvictedBackingsExist();
 
     m_layerTreeHostImpl->beginCommit();
     m_layerTreeHost->beginCommitOnImplThread(m_layerTreeHostImpl.get());
     m_layerTreeHost->finishCommitOnImplThread(m_layerTreeHostImpl.get());
 
     if (newImplTreeHasNoEvictedResources) {
@@ skipping 123 matching lines @@
     return scheduledActionDrawAndSwapInternal(false);
 }
 
 ScheduledActionDrawAndSwapResult ThreadProxy::scheduledActionDrawAndSwapForced()
 {
     return scheduledActionDrawAndSwapInternal(true);
 }
 
 void ThreadProxy::didAnticipatedDrawTimeChange(base::TimeTicks time)
 {
-    if (!m_currentTextureUpdateControllerOnImplThread)
+    if (!m_currentResourceUpdateControllerOnImplThread)
         return;
 
     ResourceProvider::debugNotifyEnterZone(0x5000000);
-    m_currentTextureUpdateControllerOnImplThread->performMoreUpdates(time);
+    m_currentResourceUpdateControllerOnImplThread->performMoreUpdates(time);
     ResourceProvider::debugNotifyLeaveZone();
 }
 
 void ThreadProxy::readyToFinalizeTextureUpdates()
 {
     DCHECK(isImplThread());
     m_schedulerOnImplThread->beginFrameComplete();
 }
 
 void ThreadProxy::didCommitAndDrawFrame()
@@ skipping 120 matching lines @@
 }
 
 void ThreadProxy::setFullRootLayerDamageOnImplThread()
 {
     DCHECK(isImplThread());
     m_layerTreeHostImpl->setFullRootLayerDamage();
 }
 
 size_t ThreadProxy::maxPartialTextureUpdates() const
 {
-    return TextureUpdateController::maxPartialTextureUpdates();
+    return ResourceUpdateController::maxPartialTextureUpdates();
 }
 
 void ThreadProxy::recreateContextOnImplThread(CompletionEvent* completion, GraphicsContext* contextPtr, bool* recreateSucceeded, RendererCapabilities* capabilities)
 {
     TRACE_EVENT0("cc", "ThreadProxy::recreateContextOnImplThread");
     DCHECK(isImplThread());
     ResourceProvider::debugNotifyEnterZone(0x7000000);
     m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
     ResourceProvider::debugNotifyLeaveZone();
     *recreateSucceeded = m_layerTreeHostImpl->initializeRenderer(scoped_ptr<GraphicsContext>(contextPtr).Pass());
@@ skipping 14 matching lines @@
 ThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState()
     : monotonicFrameBeginTime(0)
 {
 }
 
 ThreadProxy::BeginFrameAndCommitState::~BeginFrameAndCommitState()
 {
 }
 
 }  // namespace cc