[C++11 Allowed Features] Declares a type-safe null pointer converting from NULL to nullptr

cc/animation/layer_animation_controller_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/animation/layer_animation_controller.h"
 
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_registrar.h"
@@ skipping 89 matching lines @@
   // Synchronize the start times.
   EXPECT_EQ(1u, events.size());
   controller->NotifyAnimationStarted(events[0]);
   EXPECT_EQ(controller->GetAnimation(group_id,
                                      Animation::Opacity)->start_time(),
             controller_impl->GetAnimation(group_id,
                                           Animation::Opacity)->start_time());
 
   // Start the animation on the main thread. Should not affect the start time.
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_EQ(controller->GetAnimation(group_id,
                                      Animation::Opacity)->start_time(),
             controller_impl->GetAnimation(group_id,
                                           Animation::Opacity)->start_time());
 }
 
 TEST(LayerAnimationControllerTest, UseSpecifiedStartTimes) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
@@ skipping 28 matching lines @@
   EXPECT_EQ(start_time,
             controller->GetAnimation(group_id,
                                      Animation::Opacity)->start_time());
   EXPECT_EQ(controller->GetAnimation(group_id,
                                      Animation::Opacity)->start_time(),
             controller_impl->GetAnimation(group_id,
                                           Animation::Opacity)->start_time());
 
   // Start the animation on the main thread. Should not affect the start time.
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_EQ(start_time,
             controller->GetAnimation(group_id,
                                      Animation::Opacity)->start_time());
   EXPECT_EQ(controller->GetAnimation(group_id,
                                      Animation::Opacity)->start_time(),
             controller_impl->GetAnimation(group_id,
                                           Animation::Opacity)->start_time());
 }
 
 // Tests that controllers activate and deactivate as expected.
@@ skipping 33 matching lines @@
 
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->size());
   controller->NotifyAnimationStarted((*events)[0]);
 
   EXPECT_EQ(1u, registrar->active_animation_controllers().size());
   EXPECT_EQ(1u, registrar_impl->active_animation_controllers().size());
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_EQ(1u, registrar->active_animation_controllers().size());
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_EQ(Animation::Finished,
             controller->GetAnimation(Animation::Opacity)->run_state());
   EXPECT_EQ(1u, registrar->active_animation_controllers().size());
 
   events.reset(new AnimationEventsVector);
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1500));
   controller_impl->UpdateState(true, events.get());
 
   EXPECT_EQ(Animation::WaitingForDeletion,
             controller_impl->GetAnimation(Animation::Opacity)->run_state());
   // The impl thread controller should have de-activated.
   EXPECT_EQ(0u, registrar_impl->active_animation_controllers().size());
 
   EXPECT_EQ(1u, events->size());
   controller->NotifyAnimationFinished((*events)[0]);
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
 
   EXPECT_EQ(Animation::WaitingForDeletion,
             controller->GetAnimation(Animation::Opacity)->run_state());
   // The main thread controller should have de-activated.
   EXPECT_EQ(0u, registrar->active_animation_controllers().size());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
   EXPECT_FALSE(controller->has_any_animation());
   EXPECT_FALSE(controller_impl->has_any_animation());
   EXPECT_EQ(0u, registrar->active_animation_controllers().size());
   EXPECT_EQ(0u, registrar_impl->active_animation_controllers().size());
 
-  controller->SetAnimationRegistrar(NULL);
-  controller_impl->SetAnimationRegistrar(NULL);
+  controller->SetAnimationRegistrar(nullptr);
+  controller_impl->SetAnimationRegistrar(nullptr);
 }
 
 TEST(LayerAnimationControllerTest, SyncPause) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
