Changeset 100890 in webkit

Timestamp:

Nov 21, 2011 1:20:57 AM (12 years ago)

Author:

commit-queue@webkit.org

Message:

Refactoring: SpellChecker::requestCheckingFor should take Range instead of Node.
​https://bugs.webkit.org/show_bug.cgi?id=72847

Patch by Shinya Kawanaka <​shinyak@google.com> on 2011-11-21
Reviewed by Hajime Morita.

Covered by existing test.

• editing/Editor.cpp:

(WebCore::Editor::replaceSelectionWithFragment):

Passes Range to requestCheckingFor instead of Node.

• editing/SpellChecker.cpp: Changed argument type from Node to Range. The corresponding changes are also done in dependent methods.

(WebCore::SpellChecker::initRequest):
(WebCore::SpellChecker::clearRequest):
(WebCore::SpellChecker::canCheckAsynchronously):
(WebCore::SpellChecker::isBusy):
(WebCore::SpellChecker::isValid):
(WebCore::SpellChecker::isCheckable):
(WebCore::SpellChecker::requestCheckingFor):

Changed argument type from Node to Range.

(WebCore::SpellChecker::doRequestCheckingFor):
(WebCore::SpellChecker::didCheck):

• editing/SpellChecker.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• editing/Editor.cpp (modified) (1 diff)
• editing/SpellChecker.cpp (modified) (7 diffs)
• editing/SpellChecker.h (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2011-11-21  Shinya Kawanaka  <shinyak@google.com>
+
+        Refactoring: SpellChecker::requestCheckingFor should take Range instead of Node.
+        https://bugs.webkit.org/show_bug.cgi?id=72847
+
+        Reviewed by Hajime Morita.
+
+        Covered by existing test.
+
+        * editing/Editor.cpp:
+        (WebCore::Editor::replaceSelectionWithFragment):
+          Passes Range to requestCheckingFor instead of Node.
+        * editing/SpellChecker.cpp:
+          Changed argument type from Node to Range.
+          The corresponding changes are also done in dependent methods.
+        (WebCore::SpellChecker::initRequest):
+        (WebCore::SpellChecker::clearRequest):
+        (WebCore::SpellChecker::canCheckAsynchronously):
+        (WebCore::SpellChecker::isBusy):
+        (WebCore::SpellChecker::isValid):
+        (WebCore::SpellChecker::isCheckable):
+        (WebCore::SpellChecker::requestCheckingFor):
+          Changed argument type from Node to Range.
+        (WebCore::SpellChecker::doRequestCheckingFor):
+        (WebCore::SpellChecker::didCheck):
+        * editing/SpellChecker.h:
+
 2011-11-20  Kenichi Ishibashi  <bashi@chromium.org>
 

trunk/Source/WebCore/editing/Editor.cpp

@@ -414 +414 @@
 
     Node* nodeToCheck = m_frame->selection()->rootEditableElement();
-    if (m_spellChecker->canCheckAsynchronously(nodeToCheck))
-        m_spellChecker->requestCheckingFor(resolveTextCheckingTypeMask(TextCheckingTypeSpelling | TextCheckingTypeGrammar), nodeToCheck);
+    if (!nodeToCheck)
+        return;
+
+    m_spellChecker->requestCheckingFor(resolveTextCheckingTypeMask(TextCheckingTypeSpelling | TextCheckingTypeGrammar),
+        Range::create(m_frame->document(), firstPositionInNode(nodeToCheck), lastPositionInNode(nodeToCheck)));
 }
 

trunk/Source/WebCore/editing/SpellChecker.cpp

@@ -40 +40 @@
 #include "Settings.h"
 #include "TextCheckerClient.h"
+#include "TextCheckingHelper.h"
 #include "TextIterator.h"
 #include "htmlediting.h"
@@ -63 +64 @@
 }
 
