Spell check whole content of an editable element when it gets focused.

Source/core/editing/Editor.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 999 matching lines @@
 }
 
 bool Editor::isContinuousSpellCheckingEnabled() const
 {
     return client().isContinuousSpellCheckingEnabled();
 }
 
 void Editor::toggleContinuousSpellChecking()
 {
     client().toggleContinuousSpellChecking();
+    if (!isContinuousSpellCheckingEnabled())
+        m_editablesSpellCheckedOnFocus.clear();
 }
 
 bool Editor::isGrammarCheckingEnabled()
 {
     return client().isGrammarCheckingEnabled();
 }
 
 bool Editor::shouldEndEditing(Range* range)
 {
     return client().shouldEndEditing(range);
@@ skipping 22 matching lines @@
 bool Editor::canRedo()
 {
     return client().canRedo();
 }
 
 void Editor::redo()
 {
     client().redo();
 }
 
-void Editor::didBeginEditing()
+void Editor::elementDidBeginEditing(Element* element)
 {
+    if (isContinuousSpellCheckingEnabled() && unifiedTextCheckerEnabled()) {
+        // This could be called for textareas, text fields and contenteditables.
+        // Markers from text fields are cleared on blur so text fields have to be spell cheked on each focus as opposed
+        // to textareas and contenteditables which should be spell checked on the first focus only.
+        // This is also why text fields are not put into m_editablesSpellCheckedOnFocus.
+        // For textareas HTMLTextFormControlElement is put into m_editablesSpellCheckedOnFocus but spell checking
+        // is performed on its inner text element (the latter also applies to text fields). For contenteditables
+        // the passed in element is put into m_editablesSpellCheckedOnFocus (it's the root editable element).

[tony, 2013/08/20 22:10:39]

This style of comment that describes behavior is better for the commit
description.  The behavior is likely to change in the future and this comment
likely to bitrot.

I would rename m_editablesSpellCheckedOnFocus to something like
m_alreadySpellCheckedEditables or something.  Maybe
editablesAlreadySpellChecked?

+        bool isTextField = false;
+        HTMLTextFormControlElement* enclosingHTMLTextFormControlElement = 0;
+        if (!isHTMLTextFormControlElement(element))
+            enclosingHTMLTextFormControlElement = enclosingTextFormControl(firstPositionInNode(element));
+        element = enclosingHTMLTextFormControlElement ? enclosingHTMLTextFormControlElement : element;
+        Element* parent = element;
+        if (isHTMLTextFormControlElement(element)) {
+            HTMLTextFormControlElement* textControl = toHTMLTextFormControlElement(element);
+            parent = textControl;
+            element = textControl->innerTextElement();
+            isTextField = textControl->hasTagName(inputTag) && toHTMLInputElement(textControl)->isTextField();
+        }
+
+        if (isTextField || !m_editablesSpellCheckedOnFocus.contains(parent)) {
+            VisibleSelection selection = VisibleSelection::selectionFromContentsOfNode(element);
+            markMisspellingsAndBadGrammar(selection);
+            if (!isTextField)
+                m_editablesSpellCheckedOnFocus.append(parent);

[tony, 2013/08/20 22:10:39]

You could put a 'why' comment here: We always recheck textfields because markers
are removed on blur.

+        }
+    }
+}
+
+void Editor::didBeginEditing(Element* rootEditableElement)
+{
+    elementDidBeginEditing(rootEditableElement);
     client().didBeginEditing();
 }
 
-void Editor::didEndEditing()
+void Editor::didEndEditing(Element*)
 {
     client().didEndEditing();
 }
 
 void Editor::setBaseWritingDirection(WritingDirection direction)
 {
     Node* focusedElement = frame()->document()->focusedElement();
     if (focusedElement && isHTMLTextFormControlElement(focusedElement)) {
         if (direction == NaturalWritingDirection)
             return;
@@ skipping 782 matching lines @@
 
     // Handle block styles, substracting these from the typing style.
     RefPtr<EditingStyle> blockStyle = typingStyle->extractAndRemoveBlockProperties();
     if (!blockStyle->isEmpty())
         applyCommand(ApplyStyleCommand::create(m_frame->document(), blockStyle.get(), editingAction));
 
     // Set the remaining style as the typing style.
     m_frame->selection()->setTypingStyle(typingStyle);
 }
 
-
-void Editor::textFieldDidBeginEditing(Element* e)
+void Editor::textAreaOrTextFieldDidBeginEditing(Element* e)
 {
-    if (isContinuousSpellCheckingEnabled()) {
-        Element* element = toHTMLTextFormControlElement(e)->innerTextElement();
-        VisibleSelection selection = VisibleSelection::selectionFromContentsOfNode(element);
-        markMisspellingsAndBadGrammar(selection);
-    }
+    elementDidBeginEditing(e);
 }
 
 void Editor::textFieldDidEndEditing(Element* e)
 {
     // Remove markers when deactivating a selection in an <input type="text"/>.
     // Prevent new ones from appearing too.
     m_spellCheckRequester->cancelCheck();
     HTMLTextFormControlElement* textFormControlElement = toHTMLTextFormControlElement(e);
     HTMLElement* innerText = textFormControlElement->innerTextElement();
     DocumentMarker::MarkerTypes markerTypes(DocumentMarker::Spelling);
@@ skipping 286 matching lines @@
     return WebCore::unifiedTextCheckerEnabled(m_frame);
 }
 
 void Editor::toggleOverwriteModeEnabled()
 {
     m_overwriteModeEnabled = !m_overwriteModeEnabled;
     frame()->selection()->setShouldShowBlockCursor(m_overwriteModeEnabled);
 };
 
 } // namespace WebCore