@@ skipping 11 matching lines @@
   EXPECT_TRUE(controller_impl->GetAnimation(group_id, Animation::Opacity));
   EXPECT_EQ(Animation::WaitingForTargetAvailability,
             controller_impl->GetAnimation(group_id,
                                           Animation::Opacity)->run_state());
 
   // Start the animations on each controller.
   AnimationEventsVector events;
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, &events);
   controller->Animate(kInitialTickTime);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_EQ(Animation::Running,
             controller_impl->GetAnimation(group_id,
                                           Animation::Opacity)->run_state());
   EXPECT_EQ(Animation::Running,
             controller->GetAnimation(group_id,
                                      Animation::Opacity)->run_state());
 
   // Pause the main-thread animation.
   controller->PauseAnimation(
       animation_id,
@@ skipping 64 matching lines @@
       make_scoped_ptr(new AnimationEventsVector));
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
   controller_impl->AddValueObserver(&dummy_impl);
 
   AddOpacityTransitionToController(controller.get(), 1.0, 0.0f, 1.0f, false);
   controller->Animate(kInitialTickTime);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
 
   controller_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller_impl->UpdateState(true, events.get());
 
   // There should be a Started event for the animation.
   EXPECT_EQ(1u, events->size());
   EXPECT_EQ(AnimationEvent::Started, (*events)[0].type);
   controller->NotifyAnimationStarted((*events)[0]);
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
 
   EXPECT_FALSE(dummy.animation_waiting_for_deletion());
   EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());
 
   events.reset(new AnimationEventsVector);
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(2000));
   controller_impl->UpdateState(true, events.get());
 
   EXPECT_TRUE(dummy_impl.animation_waiting_for_deletion());
 
   // There should be a Finished event for the animation.
   EXPECT_EQ(1u, events->size());
   EXPECT_EQ(AnimationEvent::Finished, (*events)[0].type);
 
   // Neither controller should have deleted the animation yet.
   EXPECT_TRUE(controller->GetAnimation(Animation::Opacity));
   EXPECT_TRUE(controller_impl->GetAnimation(Animation::Opacity));
 
   controller->NotifyAnimationFinished((*events)[0]);
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
 
   // Both controllers should now have deleted the animation. The impl controller
   // should have deleted the animation even though activation has not occurred,
   // since the animation was already waiting for deletion when
   // PushAnimationUpdatesTo was called.
   EXPECT_FALSE(controller->has_any_animation());
   EXPECT_FALSE(controller_impl->has_any_animation());
@@ skipping 269 matching lines @@
       controller_impl->GetAnimation(Animation::ScrollOffset)
           ->curve()
           ->Duration();
   TimeDelta duration = TimeDelta::FromMicroseconds(
       duration_in_seconds * base::Time::kMicrosecondsPerSecond);
   EXPECT_EQ(
       duration_in_seconds,
       controller->GetAnimation(Animation::ScrollOffset)->curve()->Duration());
 
   controller->Animate(kInitialTickTime);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy.scroll_offset());
 
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy_impl.scroll_offset());
   // Scroll offset animations should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   controller->NotifyAnimationStarted((*events)[0]);
   controller->Animate(kInitialTickTime + duration / 2);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(200.f, 250.f), dummy.scroll_offset());
 
   controller_impl->Animate(kInitialTickTime + duration / 2);
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(200.f, 250.f),
                       dummy_impl.scroll_offset());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   controller_impl->Animate(kInitialTickTime + duration);
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(target_value, dummy_impl.scroll_offset());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   controller->Animate(kInitialTickTime + duration);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_VECTOR2DF_EQ(target_value, dummy.scroll_offset());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 // Ensure that when the impl controller doesn't have a value provider,
 // the main-thread controller's value provider is used to obtain the intial
 // scroll offset.
 TEST(LayerAnimationControllerTest, ScrollOffsetTransitionNoImplProvider) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
