cc: Chromify gl_renderer_unittest.cc.

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/resources/prioritized_resource_manager.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/test/fake_impl_proxy.h"
@@ skipping 51 matching lines @@
     EXPECT_PROGRAM_VALID(renderer_->GetTileProgram());
     EXPECT_PROGRAM_VALID(renderer_->GetTileProgramOpaque());
     EXPECT_PROGRAM_VALID(renderer_->GetTileProgramAA());
     EXPECT_PROGRAM_VALID(renderer_->GetTileProgramSwizzle());
     EXPECT_PROGRAM_VALID(renderer_->GetTileProgramSwizzleOpaque());
     EXPECT_PROGRAM_VALID(renderer_->GetTileProgramSwizzleAA());
     EXPECT_PROGRAM_VALID(renderer_->GetTileCheckerboardProgram());
     EXPECT_PROGRAM_VALID(renderer_->GetDebugBorderProgram());
     EXPECT_PROGRAM_VALID(renderer_->GetSolidColorProgram());
     EXPECT_PROGRAM_VALID(renderer_->GetSolidColorProgramAA());
-    //TestShadersWithTexCoordPrecision(TexCoordPrecisionMedium);
+    // TestShadersWithTexCoordPrecision(TexCoordPrecisionMedium);
     TestShadersWithTexCoordPrecision(TexCoordPrecisionHigh);
     ASSERT_FALSE(renderer_->IsContextLost());
   }
 
   void TestShadersWithTexCoordPrecision(TexCoordPrecision precision) {
     EXPECT_PROGRAM_VALID(renderer_->GetRenderPassProgram(precision));
     EXPECT_PROGRAM_VALID(renderer_->GetRenderPassProgramAA(precision));
     EXPECT_PROGRAM_VALID(renderer_->GetRenderPassMaskProgram(precision));
     EXPECT_PROGRAM_VALID(renderer_->GetRenderPassMaskProgramAA(precision));
     EXPECT_PROGRAM_VALID(
@@ skipping 160 matching lines @@
                 new FrameCountingMemoryAllocationSettingContext()))),
         resource_provider_(ResourceProvider::Create(output_surface_.get(), 0)),
         renderer_(&mock_client_,
                   output_surface_.get(),
                   resource_provider_.get()) {}
 
   virtual void SetUp() { renderer_.Initialize(); }
 
   void SwapBuffers() { renderer_.SwapBuffers(); }
 
-  FrameCountingMemoryAllocationSettingContext* context() {
+  FrameCountingMemoryAllocationSettingContext* Context() {
     return static_cast<FrameCountingMemoryAllocationSettingContext*>(
         output_surface_->context3d());
   }
 
   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_;
 };
 
 // Closing the namespace here so that GLRendererShaderTest can take advantage
 // of the friend relationship with GLRenderer and all of the mock classes
 // declared above it.
-} // namespace
+}  // namespace
 
 class GLRendererShaderTest : public testing::Test {
  protected:
   GLRendererShaderTest()
       : output_surface_(FakeOutputSurface::Create3d()),
         resource_provider_(ResourceProvider::Create(output_surface_.get(), 0)),
         renderer_(GLRenderer::Create(&mock_client_, output_surface_.get(),

[danakj, 2013/04/17 17:44:59]

nit: one argument per line if they don't all fit on one line

[reveman, 2013/04/17 18:26:04]

Done.

-                                     resource_provider_.get(), 0)) {
-  }
+                                     resource_provider_.get(), 0)) {}
 
   void TestRenderPassProgram() {
     EXPECT_PROGRAM_VALID(renderer_->render_pass_program_);
     EXPECT_TRUE(renderer_->program_shadow_ ==
         renderer_->render_pass_program_->program());
   }
 
   void TestRenderPassColorMatrixProgram() {
     EXPECT_PROGRAM_VALID(renderer_->render_pass_color_matrix_program_);
     EXPECT_TRUE(renderer_->program_shadow_ ==
@@ skipping 41 matching lines @@
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<GLRenderer> renderer_;
 };
 
 namespace {
 
 // 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_);
+  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());
+  EXPECT_EQ(1, Context()->frame_count());
 }
 
 // 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,
     SuggestBackbufferNoShouldDiscardBackbufferAndDamageRootLayerIfNotVisible) {
   renderer_.SetVisible(false);
-  context()->SetMemoryAllocation(suggest_have_backbuffer_no_);
+  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:
 // 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_);
+  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:
 // 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_);
+  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_);
+  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:
 // 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_);
