Move text input mode/info/type into InputMethodController

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
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (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/InputTypeNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.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/events/CompositionEvent.h"
 #include "core/frame/LocalFrame.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"
 
 namespace blink {
 
 namespace {
 
@@ skipping 813 matching lines @@
   } while (frame().selection().start() == frame().selection().end() &&
            before <= static_cast<int>(selectionOffsets.start()));
   // TODO(chongz): Find a way to distinguish Forward and Backward.
   dispatchBeforeInputEditorCommand(
       m_frame->document()->focusedElement(),
       InputEvent::InputType::DeleteContentBackward,
       new RangeVector(1, m_frame->selection().firstRange()));
   TypingCommand::deleteSelection(*frame().document());
 }
 
+WebTextInputInfo InputMethodController::textInputInfo() const {
+  WebTextInputInfo info;
+  if (!frame().document())
+    return info;
+
+  if (!frame().selection().isAvailable()) {
+    // plugins/mouse-capture-inside-shadow.html reaches here.
+    return info;
+  }
+  Element* element = frame().selection().rootEditableElement();
+  if (!element)
+    return info;
+
+  info.inputMode = inputModeOfFocusedElement();
+  info.type = textInputType();
+  info.flags = textInputFlags();
+  if (info.type == WebTextInputTypeNone)
+    return info;
+
+  if (!frame().editor().canEdit())
+    return info;
+
+  // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited.  see http://crbug.com/590369 for more details.
+  frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
+
+  DocumentLifecycle::DisallowTransitionScope disallowTransition(
+      frame().document()->lifecycle());
+
+  // Emits an object replacement character for each replaced element so that
+  // it is exposed to IME and thus could be deleted by IME on android.
+  info.value = plainText(EphemeralRange::rangeOfContents(*element),
+                         TextIteratorEmitsObjectReplacementCharacter);
+
+  if (info.value.isEmpty())
+    return info;
+
+  EphemeralRange firstRange =
+      firstEphemeralRangeOf(frame().selection().selection());
+  if (firstRange.isNotNull()) {
+    PlainTextRange plainTextRange(PlainTextRange::create(*element, firstRange));
+    if (plainTextRange.isNotNull()) {
+      info.selectionStart = plainTextRange.start();
+      info.selectionEnd = plainTextRange.end();
+    }
+  }
+
+  EphemeralRange range = compositionEphemeralRange();
+  if (range.isNotNull()) {
+    PlainTextRange plainTextRange(PlainTextRange::create(*element, range));
+    if (plainTextRange.isNotNull()) {
+      info.compositionStart = plainTextRange.start();
+      info.compositionEnd = plainTextRange.end();
+    }
+  }
+
+  return info;
+}
+
+int InputMethodController::textInputFlags() const {
+  Element* element = frame().document()->focusedElement();
+  if (!element)
+    return WebTextInputFlagNone;
+
+  DEFINE_STATIC_LOCAL(AtomicString, autocompleteString, ("autocomplete"));
+  DEFINE_STATIC_LOCAL(AtomicString, autocorrectString, ("autocorrect"));
+  int flags = 0;
+
+  const AtomicString& autocomplete = element->getAttribute(autocompleteString);
+  if (autocomplete == "on")
+    flags |= WebTextInputFlagAutocompleteOn;
+  else if (autocomplete == "off")
+    flags |= WebTextInputFlagAutocompleteOff;
+
+  const AtomicString& autocorrect = element->getAttribute(autocorrectString);
+  if (autocorrect == "on")
+    flags |= WebTextInputFlagAutocorrectOn;
+  else if (autocorrect == "off")
+    flags |= WebTextInputFlagAutocorrectOff;
+
+  SpellcheckAttributeState spellcheck = element->spellcheckAttributeState();
+  if (spellcheck == SpellcheckAttributeTrue)
+    flags |= WebTextInputFlagSpellcheckOn;
+  else if (spellcheck == SpellcheckAttributeFalse)
+    flags |= WebTextInputFlagSpellcheckOff;
+
+  if (isHTMLTextFormControlElement(element)) {
+    HTMLTextFormControlElement* formElement =
+        static_cast<HTMLTextFormControlElement*>(element);
+    if (formElement->supportsAutocapitalize()) {
+      DEFINE_STATIC_LOCAL(const AtomicString, none, ("none"));
+      DEFINE_STATIC_LOCAL(const AtomicString, characters, ("characters"));
+      DEFINE_STATIC_LOCAL(const AtomicString, words, ("words"));
+      DEFINE_STATIC_LOCAL(const AtomicString, sentences, ("sentences"));
+
+      const AtomicString& autocapitalize = formElement->autocapitalize();
+      if (autocapitalize == none)
+        flags |= WebTextInputFlagAutocapitalizeNone;
+      else if (autocapitalize == characters)
+        flags |= WebTextInputFlagAutocapitalizeCharacters;
+      else if (autocapitalize == words)
+        flags |= WebTextInputFlagAutocapitalizeWords;
+      else if (autocapitalize == sentences)
+        flags |= WebTextInputFlagAutocapitalizeSentences;
+      else
+        NOTREACHED();
+    }
+  }
+
+  return flags;
+}
+
+WebString InputMethodController::inputModeOfFocusedElement() const {
+  if (!RuntimeEnabledFeatures::inputModeAttributeEnabled())
+    return WebString();
+
+  Element* element = frame().document()->focusedElement();
+  if (!element)
+    return WebString();
+
+  if (isHTMLInputElement(*element)) {
+    const HTMLInputElement& input = toHTMLInputElement(*element);
+    if (input.supportsInputModeAttribute())
+      return input.fastGetAttribute(HTMLNames::inputmodeAttr).lower();
+    return WebString();
+  }
+  if (isHTMLTextAreaElement(*element)) {
+    const HTMLTextAreaElement& textarea = toHTMLTextAreaElement(*element);
+    return textarea.fastGetAttribute(HTMLNames::inputmodeAttr).lower();
+  }
+
+  return WebString();
+}
+
+WebTextInputType InputMethodController::textInputType() const {
+  if (!frame().selection().isAvailable()) {
+    // "mouse-capture-inside-shadow.html" reaches here.
+    return WebTextInputTypeNone;
+  }
+
+  // It's important to preserve the equivalence of textInputInfo().type and
+  // textInputType(), so perform the same rootEditableElement() existence check
+  // here for consistency.
+  if (!frame().selection().selection().rootEditableElement())
+    return WebTextInputTypeNone;
+
+  Document* document = frame().document();
+  if (!document)
+    return WebTextInputTypeNone;
+
+  Element* element = document->focusedElement();
+  if (!element)
+    return WebTextInputTypeNone;
+
+  if (isHTMLInputElement(*element)) {
+    HTMLInputElement& input = toHTMLInputElement(*element);
+    const AtomicString& type = input.type();
+
+    if (input.isDisabledOrReadOnly())
+      return WebTextInputTypeNone;
+
+    if (type == InputTypeNames::password)
+      return WebTextInputTypePassword;
+    if (type == InputTypeNames::search)
+      return WebTextInputTypeSearch;
+    if (type == InputTypeNames::email)
+      return WebTextInputTypeEmail;
+    if (type == InputTypeNames::number)
+      return WebTextInputTypeNumber;
+    if (type == InputTypeNames::tel)
+      return WebTextInputTypeTelephone;
+    if (type == InputTypeNames::url)
+      return WebTextInputTypeURL;
+    if (type == InputTypeNames::text)
+      return WebTextInputTypeText;
+
+    return WebTextInputTypeNone;
+  }
+
+  if (isHTMLTextAreaElement(*element)) {
+    if (toHTMLTextAreaElement(*element).isDisabledOrReadOnly())
+      return WebTextInputTypeNone;
+    return WebTextInputTypeTextArea;
+  }
+
+  if (element->isHTMLElement()) {
+    if (toHTMLElement(element)->isDateTimeFieldElement())
+      return WebTextInputTypeDateTimeField;
+  }
+
+  document->updateStyleAndLayoutTree();
+  if (hasEditableStyle(*element))
+    return WebTextInputTypeContentEditable;
+
+  return WebTextInputTypeNone;
+}
+
 DEFINE_TRACE(InputMethodController) {
   visitor->trace(m_frame);
   visitor->trace(m_compositionRange);
 }
 
 }  // namespace blink