Distinguish actions registered with setTimeout() and setInterval().

Source/core/page/DOMTimer.cpp

 /*
  * Copyright (C) 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 50 matching lines @@
     // second at most.
     return 1.0;
 }
 
 double DOMTimer::visiblePageAlignmentInterval()
 {
     // Alignment does not apply to timers on visible pages.
     return 0;
 }
 
-int DOMTimer::install(ScriptExecutionContext* context, PassOwnPtr<ScheduledAction> action, int timeout, bool singleShot)
+int DOMTimer::install(ScriptExecutionContext* context, Type type, PassOwnPtr<ScheduledAction> action, int timeout)
 {
-    int timeoutID = context->installNewTimeout(action, timeout, singleShot);
-    InspectorInstrumentation::didInstallTimer(context, timeoutID, timeout, singleShot);
+    int timeoutID = context->installNewTimeout(type, action, timeout);
+    InspectorInstrumentation::didInstallTimer(context, timeoutID, timeout, type == TimeoutType); // FIXME: Fix inspector so it can accept a DOMTimer::Type value.
     return timeoutID;
 }
 
-void DOMTimer::removeByID(ScriptExecutionContext* context, int timeoutID)
+void DOMTimer::removeByIDIfTypeMatches(ScriptExecutionContext* context, Type type, int timeoutID)
 {
-    context->removeTimeoutByID(timeoutID);
+    // FIXME: Invoke didRemoveTimer() if a timer is actually removed.
+    context->removeTimeoutByIDIfTypeMatches(type, timeoutID);
     InspectorInstrumentation::didRemoveTimer(context, timeoutID);
 }
 
-DOMTimer::DOMTimer(ScriptExecutionContext* context, PassOwnPtr<ScheduledAction> action, int interval, bool singleShot, int timeoutID)
+DOMTimer::DOMTimer(ScriptExecutionContext* context, Type type, PassOwnPtr<ScheduledAction> action, int interval, int timeoutID)
     : SuspendableTimer(context)
+    , m_type(type)
     , m_timeoutID(timeoutID)
     , m_nestingLevel(timerNestingLevel + 1)
     , m_action(action)
 {
     ASSERT(timeoutID > 0);
     if (shouldForwardUserGesture(interval, m_nestingLevel))
         m_userGestureToken = UserGestureIndicator::currentToken();
 
     double intervalMilliseconds = max(oneMillisecond, interval * oneMillisecond);
     if (intervalMilliseconds < minimumInterval && m_nestingLevel >= maxTimerNestingLevel)
         intervalMilliseconds = minimumInterval;
-    if (singleShot)
+    switch (type) {
+    case TimeoutType:
         startOneShot(intervalMilliseconds);
-    else
+        break;
+    case IntervalType:
         startRepeating(intervalMilliseconds);
+        break;
+    }
 }
 
 DOMTimer::~DOMTimer()
 {
 }
 
 int DOMTimer::timeoutID() const
 {
     return m_timeoutID;
 }
 
+DOMTimer::Type DOMTimer::type() const
+{
+    return m_type;
+}
+
 void DOMTimer::fired()
 {
     ScriptExecutionContext* context = scriptExecutionContext();
     timerNestingLevel = m_nestingLevel;
     ASSERT(!context->activeDOMObjectsAreSuspended());
     // Only the first execution of a multi-shot timer should get an affirmative user gesture indicator.
     UserGestureIndicator gestureIndicator(m_userGestureToken.release());
 
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willFireTimer(context, m_timeoutID);
 
@@ skipping 10 matching lines @@
 
         InspectorInstrumentation::didFireTimer(cookie);
 
         return;
     }
 
     // Delete timer before executing the action for one-shot timers.
     OwnPtr<ScheduledAction> action = m_action.release();
 
     // This timer is being deleted; no access to member variables allowed after this point.
-    context->removeTimeoutByID(m_timeoutID);
+    bool removed = context->removeTimeoutByIDIfTypeMatches(m_type, m_timeoutID);
+    ASSERT_UNUSED(removed, removed);
 
     action->execute(context);
 
     InspectorInstrumentation::didFireTimer(cookie);
 
     timerNestingLevel = 0;
 }
 
 void DOMTimer::contextDestroyed()
 {
@@ skipping 18 matching lines @@
             return fireTime;
 
         double alignedTime = ceil(fireTime / alignmentInterval) * alignmentInterval;
         return alignedTime;
     }
 
     return fireTime;
 }
 
 } // namespace WebCore