+  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());
   EXPECT_FALSE(renderer_.IsBackbufferDiscarded());
 
   SwapBuffers();
-  EXPECT_EQ(1, context()->frame_count());
+  EXPECT_EQ(1, Context()->frame_count());
 }
 
 TEST_F(GLRendererTest, FramebufferDiscardedAfterReadbackWhenNotVisible) {
   renderer_.SetVisible(false);
-  context()->SetMemoryAllocation(suggest_have_backbuffer_no_);
+  Context()->SetMemoryAllocation(suggest_have_backbuffer_no_);
   EXPECT_TRUE(renderer_.IsBackbufferDiscarded());
   EXPECT_EQ(1, mock_client_.set_full_root_layer_damage_count());
 
   char pixels[4];
   renderer_.DrawFrame(mock_client_.render_passes_in_draw_order());
   EXPECT_FALSE(renderer_.IsBackbufferDiscarded());
 
   renderer_.GetFramebufferPixels(pixels, gfx::Rect(0, 0, 1, 1));
   EXPECT_TRUE(renderer_.IsBackbufferDiscarded());
   EXPECT_EQ(2, mock_client_.set_full_root_layer_damage_count());
@@ skipping 594 matching lines @@
 
   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());
 }
 
 TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
-  gfx::Rect viewportRect(mock_client_.DeviceViewportSize());
-  ScopedPtrVector<RenderPass>* renderPasses =
-        mock_client_.render_passes_in_draw_order();
+  gfx::Rect viewport_rect(mock_client_.DeviceViewportSize());
+  ScopedPtrVector<RenderPass>* render_passes =
+      mock_client_.render_passes_in_draw_order();
 
-  gfx::Rect grandChildRect(25, 25);
-  RenderPass::Id grandChildPassId(3, 0);
-  TestRenderPass* grandChildPass;
+  gfx::Rect grand_child_rect(25, 25);
+  RenderPass::Id grand_child_pass_id(3, 0);
+  TestRenderPass* grand_child_pass;
 
-  gfx::Rect childRect(50, 50);
-  RenderPass::Id childPassId(2, 0);
-  TestRenderPass* childPass;
+  gfx::Rect child_rect(50, 50);
+  RenderPass::Id child_pass_id(2, 0);
+  TestRenderPass* child_pass;
 
-  RenderPass::Id rootPassId(1, 0);
-  TestRenderPass* rootPass;
+  RenderPass::Id root_pass_id(1, 0);
+  TestRenderPass* root_pass;
 
   cc::ResourceProvider::ResourceId mask =
   resource_provider_->CreateResource(gfx::Size(20, 12),
                                      resource_provider_->best_texture_format(),
                                      ResourceProvider::TextureUsageAny);
   resource_provider_->AllocateForTesting(mask);
 
   SkScalar matrix[20];
   float amount = 0.5f;
   matrix[0] = 0.213f + 0.787f * amount;
   matrix[1] = 0.715f - 0.715f * amount;
   matrix[2] = 1.f - (matrix[0] + matrix[1]);
   matrix[3] = matrix[4] = 0;
   matrix[5] = 0.213f - 0.213f * amount;
   matrix[6] = 0.715f + 0.285f * amount;
   matrix[7] = 1.f - (matrix[5] + matrix[6]);
   matrix[8] = matrix[9] = 0;
   matrix[10] = 0.213f - 0.213f * amount;
   matrix[11] = 0.715f - 0.715f * amount;
   matrix[12] = 1.f - (matrix[10] + matrix[11]);
   matrix[13] = matrix[14] = 0;
   matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0;
   matrix[18] = 1;
-  skia::RefPtr<SkColorFilter> colorFilter(skia::AdoptRef(
-      new SkColorMatrixFilter(matrix)));
-  skia::RefPtr<SkImageFilter> filter =
-      skia::AdoptRef(SkColorFilterImageFilter::Create(colorFilter.get(), NULL));
+  skia::RefPtr<SkColorFilter> color_filter(
+      skia::AdoptRef(new SkColorMatrixFilter(matrix)));
+  skia::RefPtr<SkImageFilter> filter = skia::AdoptRef(
+      SkColorFilterImageFilter::Create(color_filter.get(), NULL));
 
   gfx::Transform transform_causing_aa;
   transform_causing_aa.Rotate(20.0);
 
   // RenderPassProgram
-  renderPasses->clear();
+  render_passes->clear();
 
