Move persistent gesture state to Document, add DocumentUserGestureToken

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 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) 2008 Alp Toker <alp@atoker.com>
  * Copyright (C) Research In Motion Limited 2009. All rights reserved.
  * Copyright (C) 2011 Kris Jordan <krisjordan@gmail.com>
  * Copyright (C) 2011 Google Inc. All rights reserved.
@@ skipping 377 matching lines @@
 void FrameLoader::clearProvisionalHistoryItem() {
   m_provisionalItem.clear();
 }
 
 void FrameLoader::setHistoryItemStateForCommit(
     FrameLoadType loadType,
     HistoryCommitType historyCommitType,
     HistoryNavigationType navigationType) {
   if (m_frame->settings()->historyEntryRequiresUserGesture() &&
       historyCommitType == StandardCommit)
-    UserGestureIndicator::clearProcessedUserGestureSinceLoad();
+    m_frame->document()->clearHasReceivedUserGesture();
 
   HistoryItem* oldItem = m_currentItem;
   if (isBackForwardLoadType(loadType) && m_provisionalItem)
     m_currentItem = m_provisionalItem.release();
   else
     m_currentItem = HistoryItem::create();
   m_currentItem->setURL(m_documentLoader->urlForHistory());
   m_currentItem->setDocumentState(m_frame->document()->formElementsState());
   m_currentItem->setTarget(m_frame->tree().uniqueName());
   m_currentItem->setReferrer(SecurityPolicy::generateReferrer(
@@ skipping 368 matching lines @@
   // Generate start and stop notifications only when loader is completed so that
   // we don't fire them for fragment redirection that happens in window.onload
   // handler. See https://bugs.webkit.org/show_bug.cgi?id=31838
   if (m_frame->document()->loadEventFinished())
     client()->didStartLoading(NavigationWithinSameDocument);
 
   HistoryCommitType historyCommitType = loadTypeToCommitType(type);
   if (!m_currentItem)
     historyCommitType = HistoryInertCommit;
   if (m_frame->settings()->historyEntryRequiresUserGesture() &&
-      !UserGestureIndicator::processedUserGestureSinceLoad() &&
-      initiatingDocument)
+      !m_frame->document()->hasReceivedUserGesture() && initiatingDocument)

[ojan, 2016/10/18 16:39:49]

What happens in this case?
1. Load a top-level page.
2. Click in an iframe.
3. The iframe gets navigated to a new URL at some point.
4. Navigate the top-level to a new URL.

I would expect to get at least one history entry (after #3), and maybe two (also
after #4)?

I think the safest thing would be having two entries as that matches what we
would do today, right?

I'm picturing a use case where someone is building a web browser type thing
where you click on links in the outer page to navigate the sub-frame, or you
click on links in one sub-frame to navigate another sub-frame. I don't know if
that case matters, but my gut feeling is that it makes sense to be a bit
conservative here.

In either case, we might want a test that covers this case.

[Nate Chapin, 2016/10/18 23:26:33]

Hrm. This should probably be using initiatingDocument for hasReceivedUserGesture
checks. That should solve the problem of gestures in one frame driving
navigations in another. Updated.

In general, on the question of 1 or 2 history entries: (3) definitely gets a
user gesture. (4) depends on how the top-level navigation triggers: it gets a
history entry if there was or is a user gesture since last commit and/or history
entry addition. Also, if there is no Document* specified as the initiator, that
means that the navigation is being triggered from a trusted source (e.g., the
address bar) and a history entry may be added.

Does that make sense?

[ojan, 2016/10/18 23:40:25]

Right. And that means it gets a history entry?
Right. Assuming no user gesture between 3 and 4, then it won't get a history
entry, right? I think we take on some risk here for the use case I was
describing. I think we might want to store a bit on Page as to whether that Page
has ever had a gesture and use that bit. Or, we can try this and see what
breaks. :)
I guess that seems reasonable.
Yup. If it's not a lot of work, I think a test is worth it, but if it's a lot of
work, don't worry about it.

     historyCommitType = HistoryInertCommit;
 
   setHistoryItemStateForCommit(
       type, historyCommitType,
       sameDocumentNavigationSource == SameDocumentNavigationHistoryApi
           ? HistoryNavigationType::HistoryApi
           : HistoryNavigationType::Fragment);
   if (sameDocumentNavigationSource == SameDocumentNavigationHistoryApi) {
     m_currentItem->setStateObject(std::move(data));
     m_currentItem->setScrollRestorationType(scrollRestorationType);
@@ skipping 125 matching lines @@
                ? FrameLoadTypeStandard
                : FrameLoadTypeReplaceCurrentItem;
   }
 
   if (request.substituteData().failingURL() ==
           m_documentLoader->urlForHistory() &&
       m_loadType == FrameLoadTypeReload)
     return FrameLoadTypeReload;
 
   if (m_frame->settings()->historyEntryRequiresUserGesture() &&
-      !UserGestureIndicator::processedUserGestureSinceLoad() &&
+      !m_frame->document()->hasReceivedUserGesture() &&
       request.originDocument())
     return FrameLoadTypeReplaceCurrentItem;
 
   return FrameLoadTypeStandard;
 }
 
 bool FrameLoader::prepareRequestForThisFrame(FrameLoadRequest& request) {
   // If no origin Document* was specified, skip remaining security checks and
   // assume the caller has fully initialized the FrameLoadRequest.
   if (!request.originDocument())
@@ skipping 961 matching lines @@
                          m_documentLoader ? m_documentLoader->url() : String());
   return tracedValue;
 }
 
 inline void FrameLoader::takeObjectSnapshot() const {
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID("loading", "FrameLoader", this,
                                       toTracedValue());
 }
 
 }  // namespace blink