cc: Rename cc classes and members to match filenames

cc/throttled_texture_uploader.cc

 // Copyright 2012 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/throttled_texture_uploader.h"
 
 #include "CCPrioritizedTexture.h"
 #include "CCProxy.h"
 #include "Extensions3DChromium.h"
@@ skipping 153 matching lines @@
     m_availableQueries.first()->begin();
 }
 
 void ThrottledTextureUploader::endQuery()
 {
     m_availableQueries.first()->end();
     m_pendingQueries.append(m_availableQueries.takeFirst());
     m_numBlockingTextureUploads++;
 }
 
-void ThrottledTextureUploader::uploadTexture(CCResourceProvider* resourceProvider, Parameters upload)
+void ThrottledTextureUploader::uploadTexture(ResourceProvider* resourceProvider, Parameters upload)
 {
     bool isFullUpload = upload.geometry.destOffset.isZero() &&
                         upload.geometry.sourceRect.size() == upload.texture->size();
 
     if (isFullUpload)
         beginQuery();
 
     if (upload.bitmap) {
         upload.bitmap->lockPixels();
         upload.texture->upload(
             resourceProvider,
             static_cast<const uint8_t*>(upload.bitmap->getPixels()),
             upload.geometry.contentRect,
             upload.geometry.sourceRect,
             upload.geometry.destOffset);
         upload.bitmap->unlockPixels();
     }
 
-    // TODO(reveman): Move this logic to CCTextureUpdateController after
+    // TODO(reveman): Move this logic to TextureUpdateController after
     // removing Parameters struct.
     if (upload.picture) {
-        CCPrioritizedTexture* texture = upload.texture;
+        PrioritizedTexture* texture = upload.texture;
         IntRect pictureRect = upload.geometry.contentRect;
         IntRect sourceRect = upload.geometry.sourceRect;
         IntSize destOffset = upload.geometry.destOffset;
 
         texture->acquireBackingTexture(resourceProvider);
         ASSERT(texture->haveBackingTexture());
 
         ASSERT(resourceProvider->resourceType(texture->resourceId()) ==
-               CCResourceProvider::GLTexture);
+               ResourceProvider::GLTexture);
 
-        WebGraphicsContext3D* paintContext = CCProxy::hasImplThread() ?
+        WebGraphicsContext3D* paintContext = Proxy::hasImplThread() ?
             WebSharedGraphicsContext3D::compositorThreadContext() :
             WebSharedGraphicsContext3D::mainThreadContext();
-        GrContext* paintGrContext = CCProxy::hasImplThread() ?
+        GrContext* paintGrContext = Proxy::hasImplThread() ?
             WebSharedGraphicsContext3D::compositorThreadGrContext() :
             WebSharedGraphicsContext3D::mainThreadGrContext();
 
         // Flush the context in which the backing texture is created so that it
         // is available in other shared contexts. It is important to do here
         // because the backing texture is created in one context while it is
         // being written to in another.
         resourceProvider->flush();
-        CCResourceProvider::ScopedWriteLockGL lock(
+        ResourceProvider::ScopedWriteLockGL lock(
             resourceProvider, texture->resourceId());
 
         // Make sure ganesh uses the correct GL context.
         paintContext->makeContextCurrent();
 
         // Create an accelerated canvas to draw on.
         scoped_ptr<SkCanvas> canvas = createAcceleratedCanvas(
             paintGrContext, texture->size(), lock.textureId());
 
         // The compositor expects the textures to be upside-down so it can flip
@@ skipping 41 matching lines @@
         // Remove the oldest values from our history and insert the new one
         double texturesPerSecond = 1.0 / (usElapsed * 1e-6);
         m_texturesPerSecondHistory.pop_back();
         m_texturesPerSecondHistory.push_front(texturesPerSecond);
 
         m_availableQueries.append(m_pendingQueries.takeFirst());
     }
 }
 
 }