Introduce Internals#replaceMisspelled() and Internals#setMarker()

third_party/WebKit/Source/core/testing/Internals.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 Apple 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 154 matching lines @@
             ExceptionState& exceptionState) override {
     if (m_index >= 5)
       return false;
     value = m_index * m_index;
     return true;
   }
 };
 
 }  // namespace
 
-static bool markerTypesFrom(const String& markerType,
-                            DocumentMarker::MarkerTypes& result) {
-  if (markerType.isEmpty() || equalIgnoringCase(markerType, "all"))
-    result = DocumentMarker::AllMarkers();
-  else if (equalIgnoringCase(markerType, "Spelling"))
+// return true if markerType is valid.
+static bool markerTypeFrom(const String& markerType,

[yosin_UTC9, 2016/11/14 05:18:59]

How about returning |WTF::Optional<DocumetnMarker::MarkerType>|, ==
std::optional<T> in C++17?
https://chromium.googlesource.com/chromium/src/+/master/third_party/WebKit/So...

+                           DocumentMarker::MarkerType& result) {
+  if (equalIgnoringCase(markerType, "Spelling"))
     result = DocumentMarker::Spelling;
   else if (equalIgnoringCase(markerType, "Grammar"))
     result = DocumentMarker::Grammar;
   else if (equalIgnoringCase(markerType, "TextMatch"))
     result = DocumentMarker::TextMatch;
   else
     return false;
 
   return true;
 }
 
+// return true if markerType is valid.
+static bool markerTypesFrom(const String& markerType,
+                            DocumentMarker::MarkerTypes& result) {
+  if (markerType.isEmpty() || equalIgnoringCase(markerType, "all")) {
+    result = DocumentMarker::AllMarkers();
+    return true;
+  }
+
+  DocumentMarker::MarkerType type;
+  if (markerTypeFrom(markerType, type)) {
+    result = type;
+    return true;
+  }
+  return false;
+}
+
 static SpellCheckRequester* spellCheckRequester(Document* document) {
   if (!document || !document->frame())
     return 0;
   return &document->frame()->spellChecker().spellCheckRequester();
 }
 
 static ScrollableArea* scrollableAreaForNode(Node* node) {
   if (!node)
     return nullptr;
 
@@ skipping 705 matching lines @@
   ASSERT(element);
 
   element->document().updateStyleAndLayoutIgnorePendingStylesheets();
   LayoutObject* layoutObject = element->layoutObject();
   if (!layoutObject)
     return ClientRect::create();
   return ClientRect::create(
       layoutObject->absoluteBoundingBoxRectIgnoringTransforms());
 }
 
+void Internals::setMarker(Document* document,
+                          const Range* range,
+                          const String& markerType,
+                          ExceptionState& exceptionState) {
+  if (!document) {
+    exceptionState.throwDOMException(InvalidAccessError,
+                                     "No context document is available.");
+    return;
+  }
+
+  DocumentMarker::MarkerType type;
+  if (!markerTypeFrom(markerType, type)) {
+    exceptionState.throwDOMException(
+        SyntaxError,
+        "The marker type provided ('" + markerType + "') is invalid.");
+    return;
+  }
+
+  document->markers().addMarker(range->startPosition(), range->endPosition(),
+                                type);
+}
+
 unsigned Internals::markerCountForNode(Node* node,
                                        const String& markerType,
                                        ExceptionState& exceptionState) {
   ASSERT(node);
   DocumentMarker::MarkerTypes markerTypes = 0;
   if (!markerTypesFrom(markerType, markerTypes)) {
     exceptionState.throwDOMException(
         SyntaxError,
         "The marker type provided ('" + markerType + "') is invalid.");
     return 0;
@@ skipping 893 matching lines @@
         InvalidAccessError,
         "No frame can be obtained from the provided document.");
     return;
   }
 
   if (enabled !=
       contextDocument()->frame()->spellChecker().isSpellCheckingEnabled())
     contextDocument()->frame()->spellChecker().toggleSpellCheckingEnabled();
 }
 
+void Internals::replaceMisspelled(Document* document,
+                                  const String& replacement,
+                                  ExceptionState& exceptionState) {
+  if (!document || !document->frame()) {
+    exceptionState.throwDOMException(
+        InvalidAccessError,
+        "No frame can be obtained from the provided document.");
+    return;
+  }
+
+  document->updateStyleAndLayoutIgnorePendingStylesheets();
+  document->frame()->spellChecker().replaceMisspelledRange(replacement);
+}
+
 bool Internals::canHyphenate(const AtomicString& locale) {
   return LayoutLocale::valueOrDefault(LayoutLocale::get(locale))
       .getHyphenation();
 }
 
 void Internals::setMockHyphenation(const AtomicString& locale) {
   LayoutLocale::setHyphenationForTesting(locale, adoptRef(new MockHyphenation));
 }
 
 bool Internals::isOverwriteModeEnabled(Document* document) {
@@ skipping 1196 matching lines @@
     return ClientRect::create();
 
   return ClientRect::create(FloatRect(node->layoutObject()->visualRect()));
 }
 
 void Internals::crash() {
   CHECK(false) << "Intentional crash";
 }
 
 }  // namespace blink