cc: Fix capitalization style in chromified files.

cc/resources/resource_provider_unittest.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 "cc/resources/resource_provider.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "cc/base/scoped_ptr_deque.h"
 #include "cc/base/scoped_ptr_hash_map.h"
@@ skipping 69 matching lines @@
   }
 
   scoped_ptr<Texture> ConsumeTexture(const WGC3Dbyte* mailbox_name,
                                      unsigned sync_point) {
     unsigned mailbox = 0;
     memcpy(&mailbox, mailbox_name, sizeof(mailbox));
     DCHECK(mailbox && mailbox < next_mailbox_);
 
     // If the latest sync point the context has waited on is before the sync
     // point for when the mailbox was set, pretend we never saw that
-    // produceTexture.
+    // ProduceTexture.
     if (sync_point_for_mailbox_[mailbox] > sync_point) {
       NOTREACHED();
       return scoped_ptr<Texture>();
     }
     return textures_.take(mailbox);
   }
 
  private:
   ContextSharedData() : next_sync_point_(1), next_mailbox_(1) {}
 
@@ skipping 125 matching lines @@
   virtual void genMailboxCHROMIUM(WGC3Dbyte* mailbox) OVERRIDE {
     return shared_data_->GenMailbox(mailbox);
   }
 
   virtual void produceTextureCHROMIUM(WGC3Denum target,
                                       const WGC3Dbyte* mailbox) OVERRIDE {
     ASSERT_TRUE(current_texture_);
     ASSERT_EQ(target, GL_TEXTURE_2D);
 
     // Delay moving the texture into the mailbox until the next
-    // insertSyncPoint, so that it is not visible to other contexts that
+    // InsertSyncPoint, so that it is not visible to other contexts that
     // haven't waited on that sync point.
     scoped_ptr<PendingProduceTexture> pending(new PendingProduceTexture);
     memcpy(pending->mailbox, mailbox, sizeof(pending->mailbox));
     pending->texture = textures_.take(current_texture_);
     textures_.set(current_texture_, scoped_ptr<Texture>());
     pending_produce_textures_.push_back(pending.Pass());
   }
 
   virtual void consumeTextureCHROMIUM(WGC3Denum target,
                                       const WGC3Dbyte* mailbox) OVERRIDE {
@@ skipping 586 matching lines @@
 
   // Force all textures to be "1" so we can test for them.
   virtual WebKit::WebGLId NextTextureId() OVERRIDE { return 1; }
 };
 
 TEST_P(ResourceProviderTest, ScopedSampler) {
   // Sampling is only supported for GL textures.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
 
-  scoped_ptr<OutputSurface> outputSurface(
+  scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new TextureStateTrackingContext)));
   TextureStateTrackingContext* context =
-      static_cast<TextureStateTrackingContext*>(outputSurface->context3d());
+      static_cast<TextureStateTrackingContext*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(outputSurface.get()));
+      ResourceProvider::Create(output_surface.get()));
 
   gfx::Size size(1, 1);
   WGC3Denum format = GL_RGBA;
   int texture_id = 1;
 
   // Check that the texture gets created with the right sampler settings.
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id))
       .Times(2);  // Once to create and once to allocate.
   EXPECT_CALL(*context,
               texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
@@ skipping 46 matching lines @@
   }
 
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_P(ResourceProviderTest, ManagedResource) {
   // Sampling is only supported for GL textures.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
 
-  scoped_ptr<OutputSurface> outputSurface(
+  scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new TextureStateTrackingContext)));
   TextureStateTrackingContext* context =
-      static_cast<TextureStateTrackingContext*>(outputSurface->context3d());
+      static_cast<TextureStateTrackingContext*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(outputSurface.get()));
+      ResourceProvider::Create(output_surface.get()));
 
   gfx::Size size(1, 1);
   WGC3Denum format = GL_RGBA;
   int texture_id = 1;
 
   // Check that the texture gets created with the right sampler settings.
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
   EXPECT_CALL(*context,
               texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
   EXPECT_CALL(*context,
@@ skipping 62 matching lines @@
   MOCK_METHOD1(waitAsyncTexImage2DCHROMIUM, void(WGC3Denum target));
 };
 
 TEST_P(ResourceProviderTest, TextureAllocation) {
   // Only for GL textures.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   scoped_ptr<WebKit::WebGraphicsContext3D> mock_context(
       static_cast<WebKit::WebGraphicsContext3D*>(
           new NiceMock<AllocationTrackingContext3D>));
-  scoped_ptr<OutputSurface> outputSurface(
+  scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(mock_context.Pass()));
 
   gfx::Size size(2, 2);
   gfx::Vector2d offset(0, 0);
   gfx::Rect rect(0, 0, 2, 2);
   WGC3Denum format = GL_RGBA;
   ResourceProvider::ResourceId id = 0;
   uint8_t pixels[16] = { 0 };
   int texture_id = 123;
 
   AllocationTrackingContext3D* context =
-      static_cast<AllocationTrackingContext3D*>(outputSurface->context3d());
+      static_cast<AllocationTrackingContext3D*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(outputSurface.get()));
+      ResourceProvider::Create(output_surface.get()));
 
   // Lazy allocation. Don't allocate when creating the resource.
   EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(1);
   EXPECT_CALL(*context, texImage2D(_, _, _, _, _, _, _, _, _)).Times(0);
   EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, _, _, _, _, _, _))
       .Times(0);
   id = resource_provider->CreateResource(
       size, format, ResourceProvider::TextureUsageAny);
   resource_provider->DeleteResource(id);
   Mock::VerifyAndClearExpectations(context);
 
   // Do allocate when we set the pixels.
   EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
   EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _)).Times(1);
   EXPECT_CALL(*context, texSubImage2D(_, _, _, _, 2, 2, _, _, _)).Times(1);
   id = resource_provider->CreateResource(
       size, format, ResourceProvider::TextureUsageAny);
   resource_provider->SetPixels(id, pixels, rect, rect, offset);
   resource_provider->DeleteResource(id);
   Mock::VerifyAndClearExpectations(context);
 
