Bug 1264125 part 4 - Queue transitioncancel when animation status is idle. r?birtles draft
authorMantaroh Yoshinaga <mantaroh@gmail.com>
Tue, 20 Dec 2016 16:03:29 +0900
changeset 451398 89357c8a82bc81518ce688cd4b8ccb6b6371b8f8
parent 451397 7e3299a74fdfcca09d61e18edc4a5d60fcabf2d7
child 451399 c12e5b747c495205aa6a94940c7614244c3e4c86
push id39153
push usermantaroh@gmail.com
push dateTue, 20 Dec 2016 07:36:10 +0000
reviewersbirtles
bugs1264125
milestone53.0a1
Bug 1264125 part 4 - Queue transitioncancel when animation status is idle. r?birtles MozReview-Commit-ID: CsmIcWfKAID
layout/style/nsTransitionManager.cpp
--- a/layout/style/nsTransitionManager.cpp
+++ b/layout/style/nsTransitionManager.cpp
@@ -206,98 +206,112 @@ CSSTransition::QueueEvents()
     std::max(std::min((EffectEnd() - mEffect->SpecifiedTiming().mDelay),
                       computedTiming.mActiveDuration), zeroDuration);
 
   // TimeStamps to use for ordering the events when they are dispatched. We
   // use a TimeStamp so we can compare events produced by different elements,
   // perhaps even with different timelines.
   // The zero timestamp is for transitionrun events where we ignore the delay
   // for the purpose of ordering events.
-  TimeStamp zeroTimeStamp  = AnimationTimeToTimeStamp(zeroDuration);
-  TimeStamp startTimeStamp = ElapsedTimeToTimeStamp(intervalStartTime);
-  TimeStamp endTimeStamp   = ElapsedTimeToTimeStamp(intervalEndTime);
+  TimeStamp zeroTimeStamp   = AnimationTimeToTimeStamp(zeroDuration);
+  TimeStamp startTimeStamp  = ElapsedTimeToTimeStamp(intervalStartTime);
+  TimeStamp endTimeStamp    = ElapsedTimeToTimeStamp(intervalEndTime);
 
   TransitionPhase currentPhase;
   if (mPendingState != PendingState::NotPending &&
       (mPreviousTransitionPhase == TransitionPhase::Idle ||
        mPreviousTransitionPhase == TransitionPhase::Pending))
   {
     currentPhase = TransitionPhase::Pending;
   } else {
     currentPhase = static_cast<TransitionPhase>(computedTiming.mPhase);
   }
 
   AutoTArray<TransitionEventParams, 3> events;
+
+  // Handle cancel events firts
+  if (mPreviousTransitionPhase != TransitionPhase::Idle &&
+      currentPhase == TransitionPhase::Idle) {
+    // FIXME: bug 1264125: We will need to get active time when cancelling
+    //                     the transition.
+    StickyTimeDuration activeTime(0);
+    TimeStamp activeTimeStamp = ElapsedTimeToTimeStamp(activeTime);
+    events.AppendElement(TransitionEventParams{ eTransitionCancel,
+                                                activeTime,
+                                                activeTimeStamp });
+  }
+
+  // All other events
   switch (mPreviousTransitionPhase) {
     case TransitionPhase::Idle:
       if (currentPhase == TransitionPhase::Pending ||
           currentPhase == TransitionPhase::Before) {
         events.AppendElement(TransitionEventParams{ eTransitionRun,
-                                                   intervalStartTime,
-                                                   zeroTimeStamp });
+                                                    intervalStartTime,
+                                                    zeroTimeStamp });
       } else if (currentPhase == TransitionPhase::Active) {
         events.AppendElement(TransitionEventParams{ eTransitionRun,
-                                                   intervalStartTime,
-                                                   zeroTimeStamp });
+                                                    intervalStartTime,
+                                                    zeroTimeStamp });
         events.AppendElement(TransitionEventParams{ eTransitionStart,
-                                                   intervalStartTime,
-                                                   startTimeStamp });
+                                                    intervalStartTime,
+                                                    startTimeStamp });
       } else if (currentPhase == TransitionPhase::After) {
         events.AppendElement(TransitionEventParams{ eTransitionRun,
-                                                   intervalStartTime,
-                                                   zeroTimeStamp });
+                                                    intervalStartTime,
+                                                    zeroTimeStamp });
         events.AppendElement(TransitionEventParams{ eTransitionStart,
-                                                   intervalStartTime,
-                                                   startTimeStamp });
+                                                    intervalStartTime,
+                                                    startTimeStamp });
         events.AppendElement(TransitionEventParams{ eTransitionEnd,
-                                                   intervalEndTime,
-                                                   endTimeStamp });
+                                                    intervalEndTime,
+                                                    endTimeStamp });
       }
       break;
 
     case TransitionPhase::Pending:
     case TransitionPhase::Before:
       if (currentPhase == TransitionPhase::Active) {
         events.AppendElement(TransitionEventParams{ eTransitionStart,
-                                                   intervalStartTime,
-                                                   startTimeStamp });
+                                                    intervalStartTime,
+                                                    startTimeStamp });
       } else if (currentPhase == TransitionPhase::After) {
         events.AppendElement(TransitionEventParams{ eTransitionStart,
-                                                   intervalStartTime,
-                                                   startTimeStamp });
+                                                    intervalStartTime,
+                                                    startTimeStamp });
         events.AppendElement(TransitionEventParams{ eTransitionEnd,
-                                                   intervalEndTime,
-                                                   endTimeStamp });
+                                                    intervalEndTime,
+                                                    endTimeStamp });
       }
       break;
 
     case TransitionPhase::Active:
       if (currentPhase == TransitionPhase::After) {
         events.AppendElement(TransitionEventParams{ eTransitionEnd,
-                                                   intervalEndTime,
-                                                   endTimeStamp });
+                                                    intervalEndTime,
+                                                    endTimeStamp });
       } else if (currentPhase == TransitionPhase::Before) {
         events.AppendElement(TransitionEventParams{ eTransitionEnd,
-                                                   intervalStartTime,
-                                                   startTimeStamp });
+                                                    intervalStartTime,
+                                                    startTimeStamp });
       }
       break;
 
     case TransitionPhase::After:
       if (currentPhase == TransitionPhase::Active) {
         events.AppendElement(TransitionEventParams{ eTransitionStart,
-                                                   intervalEndTime,
-                                                   startTimeStamp });
+                                                    intervalEndTime,
+                                                    startTimeStamp });
       } else if (currentPhase == TransitionPhase::Before) {
         events.AppendElement(TransitionEventParams{ eTransitionStart,
-                                                   intervalEndTime,
-                                                   startTimeStamp });
+                                                    intervalEndTime,
+                                                    startTimeStamp });
         events.AppendElement(TransitionEventParams{ eTransitionEnd,
-                                                   intervalStartTime,
-                                                   endTimeStamp });
+                                                    intervalStartTime,
+                                                    endTimeStamp });
       }
       break;
   }
   mPreviousTransitionPhase = currentPhase;
 
   nsTransitionManager* manager = presContext->TransitionManager();
   for (const TransitionEventParams& evt : events) {
     manager->QueueEvent(TransitionEventInfo(owningElement, owningPseudoType,