cc: Fix capitalization style in chromified files.

cc/output/gl_renderer_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/output/gl_renderer.h"
 
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/resource_provider.h"
@@ skipping 214 matching lines @@
 
   WebGraphicsMemoryAllocation suggest_have_backbuffer_yes_;
   WebGraphicsMemoryAllocation suggest_have_backbuffer_no_;
 
   scoped_ptr<OutputSurface> output_surface_;
   FakeRendererClient mock_client_;
   scoped_ptr<ResourceProvider> resource_provider_;
   FakeRendererGL renderer_;
 };
 
-// Test GLRenderer discardBackbuffer functionality:
+// Test GLRenderer DiscardBackbuffer functionality:
 // Suggest recreating framebuffer when one already exists.
 // Expected: it does nothing.
 TEST_F(GLRendererTest, SuggestBackbufferYesWhenItAlreadyExistsShouldDoNothing) {
   context()->SetMemoryAllocation(suggest_have_backbuffer_yes_);
   EXPECT_EQ(0, mock_client_.set_full_root_layer_damage_count());
   EXPECT_FALSE(renderer_.IsBackbufferDiscarded());
 
   SwapBuffers();
   EXPECT_EQ(1, context()->frame_count());
 }
 
-// Test GLRenderer discardBackbuffer functionality:
+// Test GLRenderer DiscardBackbuffer functionality:
 // Suggest discarding framebuffer when one exists and the renderer is not
 // visible.
 // Expected: it is discarded and damage tracker is reset.
 TEST_F(GLRendererTest,
        SuggestBackbufferNoShouldDiscardBackbufferAndDamageRootLayerWhileNotVisible) {
   renderer_.SetVisible(false);
   context()->SetMemoryAllocation(suggest_have_backbuffer_no_);
   EXPECT_EQ(1, mock_client_.set_full_root_layer_damage_count());
   EXPECT_TRUE(renderer_.IsBackbufferDiscarded());
 }
 
-// Test GLRenderer discardBackbuffer functionality:
+// Test GLRenderer DiscardBackbuffer functionality:
 // Suggest discarding framebuffer when one exists and the renderer is visible.
 // Expected: the allocation is ignored.
 TEST_F(GLRendererTest, SuggestBackbufferNoDoNothingWhenVisible) {
   renderer_.SetVisible(true);
   context()->SetMemoryAllocation(suggest_have_backbuffer_no_);
   EXPECT_EQ(0, mock_client_.set_full_root_layer_damage_count());
   EXPECT_FALSE(renderer_.IsBackbufferDiscarded());
 }
 
-// Test GLRenderer discardBackbuffer functionality:
+// Test GLRenderer DiscardBackbuffer functionality:
 // Suggest discarding framebuffer when one does not exist.
 // Expected: it does nothing.
 TEST_F(GLRendererTest, SuggestBackbufferNoWhenItDoesntExistShouldDoNothing) {
   renderer_.SetVisible(false);
   context()->SetMemoryAllocation(suggest_have_backbuffer_no_);
   EXPECT_EQ(1, mock_client_.set_full_root_layer_damage_count());
   EXPECT_TRUE(renderer_.IsBackbufferDiscarded());
 
   context()->SetMemoryAllocation(suggest_have_backbuffer_no_);
   EXPECT_EQ(1, mock_client_.set_full_root_layer_damage_count());
   EXPECT_TRUE(renderer_.IsBackbufferDiscarded());
 }
 
-// Test GLRenderer discardBackbuffer functionality:
+// Test GLRenderer DiscardBackbuffer functionality:
 // Begin drawing a frame while a framebuffer is discarded.
 // Expected: will recreate framebuffer.
 TEST_F(GLRendererTest, DiscardedBackbufferIsRecreatedForScopeDuration) {
   renderer_.SetVisible(false);
   context()->SetMemoryAllocation(suggest_have_backbuffer_no_);
   EXPECT_TRUE(renderer_.IsBackbufferDiscarded());
   EXPECT_EQ(1, mock_client_.set_full_root_layer_damage_count());
 
   renderer_.SetVisible(true);
   renderer_.DrawFrame(*mock_client_.render_passes_in_draw_order());
@@ skipping 367 matching lines @@
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get()));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
 
   EXPECT_TRUE(renderer.Initialize());
 
   bool last_call_was_set_visiblity = false;
   // Ensure that the call to setVisibilityCHROMIUM is the last call issue to the
   // GPU process, after glFlush is called, and after the RendererClient's
-  // enforceManagedMemoryPolicy is called. Plumb this tracking between both the
+  // EnforceManagedMemoryPolicy is called. Plumb this tracking between both the
   // RenderClient and the Context by giving them both a pointer to a variable on
   // the stack.
   context->set_last_call_was_set_visibility_pointer(&last_call_was_set_visiblity);
   mock_client.set_last_call_was_set_visibility_pointer(&last_call_was_set_visiblity);
   renderer.SetVisible(true);
   renderer.DrawFrame(*mock_client.render_passes_in_draw_order());
   renderer.SetVisible(false);
   EXPECT_TRUE(last_call_was_set_visiblity);
 }
 
@@ skipping 77 matching lines @@
 
     // The remaining quads also use GL_LINEAR because nearest neighbor
     // filtering is currently only used with tile quads.
     EXPECT_CALL(*context, drawElements(_, _, _, _)).Times(6);
   }
 
   cc::DirectRenderer::DrawingFrame drawing_frame;
   renderer.BeginDrawingFrame(drawing_frame);
   EXPECT_EQ(context->active_texture(), GL_TEXTURE0);
 
