Remove user gesture tracking

sky/engine/core/frame/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 17 matching lines @@
 #include "sky/engine/core/frame/DOMTimer.h"
 
 #include "sky/engine/core/dom/ExecutionContext.h"
 #include "sky/engine/core/inspector/InspectorTraceEvents.h"
 #include "sky/engine/platform/Logging.h"
 #include "sky/engine/platform/TraceEvent.h"
 #include "sky/engine/wtf/CurrentTime.h"
 
 namespace blink {
 
-static const int maxIntervalForUserGestureForwarding = 1000; // One second matches Gecko.
 static const int maxTimerNestingLevel = 5;
 static const double oneMillisecond = 0.001;
 // Chromium uses a minimum timer interval of 4ms. We'd like to go
 // lower; however, there are poorly coded websites out there which do
 // create CPU-spinning loops.  Using 4ms prevents the CPU from
 // spinning too busily and provides a balance between CPU spinning and
 // the smallest possible interval timer.
 static const double minimumInterval = 0.004;
 
 static int timerNestingLevel = 0;
 
-static inline bool shouldForwardUserGesture(int interval, int nestingLevel)
-{
-    return UserGestureIndicator::processingUserGesture()
-        && interval <= maxIntervalForUserGestureForwarding
-        && nestingLevel == 1; // Gestures should not be forwarded to nested timers.
-}
-
 double DOMTimer::hiddenPageAlignmentInterval()
 {
     // Timers on hidden pages are aligned so that they fire once per
     // second at most.
     return 1.0;
 }
 
 double DOMTimer::visiblePageAlignmentInterval()
 {
     // Alignment does not apply to timers on visible pages.
@@ skipping 17 matching lines @@
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.stack"), "CallStack", TRACE_EVENT_SCOPE_PROCESS, "stack", InspectorCallStackEvent::currentCallStack());
 }
 
 DOMTimer::DOMTimer(ExecutionContext* context, PassOwnPtr<ScheduledAction> action, int interval, bool singleShot, int timeoutID)
     : SuspendableTimer(context)
     , m_timeoutID(timeoutID)
     , m_nestingLevel(timerNestingLevel + 1)
     , m_action(action)
 {
     ASSERT(timeoutID > 0);
-    if (shouldForwardUserGesture(interval, m_nestingLevel))
-        m_userGestureToken = UserGestureIndicator::currentToken();
 
     double intervalMilliseconds = std::max(oneMillisecond, interval * oneMillisecond);
     if (intervalMilliseconds < minimumInterval && m_nestingLevel >= maxTimerNestingLevel)
         intervalMilliseconds = minimumInterval;
     if (singleShot)
         startOneShot(intervalMilliseconds, FROM_HERE);
     else
         startRepeating(intervalMilliseconds, FROM_HERE);
 }
 
 DOMTimer::~DOMTimer()
 {
 }
 
 int DOMTimer::timeoutID() const
 {
     return m_timeoutID;
 }
 
 void DOMTimer::fired()
 {
     ExecutionContext* context = executionContext();
     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());
 
     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "TimerFire", "data", InspectorTimerFireEvent::data(context, m_timeoutID));
 
     // Simple case for non-one-shot timers.
     if (isActive()) {
         if (repeatInterval() && repeatInterval() < minimumInterval) {
             m_nestingLevel++;
             if (m_nestingLevel >= maxTimerNestingLevel)
                 augmentRepeatInterval(minimumInterval - repeatInterval());
         }
@@ skipping 64 matching lines @@
         if (fireTime - alignedTimeRoundedDown < minimumInterval)
             return alignedTimeRoundedDown;
 
         return alignedTimeRoundedUp;
     }
 
     return fireTime;
 }
 
 } // namespace blink