-  grandChildPass = AddRenderPass(renderPasses, grandChildPassId, grandChildRect,
-      gfx::Transform());
-  AddClippedQuad(grandChildPass, grandChildRect, SK_ColorYELLOW);
+  grand_child_pass = AddRenderPass(
+      render_passes, grand_child_pass_id, grand_child_rect, gfx::Transform());
+  AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
 
-  childPass = AddRenderPass(renderPasses, childPassId, childRect,
-      gfx::Transform());
-  AddQuad(childPass, childRect, SK_ColorBLUE);
+  child_pass = AddRenderPass(
+      render_passes, child_pass_id, child_rect, gfx::Transform());
+  AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
-  rootPass = AddRenderPass(renderPasses, rootPassId, viewportRect,
-      gfx::Transform());
-  AddQuad(rootPass, viewportRect, SK_ColorGREEN);
+  root_pass = AddRenderPass(
+      render_passes, root_pass_id, viewport_rect, gfx::Transform());
+  AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
-  AddRenderPassQuad(rootPass, childPass, 0, skia::RefPtr<SkImageFilter>(),
-      gfx::Transform());
-  AddRenderPassQuad(childPass, grandChildPass);
+  AddRenderPassQuad(root_pass,
+                    child_pass,
+                    0,
+                    skia::RefPtr<SkImageFilter>(),
+                    gfx::Transform());
+  AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *mock_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(mock_client_.render_passes_in_draw_order());
   TestRenderPassProgram();
 
   // RenderPassColorMatrixProgram
-  renderPasses->clear();
+  render_passes->clear();
 
-  grandChildPass = AddRenderPass(renderPasses, grandChildPassId, grandChildRect,
-      transform_causing_aa);
-  AddClippedQuad(grandChildPass, grandChildRect, SK_ColorYELLOW);
+  grand_child_pass = AddRenderPass(render_passes,
+                                   grand_child_pass_id,
+                                   grand_child_rect,
+                                   transform_causing_aa);
+  AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
 
-  childPass = AddRenderPass(renderPasses, childPassId, childRect,
-      transform_causing_aa);
-  AddQuad(childPass, childRect, SK_ColorBLUE);
+  child_pass = AddRenderPass(
+      render_passes, child_pass_id, child_rect, transform_causing_aa);
+  AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
-  rootPass = AddRenderPass(renderPasses, rootPassId, viewportRect,
-      gfx::Transform());
-  AddQuad(rootPass, viewportRect, SK_ColorGREEN);
+  root_pass = AddRenderPass(
+      render_passes, root_pass_id, viewport_rect, gfx::Transform());
+  AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
-  AddRenderPassQuad(rootPass, childPass, 0, filter, gfx::Transform());
-  AddRenderPassQuad(childPass, grandChildPass);
+  AddRenderPassQuad(root_pass, child_pass, 0, filter, gfx::Transform());
+  AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *mock_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(mock_client_.render_passes_in_draw_order());
   TestRenderPassColorMatrixProgram();
 
   // RenderPassMaskProgram
-  renderPasses->clear();
+  render_passes->clear();
 
-  grandChildPass = AddRenderPass(renderPasses, grandChildPassId, grandChildRect,
-      gfx::Transform());
-  AddClippedQuad(grandChildPass, grandChildRect, SK_ColorYELLOW);
+  grand_child_pass = AddRenderPass(render_passes,
+                                   grand_child_pass_id,
+                                   grand_child_rect,
+                                   gfx::Transform());
+  AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
 
-  childPass = AddRenderPass(renderPasses, childPassId, childRect,
-      gfx::Transform());
-  AddQuad(childPass, childRect, SK_ColorBLUE);
+  child_pass = AddRenderPass(
+      render_passes, child_pass_id, child_rect, gfx::Transform());
+  AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
-  rootPass = AddRenderPass(renderPasses, rootPassId, viewportRect,
-      gfx::Transform());
-  AddQuad(rootPass, viewportRect, SK_ColorGREEN);
+  root_pass = AddRenderPass(
+      render_passes, root_pass_id, viewport_rect, gfx::Transform());
+  AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
-  AddRenderPassQuad(rootPass, childPass, mask, skia::RefPtr<SkImageFilter>(),
-      gfx::Transform());
-  AddRenderPassQuad(childPass, grandChildPass);
+  AddRenderPassQuad(root_pass,
+                    child_pass,
+                    mask,
+                    skia::RefPtr<SkImageFilter>(),
+                    gfx::Transform());
+  AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *mock_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(mock_client_.render_passes_in_draw_order());
   TestRenderPassMaskProgram();
 
   // RenderPassMaskColorMatrixProgram
