[Android] Adding Smart GO/NEXT feature in Chrome

third_party/WebKit/Source/core/editing/InputMethodController.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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
@@ skipping 12 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/editing/InputMethodController.h"
 
 #include "core/InputModeNames.h"
 #include "core/InputTypeNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
+#include "core/dom/ElementTraversal.h"
 #include "core/dom/Text.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/commands/TypingCommand.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/editing/state_machines/BackwardCodePointStateMachine.h"
 #include "core/editing/state_machines/ForwardCodePointStateMachine.h"
 #include "core/events/CompositionEvent.h"
 #include "core/frame/LocalFrame.h"
+#include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLTextAreaElement.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/page/ChromeClient.h"
+#include "core/page/FocusController.h"
+#include "core/page/Page.h"
 
 namespace blink {
 
 namespace {
 
 void DispatchCompositionUpdateEvent(LocalFrame& frame, const String& text) {
   Element* target = frame.GetDocument()->FocusedElement();
   if (!target)
     return;
 
@@ skipping 1078 matching lines @@
         flags |= kWebTextInputFlagAutocapitalizeCharacters;
       else if (autocapitalize == words)
         flags |= kWebTextInputFlagAutocapitalizeWords;
       else if (autocapitalize == sentences)
         flags |= kWebTextInputFlagAutocapitalizeSentences;
       else
         NOTREACHED();
     }
   }
 
+  if (IsListeningToKeyboardEvents(element))
+    flags |= kWebTextInputFlagListeningToKeyboardEvents;
+
+  if (NextFocusableElementInForm(element, kWebFocusTypeForward))
+    flags |= kWebTextInputFlagHaveNextFocusableElement;
+
+  if (NextFocusableElementInForm(element, kWebFocusTypeBackward))
+    flags |= kWebTextInputFlagHavePreviousFocusableElement;
+
   return flags;
 }
 
+bool InputMethodController::IsListeningToKeyboardEvents(

[Changwan Ryu, 2017/04/27 16:34:54]

I'm not sure if this makes much sense... There are tons of different ways to
listen to text changes, too. Also, the webpage may not be particularly listening
to these events to submit a form or send you somewhere.

I think you should remove this logic, and just show 'enter', and expect webpage
to use input mode if they want to show 'GO'.

[yosin_UTC9, 2017/04/28 03:32:11]

Agree with changewan@. This is too specific and coverage narrow.
We may want to show "Go" for simple submit button, <input type=submit>, button
w/ "click"(include tap) event handler.

[AKVT, 2017/05/03 14:35:12]

Yes I am convinced here, as it has a very narrow coverage.

As I pointed in ImeUtils.java, I have still doubt on inputMode as it's still
going as trivial assignment, without having a thought of nearby (previous or
next) elements.

+    Element* element) const {
+  if (!element->IsFormControlElement() &&
+      !ToHTMLElement(element)->isContentEditableForBinding())
+    return false;
+  for (Node* node = element; node; node = node->parentNode()) {
+    if (node->HasEventListeners(EventTypeNames::keydown) ||
+        node->HasEventListeners(EventTypeNames::keypress) ||
+        node->HasEventListeners(EventTypeNames::keyup))
+      return true;
+  }
+  return false;
+}
+
+Element* InputMethodController::NextFocusableElementInForm(

[yosin_UTC9, 2017/04/28 01:07:28]

This function should be in FocusController instead of
InputeMethodController(IMC).
IMC should be passive about focus.

[yosin_UTC9, 2017/04/28 03:32:11]

I think this function should be implemented on top of TAB move function to
respect "tabindex" attribute,
which TAB move function handled.

[AKVT, 2017/05/03 14:35:12]

Done.

[AKVT, 2017/05/03 14:35:12]

Done.

+    Element* element,
+    WebFocusType focusType) const {
+  if (!element->IsFormControlElement() &&
+      !ToHTMLElement(element)->isContentEditableForBinding())
+    return nullptr;
+
+  HTMLFormElement* formOwner = nullptr;
+  if (ToHTMLElement(element)->isContentEditableForBinding())
+    formOwner = Traversal<HTMLFormElement>::FirstAncestor(*element);
+  else
+    formOwner = ToHTMLFormControlElement(element)->formOwner();
+
+  if (!formOwner)
+    return nullptr;
+
+  Element* nextElement = element;
+  for (nextElement =
+           GetDocument().GetPage()->GetFocusController().FindFocusableElement(
+               focusType, *nextElement);
+       nextElement;
+       nextElement =
+           GetDocument().GetPage()->GetFocusController().FindFocusableElement(
+               focusType, *nextElement)) {
+    if (ToHTMLElement(nextElement)->isContentEditableForBinding() &&
+        nextElement->IsDescendantOf(formOwner))
+      return nextElement;
+    if (!nextElement->IsFormControlElement())
+      continue;
+    HTMLFormControlElement* formElement = ToHTMLFormControlElement(nextElement);
+    if (formElement->formOwner() != formOwner)
+      continue;
+    // Skip disabled or readonly editable elements.
+    if (formElement->IsDisabledOrReadOnly())
+      continue;
+    LayoutObject* layout = nextElement->GetLayoutObject();
+    if (layout && layout->IsTextControl()) {
+      // TODO(ajith.v) Extend it for Select element, Radio button and Check
+      // boxes
+      return nextElement;
+    }
+  }
+  return nullptr;
+}
+
 WebTextInputMode InputMethodController::InputModeOfFocusedElement() const {
   if (!RuntimeEnabledFeatures::inputModeAttributeEnabled())
     return kWebTextInputModeDefault;
 
   AtomicString mode = GetInputModeAttribute(GetDocument().FocusedElement());
 
   if (mode.IsEmpty())
     return kWebTextInputModeDefault;
   if (mode == InputModeNames::verbatim)
     return kWebTextInputModeVerbatim;
@@ skipping 88 matching lines @@
   FinishComposingText(kKeepSelection);
 }
 
 DEFINE_TRACE(InputMethodController) {
   visitor->Trace(frame_);
   visitor->Trace(composition_range_);
   SynchronousMutationObserver::Trace(visitor);
 }
 
 }  // namespace blink