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

Source/core/editing/Editor.h

 /*
  * Copyright (C) 2006, 2007, 2008 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 196 matching lines @@
 
     bool shouldBeginEditing(Range*);
     bool shouldEndEditing(Range*);
 
     void clearUndoRedoOperations();
     bool canUndo();
     void undo();
     bool canRedo();
     void redo();
 
-    void didBeginEditing();
-    void didEndEditing();
+    void didBeginEditing(Element*);
+    void didEndEditing(Element*);

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

It doesn't look like we use Element in didEndEditing.

 
     void setBaseWritingDirection(WritingDirection);
 
     // smartInsertDeleteEnabled and selectTrailingWhitespaceEnabled are
     // mutually exclusive, meaning that enabling one will disable the other.
     bool smartInsertDeleteEnabled();
     bool isSelectTrailingWhitespaceEnabled();
 
     bool setSelectionOffsets(int selectionStart, int selectionEnd);
 
@@ skipping 45 matching lines @@
 
     void respondToChangedSelection(const VisibleSelection& oldSelection, FrameSelection::SetSelectionOptions);
     bool shouldChangeSelection(const VisibleSelection& oldSelection, const VisibleSelection& newSelection, EAffinity, bool stillSelecting) const;
 
     void spellCheckAfterBlur();
     void spellCheckOldSelection(const VisibleSelection& oldSelection, const VisibleSelection& newAdjacentWords, const VisibleSelection& newSelectedSentence);
 
     bool markedTextMatchesAreHighlighted() const;
     void setMarkedTextMatchesAreHighlighted(bool);
 
-    void textFieldDidBeginEditing(Element*);
+    void textAreaOrTextFieldDidBeginEditing(Element*);
     void textFieldDidEndEditing(Element*);
     void textDidChangeInTextField(Element*);
     bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*);
     WritingDirection baseWritingDirectionForSelectionStart() const;
 
     void replaceSelectionWithFragment(PassRefPtr<DocumentFragment>, bool selectReplacement, bool smartReplace, bool matchStyle);
     void replaceSelectionWithText(const String&, bool selectReplacement, bool smartReplace);
     bool selectionStartHasMarkerFor(DocumentMarker::MarkerType, int from, int length) const;
     void updateMarkersForWordsAffectedByEditing(bool onlyHandleWordsContainingSelection);
 
     void simplifyMarkup(Node* startNode, Node* endNode);
 
     void deviceScaleFactorChanged();
 
     EditorParagraphSeparator defaultParagraphSeparator() const { return m_defaultParagraphSeparator; }
     void setDefaultParagraphSeparator(EditorParagraphSeparator separator) { m_defaultParagraphSeparator = separator; }
 
     class RevealSelectionScope {
         WTF_MAKE_NONCOPYABLE(RevealSelectionScope);
     public:
         RevealSelectionScope(Editor*);
         ~RevealSelectionScope();
     private:
         Editor* m_editor;
     };
     friend class RevealSelectionScope;
 
+    // Spell checks whole contents of a editable element (<input="text"/>, <textarea> or contenteditable)
+    // This gets called when any editable element gets focused.

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

I would remove this comment.  It's a 'what' comment instead of a 'why' comment
and it seems like it would easily get out of date.

+    void elementDidBeginEditing(Element*);
+
 private:
     RefPtr<CompositeEditCommand> m_lastEditCommand;
     RefPtr<Node> m_removedAnchor;
     int m_preventRevealSelection;
     bool m_shouldStartNewKillRingSequence;
     bool m_shouldStyleWithCSS;
     OwnPtr<KillRing> m_killRing;
     const OwnPtr<SpellCheckRequester> m_spellCheckRequester;
     VisibleSelection m_mark;
     bool m_areMarkedTextMatchesHighlighted;
     EditorParagraphSeparator m_defaultParagraphSeparator;
     bool m_overwriteModeEnabled;
+    Vector<RefPtr<Node> > m_editablesSpellCheckedOnFocus;

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

This should be a HashSet, not a Vector.

Also, why do you hold a ref?  If someone removes the node from the DOM, the ref
is going to keep it alive until the page is unloaded.

Even if you switch it to a HashSet<Node*>, it seems like it's possible for
unbounded growth if you dynamically create editable areas.  On a site like
gmail, that's bad.

[pstanek, 2013/08/21 06:05:18]

I was thinking the same i.e. it's only a key so Node* would do but then I looked
how spelling and grammar markers are kept. They also keep refs in their hashset
which also looks unneeded so I came to conclusion that I might not know
something and there is some reason behind this so I used refs here as well.

 
     bool canDeleteRange(Range*) const;
     bool canSmartReplaceWithPasteboard(Pasteboard*);
     PassRefPtr<Clipboard> newGeneralClipboard(ClipboardAccessPolicy, Frame*);
     void pasteAsPlainTextWithPasteboard(Pasteboard*);
     void pasteWithPasteboard(Pasteboard*, bool allowPlainText);
 
     void revealSelectionAfterEditingOperation(const ScrollAlignment& = ScrollAlignment::alignCenterIfNeeded, RevealExtentOption = DoNotRevealExtent);
     void markMisspellingsOrBadGrammar(const VisibleSelection&, bool checkSpelling, RefPtr<Range>& firstMisspellingRange);
     TextCheckingTypeMask resolveTextCheckingTypeMask(TextCheckingTypeMask);
@@ skipping 25 matching lines @@
 
 inline bool Editor::markedTextMatchesAreHighlighted() const
 {
     return m_areMarkedTextMatchesHighlighted;
 }
 
 
 } // namespace WebCore
 
 #endif // Editor_h