Fix cpplint errors in cc/(animation|input|layers|trees|test)/

cc/trees/layer_tree_host_impl_unittest.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 "cc/trees/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 976 matching lines @@
     EXPECT_EQ(4.f, metadata.max_page_scale_factor);
   }
 }
 
 class DidDrawCheckLayer : public TiledLayerImpl {
  public:
   static scoped_ptr<LayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
     return scoped_ptr<LayerImpl>(new DidDrawCheckLayer(tree_impl, id));
   }
 
-  virtual void DidDraw(ResourceProvider*) OVERRIDE {
+  virtual void DidDraw(ResourceProvider* provider) OVERRIDE {
     did_draw_called_ = true;
   }
 
-  virtual void WillDraw(ResourceProvider*) OVERRIDE {
+  virtual void WillDraw(ResourceProvider* provider) OVERRIDE {
     will_draw_called_ = true;
   }
 
   bool did_draw_called() const { return did_draw_called_; }
   bool will_draw_called() const { return will_draw_called_; }
 
   void ClearDidDrawCheck() {
     did_draw_called_ = false;
     will_draw_called_ = false;
   }
@@ skipping 1299 matching lines @@
   // without blending.
   layer1->SetContentsOpaque(false);
   layer1->SetQuadRect(gfx::Rect(5, 5, 5, 5));
   layer1->SetQuadVisibleRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(false, false);
   EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
-
 }
 
 TEST_F(LayerTreeHostImplTest, ViewportCovered) {
   host_impl_->InitializeRenderer(CreateOutputSurface());
   host_impl_->active_tree()->set_background_color(SK_ColorGRAY);
 
   gfx::Size viewport_size(1000, 1000);
   host_impl_->SetViewportSize(viewport_size, viewport_size);
 
   host_impl_->active_tree()->SetRootLayer(
@@ skipping 74 matching lines @@
     for (size_t i = 0; i < frame.render_passes[0]->quad_list.size(); ++i)
       num_gutter_quads += (frame.render_passes[0]->quad_list[i]->material ==
                            DrawQuad::SOLID_COLOR) ? 1 : 0;
     EXPECT_EQ(4u, num_gutter_quads);
     EXPECT_EQ(5u, frame.render_passes[0]->quad_list.size());
 
     LayerTestCommon::VerifyQuadsExactlyCoverRect(
         frame.render_passes[0]->quad_list, gfx::Rect(viewport_size));
     host_impl_->DidDrawAllLayers(frame);
   }
-
 }
 
 
 class ReshapeTrackerContext: public TestWebGraphicsContext3D {
  public:
   ReshapeTrackerContext() : reshape_called_(false) {}
 
   virtual void reshape(int width, int height) OVERRIDE {
     reshape_called_ = true;
   }
@@ skipping 220 matching lines @@
   MOCK_METHOD1(disable, void(WebKit::WGC3Denum cap));
   MOCK_METHOD4(scissor, void(WebKit::WGC3Dint x,
                              WebKit::WGC3Dint y,
                              WebKit::WGC3Dsizei width,
                              WebKit::WGC3Dsizei height));
 };
 
 class MockContextHarness {
  private:
   MockContext* context_;
+
  public:
-  MockContextHarness(MockContext* context)
+  explicit MockContextHarness(MockContext* context)
       : context_(context) {
     // Catch "uninteresting" calls
     EXPECT_CALL(*context_, useProgram(_))
         .Times(0);
 
     EXPECT_CALL(*context_, drawElements(_, _, _, _))
         .Times(0);
 
     // These are not asserted
     EXPECT_CALL(*context_, uniformMatrix4fv(_, _, _, _))
@@ skipping 25 matching lines @@
   }
 
   void MustDrawSolidQuad() {
     EXPECT_CALL(*context_, drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0))
         .WillOnce(Return())
         .RetiresOnSaturation();
 
     EXPECT_CALL(*context_, useProgram(_))
         .WillOnce(Return())
         .RetiresOnSaturation();
-
   }
 
   void MustSetScissor(int x, int y, int width, int height) {
     EXPECT_CALL(*context_, enable(GL_SCISSOR_TEST))
         .WillRepeatedly(Return());
 
     EXPECT_CALL(*context_, scissor(x, y, width, height))
         .Times(AtLeast(1))
         .WillRepeatedly(Return());
   }
@@ skipping 560 matching lines @@
     EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
 
     // Must receive 1 render pass - for the root.
     ASSERT_EQ(1U, frame.render_passes.size());
 
     EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
-
 }
 
 TEST_F(LayerTreeHostImplTest, TextureCachingWithOcclusionEarlyOut) {
   LayerTreeSettings settings;
   settings.minimum_occlusion_tracking_size = gfx::Size();
   settings.cache_render_pass_contents = true;
   scoped_ptr<LayerTreeHostImpl> my_host_impl =
       LayerTreeHostImpl::Create(settings,
                                 this,
                                 &proxy_,
@@ skipping 1281 matching lines @@
 
     "R0ssssA0sss\n"
     "A0sssB0C0s\n"
     "B0sssD0ss\n"
     "D0sssssss\n"
   }, {
     0, 0, 0
   }
 };
 
-static void VerifyRenderPassTestData(TestCase& test_case,
-                                     RenderPassRemovalTestData& test_data) {
+static void VerifyRenderPassTestData(
+    const TestCase& test_case,
+    const RenderPassRemovalTestData& test_data) {
   char actual_result[1024];
   DumpRenderPassTestData(test_data, actual_result);
   EXPECT_STREQ(test_case.expected_result, actual_result) << "In test case: " <<
       test_case.name;
 }
 
 TEST_F(LayerTreeHostImplTest, TestRemoveRenderPasses) {
   scoped_ptr<OutputSurface> output_surface(CreateOutputSurface());
   ASSERT_TRUE(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider =
       ResourceProvider::Create(output_surface.get());
 
   scoped_ptr<TestRenderer> renderer =
       TestRenderer::Create(resource_provider.get(),
                            output_surface.get(),
                            &proxy_);
 
   int test_case_index = 0;
   while (remove_render_passes_cases[test_case_index].name) {
     RenderPassRemovalTestData test_data;
     ConfigureRenderPassTestData(
         remove_render_passes_cases[test_case_index].init_script,
         test_data,
         renderer.get());
     LayerTreeHostImpl::RemoveRenderPasses(
-        LayerTreeHostImpl::CullRenderPassesWithCachedTextures(*renderer),
+        LayerTreeHostImpl::CullRenderPassesWithCachedTextures(renderer.get()),
         &test_data);
     VerifyRenderPassTestData(remove_render_passes_cases[test_case_index],
                              test_data);
     test_case_index++;
   }
 }
 
 class LayerTreeHostImplTestWithDelegatingRenderer
     : public LayerTreeHostImplTest {
  protected:
@@ skipping 331 matching lines @@
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 }
 
 }  // namespace
 }  // namespace cc