-bool SpellChecker::initRequest(Node* node)
-{
-    ASSERT(canCheckAsynchronously(node));
-
-    String text = node->textContent();
+bool SpellChecker::initRequest(PassRefPtr<Range> range)
+{
+    ASSERT(canCheckAsynchronously(range.get()));
+
+    String text = range->text();
     if (!text.length())
         return false;
 
-    m_requestNode = node;
+    m_requestRange = range;
     m_requestText = text;
     m_requestSequence++;
@@ -80 +81 @@
 void SpellChecker::clearRequest()
 {
-    m_requestNode.clear();
+    m_requestRange.clear();
     m_requestText = String();
 }
@@ -89 +90 @@
 }
 
-bool SpellChecker::canCheckAsynchronously(Node* node) const
-{
-    return client() && isCheckable(node) && isAsynchronousEnabled() && !isBusy();
+bool SpellChecker::canCheckAsynchronously(Range* range) const
+{
+    return client() && isCheckable(range) && isAsynchronousEnabled() && !isBusy();
 }
 
 bool SpellChecker::isBusy() const
 {
-    return m_requestNode.get();
+    return m_requestRange.get();
 }
 
 bool SpellChecker::isValid(int sequence) const
 {
-    return m_requestNode.get() && m_requestText.length() && m_requestSequence == sequence;
-}
-
-bool SpellChecker::isCheckable(Node* node) const
-{
-    return node && node->renderer();
-}
-
-void SpellChecker::requestCheckingFor(TextCheckingTypeMask mask, Node* node)
-{
-    ASSERT(canCheckAsynchronously(node));
-
-    if (!initRequest(node))
+    return m_requestRange.get() && m_requestText.length() && m_requestSequence == sequence;
+}
+
+bool SpellChecker::isCheckable(Range* range) const
+{
+    return range && range->firstNode() && range->firstNode()->renderer();
+}
+
+void SpellChecker::requestCheckingFor(TextCheckingTypeMask mask, PassRefPtr<Range> range)
+{
+    if (!canCheckAsynchronously(range.get()))
+        return;
+
+    doRequestCheckingFor(mask, range);
+}
+
+void SpellChecker::doRequestCheckingFor(TextCheckingTypeMask mask, PassRefPtr<Range> range)
+{
+    ASSERT(canCheckAsynchronously(range.get()));
+
+    if (!initRequest(range))
         return;
     client()->requestCheckingOfString(this, m_requestSequence, mask, m_requestText);
@@ -154 +163 @@
         return;
 
-    if (!m_requestNode->renderer()) {
+    if (!isCheckable(m_requestRange.get())) {
         clearRequest();
         return;
@@ -160 +169 @@
 
     int startOffset = 0;
-    PositionIterator start = firstPositionInOrBeforeNode(m_requestNode.get());
+    PositionIterator start = m_requestRange->startPosition();
     for (size_t i = 0; i < results.size(); ++i) {
         if (results[i].type != TextCheckingTypeSpelling && results[i].type != TextCheckingTypeGrammar)
@@ -178 +187 @@
         // JavaScript applications, retrieve the words in the specified region and compare them with
         // the original ones.
-        RefPtr<Range> range = Range::create(m_requestNode->document(), start, end);
+        RefPtr<Range> range = Range::create(m_requestRange->ownerDocument(), start, end);
         // FIXME: Use textContent() compatible string conversion.
         String destination = range->text();
         String source = m_requestText.substring(results[i].location, results[i].length);
         if (destination == source)
-            m_requestNode->document()->markers()->addMarker(range.get(), toMarkerType(results[i].type));
+            m_requestRange->ownerDocument()->markers()->addMarker(range.get(), toMarkerType(results[i].type));
 
         startOffset = results[i].location;

trunk/Source/WebCore/editing/SpellChecker.h

@@ -39 +39 @@
 class TextCheckerClient;
 struct TextCheckingResult;
+class Range;
 
 class SpellChecker {
@@ -47 +48 @@
 
     bool isAsynchronousEnabled() const;
-    bool canCheckAsynchronously(Node*) const;
+    bool canCheckAsynchronously(Range*) const;
     bool isBusy() const;
     bool isValid(int sequence) const;
-    bool isCheckable(Node*) const;
-    void requestCheckingFor(TextCheckingTypeMask, Node*);
+    bool isCheckable(Range*) const;
+    void requestCheckingFor(TextCheckingTypeMask, PassRefPtr<Range>);
     void didCheck(int sequence, const Vector<TextCheckingResult>&);
 
 private:
-    bool initRequest(Node*);
+    bool initRequest(PassRefPtr<Range>);
     void clearRequest();
+    void doRequestCheckingFor(TextCheckingTypeMask, PassRefPtr<Range>);
     TextCheckerClient* client() const;
 
     Frame* m_frame;
 
-    RefPtr<Node> m_requestNode;
+    RefPtr<Range> m_requestRange;
     String m_requestText;
     int m_requestSequence;