Move persistent gesture state to Document, add DocumentUserGestureToken

third_party/WebKit/Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "web/WebViewImpl.h"
 
 #include "core/CSSValueKeywords.h"
 #include "core/HTMLNames.h"
 #include "core/InputTypeNames.h"
 #include "core/clipboard/DataObject.h"
 #include "core/dom/Document.h"
+#include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/LayoutTreeBuilderTraversal.h"
 #include "core/dom/Text.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/InputMethodController.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/editing/serializers/HTMLInterchange.h"
@@ skipping 207 matching lines @@
 
 static bool shouldUseExternalPopupMenus = false;
 
 namespace {
 
 class UserGestureNotifier {
  public:
   // If a UserGestureIndicator is created for a user gesture since the last
   // page load and *userGestureObserved is false, the UserGestureNotifier
   // will notify the client and set *userGestureObserved to true.
-  UserGestureNotifier(WebAutofillClient*, bool* userGestureObserved);
+  UserGestureNotifier(WebLocalFrameImpl*, bool* userGestureObserved);
   ~UserGestureNotifier();
 
  private:
-  WebAutofillClient* const m_client;
+  Persistent<WebLocalFrameImpl> m_frame;
   bool* const m_userGestureObserved;
 };
 
-UserGestureNotifier::UserGestureNotifier(WebAutofillClient* client,
+UserGestureNotifier::UserGestureNotifier(WebLocalFrameImpl* frame,
                                          bool* userGestureObserved)
-    : m_client(client), m_userGestureObserved(userGestureObserved) {
+    : m_frame(frame), m_userGestureObserved(userGestureObserved) {
   DCHECK(m_userGestureObserved);
 }
 
 UserGestureNotifier::~UserGestureNotifier() {
   if (!*m_userGestureObserved &&
-      UserGestureIndicator::processedUserGestureSinceLoad()) {
+      m_frame->frame()->document()->hasReceivedUserGesture()) {
     *m_userGestureObserved = true;
-    if (m_client)
-      m_client->firstUserGestureObserved();
+    if (m_frame && m_frame->autofillClient())
+      m_frame->autofillClient()->firstUserGestureObserved();

[Rick Byers, 2016/10/17 17:02:47]

Is there a notifier per frame?  You should probably get someone familiar with
the autofill use cases to confirm that this change in semantics (from page to
main frame) is OK and won't break iframe form-filling scenarios.

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

Yes, the notifier is per-frame, and UserGestureNotifier is only ever initialized
for the main frame. So the same autofill client will still be getting this
callback. The substantive change here is that only main frame user gestures will
trigger the firstUserGestureObserved() callback, where before any gesture in the
page (well, really the whole process) would trigger it.

@mathp, any idea whether that is OK?

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

I suspect it's not OK since a lot of times password fields, etc. are inside
login iframes.

You could just crawl all frames here, right? Since this is guarded with a bool,
we'd only ever crawl all frames once per page load, I think? Alternately, could
store a bit on Page as well, but that seems like overkill to me unless we have
common use cases.

[Mathieu, 2016/10/19 17:20:31]

Ojan is correct. More and more payments and password information is in iframes,
I'm pretty sure it would break some functionality. 

   }
 }
 
 class EmptyEventListener final : public EventListener {
  public:
   static EmptyEventListener* create() { return new EmptyEventListener(); }
 
   bool operator==(const EventListener& other) const override {
     return this == &other;
   }
@@ skipping 1921 matching lines @@
 
 WebInputEventResult WebViewImpl::handleInputEvent(
     const WebInputEvent& inputEvent) {
   // TODO(dcheng): The fact that this is getting called when there is no local
   // main frame is problematic and probably indicates a bug in the input event
   // routing code.
   if (!mainFrameImpl())
     return WebInputEventResult::NotHandled;
 
   WebAutofillClient* autofillClient = mainFrameImpl()->autofillClient();
-  UserGestureNotifier notifier(autofillClient, &m_userGestureObserved);
+  UserGestureNotifier notifier(mainFrameImpl(), &m_userGestureObserved);
   // On the first input event since page load, |notifier| instructs the
   // autofill client to unblock values of password input fields of any forms
   // on the page. There is a single input event, GestureTap, which can both
   // be the first event after page load, and cause a form submission. In that
   // case, the form submission happens before the autofill client is told
   // to unblock the password values, and so the password values are not
   // submitted. To avoid that, GestureTap is handled explicitly:
   if (inputEvent.type == WebInputEvent::GestureTap && autofillClient) {
     m_userGestureObserved = true;
     autofillClient->firstUserGestureObserved();
@@ skipping 50 matching lines @@
     AtomicString eventType;
     switch (inputEvent.type) {
       case WebInputEvent::MouseMove:
         eventType = EventTypeNames::mousemove;
         break;
       case WebInputEvent::MouseLeave:
         eventType = EventTypeNames::mouseout;
         break;
       case WebInputEvent::MouseDown:
         eventType = EventTypeNames::mousedown;
-        gestureIndicator = wrapUnique(new UserGestureIndicator(
-            UserGestureToken::create(UserGestureToken::NewGesture)));
+        gestureIndicator = wrapUnique(
+            new UserGestureIndicator(DocumentUserGestureToken::create(
+                &node->document(), UserGestureToken::NewGesture)));
         m_mouseCaptureGestureToken = gestureIndicator->currentToken();
         break;
       case WebInputEvent::MouseUp:
         eventType = EventTypeNames::mouseup;
         gestureIndicator = wrapUnique(
             new UserGestureIndicator(m_mouseCaptureGestureToken.release()));
         break;
       default:
         NOTREACHED();
     }
@@ skipping 152 matching lines @@
   }
 
   // A keypress event is canceled. If an ongoing composition exists, then the
   // keydown event should have arisen from a handled key (e.g., backspace).
   // In this case we ignore the cancellation and continue; otherwise (no
   // ongoing composition) we exit and signal success only for attempts to
   // clear the composition.
   if (m_suppressNextKeypressEvent && !inputMethodController.hasComposition())
     return text.isEmpty();
 
-  UserGestureIndicator gestureIndicator(
-      UserGestureToken::create(UserGestureToken::NewGesture));
+  UserGestureIndicator gestureIndicator(DocumentUserGestureToken::create(
+      focused->document(), UserGestureToken::NewGesture));
 
   // When the range of composition underlines overlap with the range between
   // selectionStart and selectionEnd, WebKit somehow won't paint the selection
   // at all (see InlineTextBox::paint() function in InlineTextBox.cpp).
   // But the selection range actually takes effect.
   inputMethodController.setComposition(
       String(text), CompositionUnderlineVectorBuilder(underlines),
       selectionStart, selectionEnd);
 
   return text.isEmpty() || inputMethodController.hasComposition();
@@ skipping 10 matching lines @@
   if (WebPlugin* plugin = focusedPluginIfInputMethodSupported(focused))
     return plugin->finishComposingText(selectionBehavior);
 
   return focused->inputMethodController().finishComposingText(
       selectionBehavior == KeepSelection
           ? InputMethodController::KeepSelection
           : InputMethodController::DoNotKeepSelection);
 }
 
 bool WebViewImpl::commitText(const WebString& text, int relativeCaretPosition) {
-  UserGestureIndicator gestureIndicator(
-      UserGestureToken::create(UserGestureToken::NewGesture));
 
   LocalFrame* focused = focusedLocalFrameAvailableForIme();
   if (!focused)
     return false;
 
+  UserGestureIndicator gestureIndicator(DocumentUserGestureToken::create(
+      focused->document(), UserGestureToken::NewGesture));
+
   if (WebPlugin* plugin = focusedPluginIfInputMethodSupported(focused))
     return plugin->commitText(text, relativeCaretPosition);
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   focused->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   return focused->inputMethodController().commitText(text,
                                                      relativeCaretPosition);
 }
@@ skipping 1326 matching lines @@
 void WebViewImpl::dragTargetDrop(const WebDragData& webDragData,
                                  const WebPoint& pointInViewport,
                                  const WebPoint& screenPoint,
                                  int modifiers) {
   WebPoint pointInRootFrame(
       page()->frameHost().visualViewport().viewportToRootFrame(
           pointInViewport));
 
   DCHECK(m_currentDragData);
   m_currentDragData = DataObject::create(webDragData);
-
-  WebAutofillClient* autofillClient =
-      mainFrameImpl() ? mainFrameImpl()->autofillClient() : 0;
-  UserGestureNotifier notifier(autofillClient, &m_userGestureObserved);
+  UserGestureNotifier notifier(mainFrameImpl(), &m_userGestureObserved);
 
   // If this webview transitions from the "drop accepting" state to the "not
   // accepting" state, then our IPC message reply indicating that may be in-
   // flight, or else delayed by javascript processing in this webview.  If a
   // drop happens before our IPC reply has reached the browser process, then
   // the browser forwards the drop to this webview.  So only allow a drop to
   // proceed if our webview m_dragOperation state is not DragOperationNone.
 
   if (m_dragOperation ==
       WebDragOperationNone) {  // IPC RACE CONDITION: do not allow this drop.
     dragTargetDragLeave();
     return;
   }
 
   m_currentDragData->setModifiers(modifiers);
   DragData dragData(m_currentDragData.get(), pointInRootFrame, screenPoint,
                     static_cast<DragOperation>(m_operationsAllowed));
 
-  UserGestureIndicator gesture(

[Nate Chapin, 2016/10/13 20:03:19]

Moved to DragController.

-      UserGestureToken::create(UserGestureToken::NewGesture));
   m_page->dragController().performDrag(&dragData);
 
   m_dragOperation = WebDragOperationNone;
   m_currentDragData = nullptr;
 }
 
 void WebViewImpl::spellingMarkers(WebVector<uint32_t>* markers) {
   Vector<uint32_t> result;
   for (Frame* frame = m_page->mainFrame(); frame;
        frame = frame->tree().traverseNext()) {
@@ skipping 775 matching lines @@
   if (m_layerTreeView)
     m_layerTreeView->setVisible(isVisible);
 }
 
 void WebViewImpl::pointerLockMouseEvent(const WebInputEvent& event) {
   std::unique_ptr<UserGestureIndicator> gestureIndicator;
   AtomicString eventType;
   switch (event.type) {
     case WebInputEvent::MouseDown:
       eventType = EventTypeNames::mousedown;
-      gestureIndicator = wrapUnique(new UserGestureIndicator(
-          UserGestureToken::create(UserGestureToken::NewGesture)));
+      if (!page() || !page()->pointerLockController().element())
+        break;
+      gestureIndicator =
+          wrapUnique(new UserGestureIndicator(DocumentUserGestureToken::create(
+              &page()->pointerLockController().element()->document(),
+              UserGestureToken::NewGesture)));
       m_pointerLockGestureToken = gestureIndicator->currentToken();
       break;
     case WebInputEvent::MouseUp:
       eventType = EventTypeNames::mouseup;
       gestureIndicator = wrapUnique(
           new UserGestureIndicator(m_pointerLockGestureToken.release()));
       break;
     case WebInputEvent::MouseMove:
       eventType = EventTypeNames::mousemove;
       break;
@@ skipping 55 matching lines @@
   if (focusedFrame->localFrameRoot() != mainFrameImpl()->frame())
     return nullptr;
   return focusedFrame;
 }
 
 LocalFrame* WebViewImpl::focusedLocalFrameAvailableForIme() const {
   return m_imeAcceptEvents ? focusedLocalFrameInWidget() : nullptr;
 }
 
 }  // namespace blink