UserGestureIndicator is a mess. Clean it up.

third_party/WebKit/Source/core/loader/NavigationScheduler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2009 Adam Barth. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 60 matching lines @@
   ScheduledRedirect,
   ScheduledLocationChange,
   ScheduledPageBlock,
 
   ScheduledLastEntry
 };
 
 // If the current frame has a provisional document loader, a scheduled
 // navigation might abort that load. Log those occurrences until
 // crbug.com/557430 is resolved.
-void maybeLogScheduledNavigationClobber(
-    ScheduledNavigationType type,
-    LocalFrame* frame,
-    const FrameLoadRequest& request,
-    UserGestureIndicator* gestureIndicator) {
+void maybeLogScheduledNavigationClobber(ScheduledNavigationType type,
+                                        LocalFrame* frame) {
   if (!frame->loader().provisionalDocumentLoader())
     return;
   // Include enumeration values userGesture variants.
   DEFINE_STATIC_LOCAL(EnumerationHistogram, scheduledNavigationClobberHistogram,
                       ("Navigation.Scheduled.MaybeCausedAbort",
                        ScheduledNavigationType::ScheduledLastEntry * 2));
 
-  UserGestureToken* gestureToken = gestureIndicator->currentToken();
-  int value = gestureToken->hasGestures() ? type + ScheduledLastEntry : type;
+  UserGestureToken* gestureToken = UserGestureIndicator::currentToken();
+  int value = gestureToken && gestureToken->hasGestures()
+                  ? type + ScheduledLastEntry
+                  : type;
   scheduledNavigationClobberHistogram.count(value);
 
   DEFINE_STATIC_LOCAL(
       CustomCountHistogram, scheduledClobberAbortTimeHistogram,
       ("Navigation.Scheduled.MaybeCausedAbort.Time", 1, 10000, 50));
   double navigationStart =
       frame->loader().provisionalDocumentLoader()->timing().navigationStart();
   if (navigationStart)
     scheduledClobberAbortTimeHistogram.count(monotonicallyIncreasingTime() -
                                              navigationStart);
 }
 
 }  // namespace
 
 unsigned NavigationDisablerForUnload::s_navigationDisableCount = 0;
 
 class ScheduledNavigation
     : public GarbageCollectedFinalized<ScheduledNavigation> {
   WTF_MAKE_NONCOPYABLE(ScheduledNavigation);
 
  public:
   ScheduledNavigation(double delay,
                       Document* originDocument,
                       bool replacesCurrentItem,
                       bool isLocationChange)
       : m_delay(delay),
         m_originDocument(originDocument),
         m_replacesCurrentItem(replacesCurrentItem),
-        m_isLocationChange(isLocationChange),
-        m_wasUserGesture(UserGestureIndicator::processingUserGesture()) {
-    if (m_wasUserGesture)
+        m_isLocationChange(isLocationChange) {
+    if (UserGestureIndicator::processingUserGesture())
       m_userGestureToken = UserGestureIndicator::currentToken();
   }
   virtual ~ScheduledNavigation() {}
 
   virtual void fire(LocalFrame*) = 0;
 
   virtual bool shouldStartTimer(LocalFrame*) { return true; }
 
   double delay() const { return m_delay; }
   Document* originDocument() const { return m_originDocument.get(); }
   bool replacesCurrentItem() const { return m_replacesCurrentItem; }
   bool isLocationChange() const { return m_isLocationChange; }
   std::unique_ptr<UserGestureIndicator> createUserGestureIndicator() {
-    if (m_wasUserGesture && m_userGestureToken)
-      return wrapUnique(new UserGestureIndicator(m_userGestureToken));
-    return wrapUnique(
-        new UserGestureIndicator(DefinitelyNotProcessingUserGesture));
+    return wrapUnique(new UserGestureIndicator(m_userGestureToken));
   }
 
   DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_originDocument); }
 
  protected:
-  void clearUserGesture() { m_wasUserGesture = false; }
+  void clearUserGesture() { m_userGestureToken.clear(); }
 
  private:
   double m_delay;
   Member<Document> m_originDocument;
   bool m_replacesCurrentItem;
   bool m_isLocationChange;
-  bool m_wasUserGesture;
   RefPtr<UserGestureToken> m_userGestureToken;
 };
 
 class ScheduledURLNavigation : public ScheduledNavigation {
  protected:
   ScheduledURLNavigation(double delay,
                          Document* originDocument,
                          const String& url,
                          bool replacesCurrentItem,
                          bool isLocationChange)
@@ skipping 13 matching lines @@
     std::unique_ptr<UserGestureIndicator> gestureIndicator =
         createUserGestureIndicator();
     FrameLoadRequest request(originDocument(), m_url, "_self",
                              m_shouldCheckMainWorldContentSecurityPolicy);
     request.setReplacesCurrentItem(replacesCurrentItem());
     request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
 
     ScheduledNavigationType type =
         isLocationChange() ? ScheduledNavigationType::ScheduledLocationChange
                            : ScheduledNavigationType::ScheduledURLNavigation;
-    maybeLogScheduledNavigationClobber(type, frame, request,
-                                       gestureIndicator.get());
+    maybeLogScheduledNavigationClobber(type, frame);
     frame->loader().load(request);
   }
 
   String url() const { return m_url; }
 
  private:
   String m_url;
   ContentSecurityPolicyDisposition m_shouldCheckMainWorldContentSecurityPolicy;
 };
 