-  renderPasses->clear();
+  render_passes->clear();
 
-  grandChildPass = AddRenderPass(renderPasses, grandChildPassId, grandChildRect,
-      gfx::Transform());
-  AddClippedQuad(grandChildPass, grandChildRect, SK_ColorYELLOW);
+  grand_child_pass = AddRenderPass(
+      render_passes, grand_child_pass_id, grand_child_rect, gfx::Transform());
+  AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
 
-  childPass = AddRenderPass(renderPasses, childPassId, childRect,
-      gfx::Transform());
-  AddQuad(childPass, childRect, SK_ColorBLUE);
+  child_pass = AddRenderPass(
+      render_passes, child_pass_id, child_rect, gfx::Transform());
+  AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
-  rootPass = AddRenderPass(renderPasses, rootPassId, viewportRect,
-      gfx::Transform());
-  AddQuad(rootPass, viewportRect, SK_ColorGREEN);
+  root_pass = AddRenderPass(
+      render_passes, root_pass_id, viewport_rect, gfx::Transform());
+  AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
-  AddRenderPassQuad(rootPass, childPass, mask, filter, gfx::Transform());
-  AddRenderPassQuad(childPass, grandChildPass);
+  AddRenderPassQuad(root_pass, child_pass, mask, filter, gfx::Transform());
+  AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *mock_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(mock_client_.render_passes_in_draw_order());
   TestRenderPassMaskColorMatrixProgram();
 
   // RenderPassProgramAA
-  renderPasses->clear();
+  render_passes->clear();
 
-  grandChildPass = AddRenderPass(renderPasses, grandChildPassId, grandChildRect,
-      transform_causing_aa);
-  AddClippedQuad(grandChildPass, grandChildRect, SK_ColorYELLOW);
+  grand_child_pass = AddRenderPass(render_passes,
+                                   grand_child_pass_id,
+                                   grand_child_rect,
+                                   transform_causing_aa);
+  AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
 
-  childPass = AddRenderPass(renderPasses, childPassId, childRect,
-      transform_causing_aa);
-  AddQuad(childPass, childRect, SK_ColorBLUE);
+  child_pass = AddRenderPass(
+      render_passes, child_pass_id, child_rect, transform_causing_aa);
+  AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
-  rootPass = AddRenderPass(renderPasses, rootPassId, viewportRect,
-      gfx::Transform());
-  AddQuad(rootPass, viewportRect, SK_ColorGREEN);
+  root_pass = AddRenderPass(
+      render_passes, root_pass_id, viewport_rect, gfx::Transform());
+  AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
-  AddRenderPassQuad(rootPass, childPass, 0, skia::RefPtr<SkImageFilter>(),
-      transform_causing_aa);
-  AddRenderPassQuad(childPass, grandChildPass);
+  AddRenderPassQuad(root_pass,
+                    child_pass,
+                    0,
+                    skia::RefPtr<SkImageFilter>(),
+                    transform_causing_aa);
+  AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *mock_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(mock_client_.render_passes_in_draw_order());
   TestRenderPassProgramAA();
 
   // RenderPassColorMatrixProgramAA
-  renderPasses->clear();
+  render_passes->clear();
 
-  grandChildPass = AddRenderPass(renderPasses, grandChildPassId, grandChildRect,
-      transform_causing_aa);
-  AddClippedQuad(grandChildPass, grandChildRect, SK_ColorYELLOW);
+  grand_child_pass = AddRenderPass(render_passes,
+                                   grand_child_pass_id,
+                                   grand_child_rect,
+                                   transform_causing_aa);
+  AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
 
-  childPass = AddRenderPass(renderPasses, childPassId, childRect,
-      transform_causing_aa);
-  AddQuad(childPass, childRect, SK_ColorBLUE);
+  child_pass = AddRenderPass(
+      render_passes, child_pass_id, child_rect, transform_causing_aa);
+  AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
-  rootPass = AddRenderPass(renderPasses, rootPassId, viewportRect,
-      gfx::Transform());
-  AddQuad(rootPass, viewportRect, SK_ColorGREEN);
+  root_pass = AddRenderPass(
+      render_passes, root_pass_id, viewport_rect, gfx::Transform());
+  AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
-  AddRenderPassQuad(rootPass, childPass, 0, filter, transform_causing_aa);
-  AddRenderPassQuad(childPass, grandChildPass);
+  AddRenderPassQuad(root_pass, child_pass, 0, filter, transform_causing_aa);
+  AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *mock_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(mock_client_.render_passes_in_draw_order());
   TestRenderPassColorMatrixProgramAA();
 
   // RenderPassMaskProgramAA
