bindings: Pass is_null flag to attribute setters when they are nullable

third_party/WebKit/Source/core/animation/AnimationTest.cpp

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 42 matching lines @@
     StartTimeline();
   }
 
   void SetUpWithoutStartingTimeline() {
     page_holder = DummyPageHolder::Create();
     document = &page_holder->GetDocument();
     document->GetAnimationClock().ResetTimeForTesting();
     timeline = AnimationTimeline::Create(document.Get());
     timeline->ResetForTesting();
     animation = timeline->Play(0);
-    animation->setStartTime(0);
+    animation->setStartTime(0, false);
     animation->setEffect(MakeAnimation());
   }
 
   void StartTimeline() { SimulateFrame(0); }
 
   KeyframeEffect* MakeAnimation(double duration = 30,
                                 double playback_rate = 1) {
     Timing timing;
     timing.iteration_duration = duration;
     timing.playback_rate = playback_rate;
@@ skipping 78 matching lines @@
 TEST_F(AnimationAnimationTest,
        SetCurrentTimeNegativeWithoutSimultaneousPlaybackRateChange) {
   SimulateFrame(20);
   EXPECT_EQ(20, animation->CurrentTimeInternal());
   EXPECT_EQ(Animation::kRunning, animation->PlayStateInternal());
   animation->setPlaybackRate(-1);
   EXPECT_EQ(Animation::kPending, animation->PlayStateInternal());
   SimulateFrame(30);
   EXPECT_EQ(20, animation->CurrentTimeInternal());
   EXPECT_EQ(Animation::kRunning, animation->PlayStateInternal());
-  animation->setCurrentTime(-10 * 1000);
+  animation->setCurrentTime(-10 * 1000, false);
   EXPECT_EQ(Animation::kFinished, animation->PlayStateInternal());
 }
 
 TEST_F(AnimationAnimationTest, SetCurrentTimePastContentEnd) {
-  animation->setCurrentTime(50 * 1000);
+  animation->setCurrentTime(50 * 1000, false);
   EXPECT_EQ(Animation::kFinished, animation->PlayStateInternal());
   EXPECT_EQ(50, animation->CurrentTimeInternal());
   SimulateFrame(20);
   EXPECT_EQ(Animation::kFinished, animation->PlayStateInternal());
   EXPECT_EQ(50, animation->CurrentTimeInternal());
 
   animation->setPlaybackRate(-2);
-  animation->setCurrentTime(50 * 1000);
+  animation->setCurrentTime(50 * 1000, false);
   EXPECT_EQ(Animation::kPending, animation->PlayStateInternal());
   EXPECT_EQ(50, animation->CurrentTimeInternal());
   SimulateFrame(20);
   EXPECT_EQ(Animation::kRunning, animation->PlayStateInternal());
   SimulateFrame(40);
   EXPECT_EQ(10, animation->CurrentTimeInternal());
 }
 
 TEST_F(AnimationAnimationTest, SetCurrentTimeMax) {
   animation->SetCurrentTimeInternal(std::numeric_limits<double>::max());
   EXPECT_EQ(std::numeric_limits<double>::max(),
             animation->CurrentTimeInternal());
   SimulateFrame(100);
   EXPECT_EQ(std::numeric_limits<double>::max(),
             animation->CurrentTimeInternal());
 }
 
 TEST_F(AnimationAnimationTest, SetCurrentTimeSetsStartTime) {
   EXPECT_EQ(0, animation->startTime());
-  animation->setCurrentTime(1000);
+  animation->setCurrentTime(1000, false);
   EXPECT_EQ(-1000, animation->startTime());
   SimulateFrame(1);
   EXPECT_EQ(-1000, animation->startTime());
   EXPECT_EQ(2000, animation->currentTime());
 }
 
 TEST_F(AnimationAnimationTest, SetStartTime) {
   SimulateFrame(20);
   EXPECT_EQ(Animation::kRunning, animation->PlayStateInternal());
   EXPECT_EQ(0, animation->StartTimeInternal());
   EXPECT_EQ(20 * 1000, animation->currentTime());
-  animation->setStartTime(10 * 1000);
+  animation->setStartTime(10 * 1000, false);
   EXPECT_EQ(Animation::kRunning, animation->PlayStateInternal());
   EXPECT_EQ(10, animation->StartTimeInternal());
   EXPECT_EQ(10 * 1000, animation->currentTime());
   SimulateFrame(30);
   EXPECT_EQ(10, animation->StartTimeInternal());
   EXPECT_EQ(20 * 1000, animation->currentTime());
-  animation->setStartTime(-20 * 1000);
+  animation->setStartTime(-20 * 1000, false);
   EXPECT_EQ(Animation::kFinished, animation->PlayStateInternal());
 }
 
 TEST_F(AnimationAnimationTest, SetStartTimeLimitsAnimation) {
-  animation->setStartTime(-50 * 1000);
+  animation->setStartTime(-50 * 1000, false);
   EXPECT_EQ(Animation::kFinished, animation->PlayStateInternal());
   EXPECT_EQ(30, animation->CurrentTimeInternal());
   animation->setPlaybackRate(-1);
   EXPECT_EQ(Animation::kPending, animation->PlayStateInternal());
-  animation->setStartTime(-100 * 1000);
+  animation->setStartTime(-100 * 1000, false);
   EXPECT_EQ(Animation::kFinished, animation->PlayStateInternal());
   EXPECT_EQ(0, animation->CurrentTimeInternal());
   EXPECT_TRUE(animation->Limited());
 }
 
 TEST_F(AnimationAnimationTest, SetStartTimeOnLimitedAnimation) {
   SimulateFrame(30);
-  animation->setStartTime(-10 * 1000);
+  animation->setStartTime(-10 * 1000, false);
   EXPECT_EQ(Animation::kFinished, animation->PlayStateInternal());
   EXPECT_EQ(30, animation->CurrentTimeInternal());
   animation->SetCurrentTimeInternal(50);
-  animation->setStartTime(-40 * 1000);
+  animation->setStartTime(-40 * 1000, false);
   EXPECT_EQ(30, animation->CurrentTimeInternal());
   EXPECT_EQ(Animation::kFinished, animation->PlayStateInternal());
   EXPECT_TRUE(animation->Limited());
 }
 
 TEST_F(AnimationAnimationTest, StartTimePauseFinish) {
   NonThrowableExceptionState exception_state;
   animation->pause();
   EXPECT_EQ(Animation::kPending, animation->PlayStateInternal());
   EXPECT_TRUE(std::isnan(animation->startTime()));
@@ skipping 132 matching lines @@
 }
 
 TEST_F(AnimationAnimationTest, ReverseSeeksToStart) {
   animation->SetCurrentTimeInternal(-10);
   animation->setPlaybackRate(-1);
   animation->reverse();
   EXPECT_EQ(0, animation->CurrentTimeInternal());
 }
 
 TEST_F(AnimationAnimationTest, ReverseSeeksToEnd) {
-  animation->setCurrentTime(40 * 1000);
+  animation->setCurrentTime(40 * 1000, false);
   animation->reverse();
   EXPECT_EQ(30, animation->CurrentTimeInternal());
 }
 
 TEST_F(AnimationAnimationTest, ReverseBeyondLimit) {
   animation->SetCurrentTimeInternal(40);
   animation->setPlaybackRate(-1);
   animation->reverse();
   EXPECT_EQ(Animation::kPending, animation->PlayStateInternal());
   EXPECT_EQ(0, animation->CurrentTimeInternal());
@@ skipping 11 matching lines @@
   EXPECT_EQ(Animation::kFinished, animation->PlayStateInternal());
 
   animation->setPlaybackRate(-1);
   animation->finish(exception_state);
   EXPECT_EQ(0, animation->CurrentTimeInternal());
   EXPECT_EQ(Animation::kFinished, animation->PlayStateInternal());
 }
 
 TEST_F(AnimationAnimationTest, FinishAfterEffectEnd) {
   NonThrowableExceptionState exception_state;
-  animation->setCurrentTime(40 * 1000);
+  animation->setCurrentTime(40 * 1000, false);
   animation->finish(exception_state);
   EXPECT_EQ(40, animation->CurrentTimeInternal());
 }
 
 TEST_F(AnimationAnimationTest, FinishBeforeStart) {
   NonThrowableExceptionState exception_state;
   animation->SetCurrentTimeInternal(-10);
   animation->setPlaybackRate(-1);
   animation->finish(exception_state);
   EXPECT_EQ(0, animation->CurrentTimeInternal());
@@ skipping 100 matching lines @@
   animation->setPlaybackRate(std::numeric_limits<double>::max());
   SimulateFrame(0);
   EXPECT_EQ(std::numeric_limits<double>::max(), animation->playbackRate());
   EXPECT_EQ(0, animation->CurrentTimeInternal());
   SimulateFrame(1);
   EXPECT_EQ(30, animation->CurrentTimeInternal());
 }
 
 TEST_F(AnimationAnimationTest, SetEffect) {
   animation = timeline->Play(0);
-  animation->setStartTime(0);
+  animation->setStartTime(0, false);
   AnimationEffectReadOnly* effect1 = MakeAnimation();
   AnimationEffectReadOnly* effect2 = MakeAnimation();
   animation->setEffect(effect1);
   EXPECT_EQ(effect1, animation->effect());
   EXPECT_EQ(0, animation->CurrentTimeInternal());
   animation->SetCurrentTimeInternal(15);
   animation->setEffect(effect2);
   EXPECT_EQ(15, animation->CurrentTimeInternal());
   EXPECT_EQ(0, effect1->GetAnimation());
   EXPECT_EQ(animation, effect2->GetAnimation());
@@ skipping 37 matching lines @@
   EXPECT_EQ(0, animation2->effect());
 }
 
 TEST_F(AnimationAnimationTest, AnimationsReturnTimeToNextEffect) {
   Timing timing;
   timing.start_delay = 1;
   timing.iteration_duration = 1;
   timing.end_delay = 1;
   KeyframeEffect* keyframe_effect = KeyframeEffect::Create(0, nullptr, timing);
   animation = timeline->Play(keyframe_effect);
-  animation->setStartTime(0);
+  animation->setStartTime(0, false);
 
   SimulateFrame(0);
   EXPECT_EQ(1, animation->TimeToEffectChange());
 
   SimulateFrame(0.5);
   EXPECT_EQ(0.5, animation->TimeToEffectChange());
 
   SimulateFrame(1);
   EXPECT_EQ(0, animation->TimeToEffectChange());
 
@@ skipping 116 matching lines @@
   EXPECT_EQ(0, animation->currentTime());
   EXPECT_TRUE(std::isnan(animation->startTime()));
   SimulateFrame(10);
   EXPECT_EQ(Animation::kRunning, animation->PlayStateInternal());
   EXPECT_EQ(0, animation->currentTime());
   EXPECT_EQ(10 * 1000, animation->startTime());
 }
 
 TEST_F(AnimationAnimationTest, PlayBackwardsAfterCancel) {
   animation->setPlaybackRate(-1);
-  animation->setCurrentTime(15 * 1000);
+  animation->setCurrentTime(15 * 1000, false);
   SimulateFrame(0);
   animation->cancel();
   EXPECT_EQ(Animation::kIdle, animation->PlayStateInternal());
   EXPECT_TRUE(std::isnan(animation->currentTime()));
   EXPECT_TRUE(std::isnan(animation->startTime()));
   animation->play();
   EXPECT_EQ(Animation::kPending, animation->PlayStateInternal());
   EXPECT_EQ(30 * 1000, animation->currentTime());
   EXPECT_TRUE(std::isnan(animation->startTime()));
   SimulateFrame(10);
@@ skipping 65 matching lines @@
       timeline->Play(keyframe_effect_not_composited);
 
   SimulateFrame(0, composited_element_ids);
   EXPECT_TRUE(animation_composited->CanStartAnimationOnCompositor(
       composited_element_ids));
   EXPECT_FALSE(animation_not_composited->CanStartAnimationOnCompositor(
       composited_element_ids));
 }
 
 }  // namespace blink