-  for (cc::QuadList::backToFrontIterator
-           it = pass->quad_list.backToFrontBegin();
-       it != pass->quad_list.backToFrontEnd();
+  for (cc::QuadList::BackToFrontIterator
+           it = pass->quad_list.BackToFrontBegin();
+       it != pass->quad_list.BackToFrontEnd();
        ++it) {
     renderer.DoDrawQuad(drawing_frame, *it);
   }
   renderer.FinishDrawingQuadList();
   EXPECT_EQ(context->active_texture(), GL_TEXTURE0);
   Mock::VerifyAndClearExpectations(context);
 }
 
 class NoClearRootRenderPassFakeClient : public FakeRendererClient {
  public:
@@ skipping 23 matching lines @@
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
   EXPECT_TRUE(renderer.Initialize());
 
   gfx::Rect viewport_rect(mock_client.DeviceViewportSize());
   ScopedPtrVector<RenderPass>& render_passes =
       *mock_client.render_passes_in_draw_order();
   render_passes.clear();
 
   RenderPass::Id root_pass_id(1, 0);
-  TestRenderPass* root_pass = addRenderPass(
+  TestRenderPass* root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
-  addQuad(root_pass, viewport_rect, SK_ColorGREEN);
+  AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
   RenderPass::Id child_pass_id(2, 0);
-  TestRenderPass* child_pass = addRenderPass(
+  TestRenderPass* child_pass = AddRenderPass(
       render_passes, child_pass_id, viewport_rect, gfx::Transform());
-  addQuad(child_pass, viewport_rect, SK_ColorBLUE);
+  AddQuad(child_pass, viewport_rect, SK_ColorBLUE);
 
-  addRenderPassQuad(root_pass, child_pass);
+  AddRenderPassQuad(root_pass, child_pass);
 
   // First render pass is not the root one, clearing should happen.
   EXPECT_CALL(*mock_context, clear(GL_COLOR_BUFFER_BIT)).Times(AtLeast(1));
 
   Expectation first_render_pass =
       EXPECT_CALL(*mock_context, drawElements(_, _, _, _)).Times(1);
 
   // The second render pass is the root one, clearing should be prevented.
   EXPECT_CALL(*mock_context, clear(GL_COLOR_BUFFER_BIT)).Times(0)
       .After(first_render_pass);
@@ skipping 42 matching lines @@
   EXPECT_TRUE(renderer.Initialize());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
 
   gfx::Rect viewport_rect(mock_client.DeviceViewportSize());
   ScopedPtrVector<RenderPass>& render_passes =
       *mock_client.render_passes_in_draw_order();
   render_passes.clear();
 
   gfx::Rect grand_child_rect(25, 25);
   RenderPass::Id grand_child_pass_id(3, 0);
-  TestRenderPass* grand_child_pass = addRenderPass(
+  TestRenderPass* grand_child_pass = AddRenderPass(
       render_passes, grand_child_pass_id, grand_child_rect, gfx::Transform());
-  addClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
+  AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
 
   gfx::Rect child_rect(50, 50);
   RenderPass::Id child_pass_id(2, 0);
   TestRenderPass* child_pass =
-      addRenderPass(render_passes, child_pass_id, child_rect, gfx::Transform());
-  addQuad(child_pass, child_rect, SK_ColorBLUE);
+      AddRenderPass(render_passes, child_pass_id, child_rect, gfx::Transform());
+  AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
   RenderPass::Id root_pass_id(1, 0);
-  TestRenderPass* root_pass = addRenderPass(
+  TestRenderPass* root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
-  addQuad(root_pass, viewport_rect, SK_ColorGREEN);
+  AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
-  addRenderPassQuad(root_pass, child_pass);
-  addRenderPassQuad(child_pass, grand_child_pass);
+  AddRenderPassQuad(root_pass, child_pass);
+  AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer.DecideRenderPassAllocationsForFrame(
       *mock_client.render_passes_in_draw_order());
   renderer.DrawFrame(*mock_client.render_passes_in_draw_order());
 }
 
 class OutputSurfaceMockContext : public TestWebGraphicsContext3D {
  public:
   // Specifically override methods even if they are unused (used in conjunction
   // with StrictMock). We need to make sure that GLRenderer does not issue
@@ skipping 43 matching lines @@
   virtual void SetUp() { EXPECT_TRUE(renderer_.Initialize()); }
 
   void SwapBuffers() { renderer_.SwapBuffers(); }
 
   void DrawFrame() {
     gfx::Rect viewport_rect(DeviceViewportSize());
     ScopedPtrVector<RenderPass>* render_passes = render_passes_in_draw_order();
     render_passes->clear();
 
     RenderPass::Id render_pass_id(1, 0);
-    TestRenderPass* render_pass = addRenderPass(
+    TestRenderPass* render_pass = AddRenderPass(
         *render_passes, render_pass_id, viewport_rect, gfx::Transform());
-    addQuad(render_pass, viewport_rect, SK_ColorGREEN);
+    AddQuad(render_pass, viewport_rect, SK_ColorGREEN);
 
     EXPECT_CALL(output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());
 
     EXPECT_CALL(output_surface_, Reshape(_)).Times(1);
 
     EXPECT_CALL(output_surface_, BindFramebuffer()).Times(1);
 
     EXPECT_CALL(*context(), drawElements(_, _, _, _)).Times(1);
 
     renderer_.DecideRenderPassAllocationsForFrame(*render_passes_in_draw_order());
@@ skipping 42 matching lines @@
   }
 };
 
 TEST_F(MockOutputSurfaceTestWithSendCompositorFrame, DrawFrame) {
   EXPECT_CALL(output_surface_, SendFrameToParentCompositor(_)).Times(1);
   DrawFrame();
 }
 
 }  // namespace
 }  // namespace cc