@@ skipping 26 matching lines @@
   EXPECT_TRUE(controller_impl->GetAnimation(Animation::ScrollOffset));
   double duration_in_seconds =
       controller_impl->GetAnimation(Animation::ScrollOffset)
           ->curve()
           ->Duration();
   EXPECT_EQ(
       duration_in_seconds,
       controller->GetAnimation(Animation::ScrollOffset)->curve()->Duration());
 
   controller->Animate(kInitialTickTime);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy.scroll_offset());
 
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy_impl.scroll_offset());
   // Scroll offset animations should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   TimeDelta duration = TimeDelta::FromMicroseconds(
       duration_in_seconds * base::Time::kMicrosecondsPerSecond);
 
   controller->NotifyAnimationStarted((*events)[0]);
   controller->Animate(kInitialTickTime + duration / 2);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(400.f, 150.f), dummy.scroll_offset());
 
   controller_impl->Animate(kInitialTickTime + duration / 2);
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(400.f, 150.f),
                       dummy_impl.scroll_offset());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   controller_impl->Animate(kInitialTickTime + duration);
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(target_value, dummy_impl.scroll_offset());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   controller->Animate(kInitialTickTime + duration);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_VECTOR2DF_EQ(target_value, dummy.scroll_offset());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 TEST(LayerAnimationControllerTest, ScrollOffsetTransitionOnImplOnly) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   scoped_ptr<AnimationEventsVector> events(
@@ skipping 742 matching lines @@
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(2.0)).Pass(),
       4,
       Animation::Transform));
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       5,
       Animation::Opacity));
 
   controller->Animate(kInitialTickTime);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
 
   EXPECT_EQ(Animation::Finished,
             controller->GetAnimation(1, Animation::Transform)->run_state());
   EXPECT_EQ(Animation::Finished,
             controller->GetAnimation(2, Animation::Opacity)->run_state());
   EXPECT_EQ(Animation::Running,
             controller->GetAnimation(3, Animation::Transform)->run_state());
   EXPECT_EQ(Animation::WaitingForTargetAvailability,
             controller->GetAnimation(4, Animation::Transform)->run_state());
   EXPECT_EQ(Animation::Running,
@@ skipping 32 matching lines @@
   controller_impl->ActivateAnimations();
   EXPECT_TRUE(controller_impl->GetAnimation(group_id, Animation::Opacity));
 
   controller->AbortAnimations(Animation::Opacity);
   EXPECT_EQ(Animation::Aborted,
             controller->GetAnimation(Animation::Opacity)->run_state());
   EXPECT_FALSE(dummy.animation_waiting_for_deletion());
   EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());
 
   controller->Animate(kInitialTickTime);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
   EXPECT_EQ(Animation::WaitingForDeletion,
             controller->GetAnimation(Animation::Opacity)->run_state());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
   EXPECT_FALSE(controller->GetAnimation(group_id, Animation::Opacity));
   EXPECT_FALSE(controller_impl->GetAnimation(group_id, Animation::Opacity));
 }
 
@@ skipping 28 matching lines @@
   EXPECT_EQ(1u, events.size());
   EXPECT_EQ(AnimationEvent::Aborted, events[0].type);
   EXPECT_EQ(Animation::WaitingForDeletion,
             controller_impl->GetAnimation(Animation::Opacity)->run_state());
 
   controller->NotifyAnimationAborted(events[0]);
   EXPECT_EQ(Animation::Aborted,
             controller->GetAnimation(Animation::Opacity)->run_state());
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
   EXPECT_EQ(Animation::WaitingForDeletion,
             controller->GetAnimation(Animation::Opacity)->run_state());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
   EXPECT_FALSE(controller->GetAnimation(group_id, Animation::Opacity));
   EXPECT_FALSE(controller_impl->GetAnimation(group_id, Animation::Opacity));
 }
 
@@ skipping 567 matching lines @@
   // been ticked at the new animation's starting point.
   EXPECT_EQ(Animation::Running,
             controller_impl->GetAnimation(second_animation_group_id,
                                           Animation::Opacity)->run_state());
   EXPECT_EQ(1.f, pending_dummy_impl.opacity());
   EXPECT_EQ(1.f, dummy_impl.opacity());
 }
 
 }  // namespace
 }  // namespace cc