-  // Same for setPixelsFromBuffer
+  // Same for SetPixelsFromBuffer
   EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
   EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _)).Times(1);
   EXPECT_CALL(*context, texSubImage2D(_, _, _, _, 2, 2, _, _, _)).Times(1);
   id = resource_provider->CreateResource(
       size, format, ResourceProvider::TextureUsageAny);
   resource_provider->AcquirePixelBuffer(id);
   resource_provider->SetPixelsFromBuffer(id);
   resource_provider->ReleasePixelBuffer(id);
@@ skipping 15 matching lines @@
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_P(ResourceProviderTest, ForcingAsyncUploadToComplete) {
   // Only for GL textures.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   scoped_ptr<WebKit::WebGraphicsContext3D> mock_context(
       static_cast<WebKit::WebGraphicsContext3D*>(
           new NiceMock<AllocationTrackingContext3D>));
-  scoped_ptr<OutputSurface> outputSurface(
+  scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(mock_context.Pass()));
 
   gfx::Size size(2, 2);
   WGC3Denum format = GL_RGBA;
   ResourceProvider::ResourceId id = 0;
   int texture_id = 123;
 
   AllocationTrackingContext3D* context =
-      static_cast<AllocationTrackingContext3D*>(outputSurface->context3d());
+      static_cast<AllocationTrackingContext3D*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(outputSurface.get()));
+      ResourceProvider::Create(output_surface.get()));
 
   EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
   EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
       .Times(1);
   EXPECT_CALL(*context, waitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D)).Times(1);
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, 0)).Times(1);
   id = resource_provider->CreateResource(
       size, format, ResourceProvider::TextureUsageAny);
   resource_provider->AcquirePixelBuffer(id);
   resource_provider->BeginSetPixels(id);
   resource_provider->ForceSetPixelsToComplete(id);
   resource_provider->ReleasePixelBuffer(id);
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_P(ResourceProviderTest, AbortForcedAsyncUpload) {
   // Only for GL textures.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   scoped_ptr<WebKit::WebGraphicsContext3D> mock_context(
       static_cast<WebKit::WebGraphicsContext3D*>(
           new NiceMock<AllocationTrackingContext3D>));
-  scoped_ptr<OutputSurface> outputSurface(
+  scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(mock_context.Pass()));
 
   gfx::Size size(2, 2);
   WGC3Denum format = GL_RGBA;
   ResourceProvider::ResourceId id = 0;
   int texture_id = 123;
 
   AllocationTrackingContext3D* context =
-      static_cast<AllocationTrackingContext3D*>(outputSurface->context3d());
+      static_cast<AllocationTrackingContext3D*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(outputSurface.get()));
+      ResourceProvider::Create(output_surface.get()));
 
   EXPECT_CALL(*context, createTexture()).WillRepeatedly(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(4);
   EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
       .Times(1);
   EXPECT_CALL(*context, waitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D)).Times(1);
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, 0)).Times(1);
   EXPECT_CALL(*context, deleteTexture(_)).Times(1);
   id = resource_provider->CreateResource(
       size, format, ResourceProvider::TextureUsageAny);
   resource_provider->AcquirePixelBuffer(id);
   resource_provider->BeginSetPixels(id);
   resource_provider->ForceSetPixelsToComplete(id);
   resource_provider->AbortSetPixels(id);
   resource_provider->ReleasePixelBuffer(id);
   Mock::VerifyAndClearExpectations(context);
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceProviderTests,
     ResourceProviderTest,
     ::testing::Values(ResourceProvider::GLTexture, ResourceProvider::Bitmap));
 
 }  // namespace
 }  // namespace cc