-  renderPasses->clear();
+  render_passes->clear();
 
-  grandChildPass = AddRenderPass(renderPasses, grandChildPassId, grandChildRect,
+  grand_child_pass = AddRenderPass(render_passes,
+                                   grand_child_pass_id,
+                                   grand_child_rect,
+                                   transform_causing_aa);
+  AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
+
+  child_pass = AddRenderPass(render_passes, child_pass_id, child_rect,
       transform_causing_aa);
-  AddClippedQuad(grandChildPass, grandChildRect, SK_ColorYELLOW);
+  AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
-  childPass = AddRenderPass(renderPasses, childPassId, childRect,
+  root_pass = AddRenderPass(render_passes, root_pass_id, viewport_rect,
+      gfx::Transform());
+  AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
+
+  AddRenderPassQuad(root_pass, child_pass, mask, skia::RefPtr<SkImageFilter>(),
       transform_causing_aa);
-  AddQuad(childPass, childRect, SK_ColorBLUE);
-
-  rootPass = AddRenderPass(renderPasses, rootPassId, viewportRect,
-      gfx::Transform());
-  AddQuad(rootPass, viewportRect, SK_ColorGREEN);
-
-  AddRenderPassQuad(rootPass, childPass, mask, skia::RefPtr<SkImageFilter>(),
-      transform_causing_aa);
-  AddRenderPassQuad(childPass, grandChildPass);
+  AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *mock_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(mock_client_.render_passes_in_draw_order());
   TestRenderPassMaskProgramAA();
 
   // RenderPassMaskColorMatrixProgramAA
-  renderPasses->clear();
+  render_passes->clear();
 
-  grandChildPass = AddRenderPass(renderPasses, grandChildPassId, grandChildRect,
+  grand_child_pass = AddRenderPass(render_passes,
+                                   grand_child_pass_id,
+                                   grand_child_rect,
+                                   transform_causing_aa);
+  AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
+
+  child_pass = AddRenderPass(render_passes, child_pass_id, child_rect,
       transform_causing_aa);
-  AddClippedQuad(grandChildPass, grandChildRect, SK_ColorYELLOW);
+  AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
-  childPass = AddRenderPass(renderPasses, childPassId, childRect,
+  root_pass = AddRenderPass(render_passes, root_pass_id, viewport_rect,
       transform_causing_aa);
-  AddQuad(childPass, childRect, SK_ColorBLUE);
+  AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
-  rootPass = AddRenderPass(renderPasses, rootPassId, viewportRect,
-      transform_causing_aa);
-  AddQuad(rootPass, viewportRect, SK_ColorGREEN);
-
-  AddRenderPassQuad(rootPass, childPass, mask, filter, transform_causing_aa);
-  AddRenderPassQuad(childPass, grandChildPass);
+  AddRenderPassQuad(root_pass, child_pass, mask, filter, transform_causing_aa);
+  AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *mock_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(mock_client_.render_passes_in_draw_order());
   TestRenderPassMaskColorMatrixProgramAA();
 }
 
 class OutputSurfaceMockContext : public TestWebGraphicsContext3D {
  public:
   // Specifically override methods even if they are unused (used in conjunction
@@ skipping 54 matching lines @@
     TestRenderPass* render_pass = AddRenderPass(
         render_passes, render_pass_id, viewport_rect, gfx::Transform());
     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);
+    EXPECT_CALL(*Context(), drawElements(_, _, _, _)).Times(1);
 
     renderer_.DecideRenderPassAllocationsForFrame(
         *render_passes_in_draw_order());
     renderer_.DrawFrame(render_passes_in_draw_order());
   }
 
-  OutputSurfaceMockContext* context() {
+  OutputSurfaceMockContext* Context() {
     return static_cast<OutputSurfaceMockContext*>(output_surface_.context3d());
   }
 
   StrictMock<MockOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   FakeRendererGL renderer_;
 };
 
 TEST_F(MockOutputSurfaceTest, DrawFrameAndSwap) {
   DrawFrame();
@@ skipping 28 matching lines @@
   }
 };
 
 TEST_F(MockOutputSurfaceTestWithSendCompositorFrame, DrawFrame) {
   EXPECT_CALL(output_surface_, SendFrameToParentCompositor(_)).Times(1);
   DrawFrame();
 }
 
 }  // namespace
 }  // namespace cc