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

cc/trees/layer_tree_host_unittest_animation.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/trees/layer_tree_host.h"
 
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/timing_function.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/test/fake_content_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/layer_tree_test.h"
 
 namespace cc {
 namespace {
 
 class LayerTreeHostAnimationTest : public LayerTreeTest {
  public:
   virtual void SetupTree() OVERRIDE {
     LayerTreeTest::SetupTree();
     layer_tree_host()->root_layer()->set_layer_animation_delegate(this);
   }
 };
 
 // Makes sure that SetNeedsAnimate does not cause the CommitRequested() state to
 // be set.
-class LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested :
-    public LayerTreeHostAnimationTest {
+class LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested
+    : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested()
       : num_commits_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void Animate(base::TimeTicks monotonic_time) OVERRIDE {
     // We skip the first commit becasue its the commit that populates the
@@ skipping 29 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested)
 
 // Trigger a frame with SetNeedsCommit. Then, inside the resulting animate
 // callback, requet another frame using SetNeedsAnimate. End the test when
 // animate gets called yet-again, indicating that the proxy is correctly
 // handling the case where SetNeedsAnimate() is called inside the begin frame
 // flow.
-class LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback :
-    public LayerTreeHostAnimationTest {
+class LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback
+    : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback()
       : num_animates_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void Animate(base::TimeTicks) OVERRIDE {
     if (!num_animates_) {
       layer_tree_host()->SetNeedsAnimate();
       num_animates_++;
       return;
     }
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_animates_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback)
 
 // Add a layer animation and confirm that
 // LayerTreeHostImpl::updateAnimationState does get called and continues to
 // get called.
-class LayerTreeHostAnimationTestAddAnimation :
-    public LayerTreeHostAnimationTest {
+class LayerTreeHostAnimationTestAddAnimation
+    : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAddAnimation()
       : num_animates_(0)
       , received_animation_started_notification_(false)
       , start_time_(0.0) {
   }
 
   virtual void BeginTest() OVERRIDE {
     PostAddInstantAnimationToMainThread();
   }
@@ skipping 29 matching lines @@
  private:
   int num_animates_;
   bool received_animation_started_notification_;
   double start_time_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAddAnimation)
 
 // Add a layer animation to a layer, but continually fail to draw. Confirm that
 // after a while, we do eventually force a draw.
-class LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws :
-    public LayerTreeHostAnimationTest {
+class LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws
+    : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws()
       : started_animating_(false) {}
 
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   virtual void AnimateLayers(
       LayerTreeHostImpl* host_impl,
       base::TimeTicks monotonic_time) OVERRIDE {
     started_animating_ = true;
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl*) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* tree_impl) OVERRIDE {
     if (started_animating_)
       EndTest();
   }
 
   virtual bool PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
       bool result) OVERRIDE {
     return false;
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   bool started_animating_;
 };
 
 // Starvation can only be an issue with the MT compositor.
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws)
 
 // Ensures that animations continue to be ticked when we are backgrounded.
-class LayerTreeHostAnimationTestTickAnimationWhileBackgrounded :
-    public LayerTreeHostAnimationTest {
+class LayerTreeHostAnimationTestTickAnimationWhileBackgrounded
+    : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestTickAnimationWhileBackgrounded()
       : num_animates_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   // Use WillAnimateLayers to set visible false before the animation runs and
   // causes a commit, so we block the second visible animate in single-thread
@@ skipping 16 matching lines @@
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_animates_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestTickAnimationWhileBackgrounded)
 
 // Ensures that animations continue to be ticked when we are backgrounded.
-class LayerTreeHostAnimationTestAddAnimationWithTimingFunction :
-    public LayerTreeHostAnimationTest {
+class LayerTreeHostAnimationTestAddAnimationWithTimingFunction
+    : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAddAnimationWithTimingFunction() {}
 
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   virtual void AnimateLayers(
       LayerTreeHostImpl* host_impl,
       base::TimeTicks monotonic_time) OVERRIDE {
@@ skipping 27 matching lines @@
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAddAnimationWithTimingFunction)
 
 // Ensures that main thread animations have their start times synchronized with
 // impl thread animations.
-class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes :
-    public LayerTreeHostAnimationTest {
+class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes
+    : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestSynchronizeAnimationStartTimes()
       : main_start_time_(-1.0),
         impl_start_time_(-1.0) {}
 
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   virtual void notifyAnimationStarted(double time) OVERRIDE {
@@ skipping 31 matching lines @@
 
  private:
   double main_start_time_;
   double impl_start_time_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestSynchronizeAnimationStartTimes)
 
 // Ensures that notify animation finished is called.
-class LayerTreeHostAnimationTestAnimationFinishedEvents :
-    public LayerTreeHostAnimationTest {
+class LayerTreeHostAnimationTestAnimationFinishedEvents
+    : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAnimationFinishedEvents() {}
 
   virtual void BeginTest() OVERRIDE {
     PostAddInstantAnimationToMainThread();
   }
 
   virtual void notifyAnimationFinished(double time) OVERRIDE {
     LayerAnimationController* controller =
         layer_tree_host()->root_layer()->layer_animation_controller();
     Animation* animation =
         controller->GetAnimation(0, Animation::Opacity);
     if (animation)
       controller->RemoveAnimation(animation->id());
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAnimationFinishedEvents)
 
 // Ensures that when opacity is being animated, this value does not cause the
 // subtree to be skipped.
-class LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity :
-    public LayerTreeHostAnimationTest {
+class LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity
+    : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity()
       : update_check_layer_(FakeContentLayer::Create(&client_)) {
   }
 
   virtual void SetupTree() OVERRIDE {
     update_check_layer_->SetOpacity(0.f);
     layer_tree_host()->SetRootLayer(update_check_layer_);
     LayerTreeHostAnimationTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(update_check_layer_.get());
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* tree_impl) OVERRIDE {
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {
     // Update() should have been called once, proving that the layer was not
     // skipped.
     EXPECT_EQ(1, update_check_layer_->update_count());
 
     // clear update_check_layer_ so LayerTreeHost dies.
     update_check_layer_ = NULL;
   }
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> update_check_layer_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity)
 
 // Layers added to tree with existing active animations should have the
 // animation correctly recognized.
-class LayerTreeHostAnimationTestLayerAddedWithAnimation :
-    public LayerTreeHostAnimationTest {
+class LayerTreeHostAnimationTestLayerAddedWithAnimation
+    : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestLayerAddedWithAnimation() {}
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommit() OVERRIDE {
     if (layer_tree_host()->commit_number() == 1) {
       scoped_refptr<Layer> layer = Layer::Create();
@@ skipping 16 matching lines @@
       base::TimeTicks monotonic_time) OVERRIDE {
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestLayerAddedWithAnimation)
 
-class LayerTreeHostAnimationTestCompositeAndReadbackAnimateCount :
-    public LayerTreeHostAnimationTest {
+class LayerTreeHostAnimationTestCompositeAndReadbackAnimateCount
+    : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestCompositeAndReadbackAnimateCount()
       : animated_commit_(-1) {
   }
 
   virtual void Animate(base::TimeTicks) OVERRIDE {
     // We shouldn't animate on the CompositeAndReadback-forced commit, but we
     // should for the SetNeedsCommit-triggered commit.
     animated_commit_ = layer_tree_host()->commit_number();
     EXPECT_NE(2, animated_commit_);
@@ skipping 28 matching lines @@
   virtual void AfterTest() OVERRIDE {
     EXPECT_EQ(3, animated_commit_);
   }
 
  private:
   int animated_commit_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestCompositeAndReadbackAnimateCount)
 
-class LayerTreeHostAnimationTestContinuousAnimate :
-    public LayerTreeHostAnimationTest {
+class LayerTreeHostAnimationTestContinuousAnimate
+    : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestContinuousAnimate()
       : num_commit_complete_(0),
         num_draw_layers_(0) {
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void Animate(base::TimeTicks) OVERRIDE {
     if (num_draw_layers_ == 2)
       return;
     layer_tree_host()->SetNeedsAnimate();
   }
 
   virtual void Layout() OVERRIDE {
     layer_tree_host()->root_layer()->SetNeedsDisplay();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* tree_impl) OVERRIDE {
     if (num_draw_layers_ == 1)
       num_commit_complete_++;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     num_draw_layers_++;
     if (num_draw_layers_ == 2)
       EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {
     // Check that we didn't commit twice between first and second draw.
     EXPECT_EQ(1, num_commit_complete_);
   }
 
  private:
   int num_commit_complete_;
   int num_draw_layers_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestContinuousAnimate)
 
 }  // namespace
 }  // namespace cc