@@ skipping 15 matching lines @@
     std::unique_ptr<UserGestureIndicator> gestureIndicator =
         createUserGestureIndicator();
     FrameLoadRequest request(originDocument(), url(), "_self");
     request.setReplacesCurrentItem(replacesCurrentItem());
     if (equalIgnoringFragmentIdentifier(frame->document()->url(),
                                         request.resourceRequest().url()))
       request.resourceRequest().setCachePolicy(
           WebCachePolicy::ValidatingCacheData);
     request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
     maybeLogScheduledNavigationClobber(
-        ScheduledNavigationType::ScheduledRedirect, frame, request,
-        gestureIndicator.get());
+        ScheduledNavigationType::ScheduledRedirect, frame);
     frame->loader().load(request);
   }
 
  private:
   ScheduledRedirect(double delay,
                     Document* originDocument,
                     const String& url,
                     bool replacesCurrentItem)
       : ScheduledURLNavigation(delay,
                                originDocument,
@@ skipping 31 matching lines @@
   void fire(LocalFrame* frame) override {
     std::unique_ptr<UserGestureIndicator> gestureIndicator =
         createUserGestureIndicator();
     ResourceRequest resourceRequest = frame->loader().resourceRequestForReload(
         FrameLoadTypeReload, KURL(), ClientRedirectPolicy::ClientRedirect);
     if (resourceRequest.isNull())
       return;
     FrameLoadRequest request = FrameLoadRequest(nullptr, resourceRequest);
     request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
     maybeLogScheduledNavigationClobber(ScheduledNavigationType::ScheduledReload,
-                                       frame, request, gestureIndicator.get());
+                                       frame);
     frame->loader().load(request, FrameLoadTypeReload);
   }
 
  private:
   ScheduledReload() : ScheduledNavigation(0.0, nullptr, true, true) {}
 };
 
 class ScheduledPageBlock final : public ScheduledURLNavigation {
  public:
   static ScheduledPageBlock* create(Document* originDocument,
                                     const String& url) {
     return new ScheduledPageBlock(originDocument, url);
   }
 
   void fire(LocalFrame* frame) override {
     std::unique_ptr<UserGestureIndicator> gestureIndicator =
         createUserGestureIndicator();
     SubstituteData substituteData(SharedBuffer::create(), "text/plain", "UTF-8",
                                   KURL(), ForceSynchronousLoad);
     FrameLoadRequest request(originDocument(), url(), substituteData);
     request.setReplacesCurrentItem(true);
     request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
     maybeLogScheduledNavigationClobber(
-        ScheduledNavigationType::ScheduledPageBlock, frame, request,
-        gestureIndicator.get());
+        ScheduledNavigationType::ScheduledPageBlock, frame);
     frame->loader().load(request);
   }
 
  private:
   ScheduledPageBlock(Document* originDocument, const String& url)
       : ScheduledURLNavigation(0.0, originDocument, url, true, true) {}
 };
 
 class ScheduledFormSubmission final : public ScheduledNavigation {
  public:
   static ScheduledFormSubmission* create(Document* document,
                                          FormSubmission* submission,
                                          bool replacesCurrentItem) {
     return new ScheduledFormSubmission(document, submission,
                                        replacesCurrentItem);
   }
 
   void fire(LocalFrame* frame) override {
     std::unique_ptr<UserGestureIndicator> gestureIndicator =
         createUserGestureIndicator();
     FrameLoadRequest frameRequest =
         m_submission->createFrameLoadRequest(originDocument());
     frameRequest.setReplacesCurrentItem(replacesCurrentItem());
     maybeLogScheduledNavigationClobber(
-        ScheduledNavigationType::ScheduledFormSubmission, frame, frameRequest,
-        gestureIndicator.get());
+        ScheduledNavigationType::ScheduledFormSubmission, frame);
     frame->loader().load(frameRequest);
   }
 
   DEFINE_INLINE_VIRTUAL_TRACE() {
     visitor->trace(m_submission);
     ScheduledNavigation::trace(visitor);
   }
 
  private:
   ScheduledFormSubmission(Document* document,
@@ skipping 213 matching lines @@
   m_navigateTaskFactory->cancel();
   m_redirect.clear();
 }
 
 DEFINE_TRACE(NavigationScheduler) {
   visitor->trace(m_frame);
   visitor->trace(m_redirect);
 }
 
 }  // namespace blink