Unreviewed, rolling out r141479.
[WebKit-https.git] / Source / WebKit / chromium / src / EditorClientImpl.cpp
1 /*
2  * Copyright (C) 2006, 2007 Apple, Inc.  All rights reserved.
3  * Copyright (C) 2012 Google, Inc.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #include "config.h"
28 #include "EditorClientImpl.h"
29
30 #include "Document.h"
31 #include "Editor.h"
32 #include "EventHandler.h"
33 #include "EventNames.h"
34 #include "Frame.h"
35 #include "HTMLInputElement.h"
36 #include "HTMLNames.h"
37 #include "KeyboardCodes.h"
38 #include "KeyboardEvent.h"
39 #include "PlatformKeyboardEvent.h"
40 #include "RenderObject.h"
41 #include "Settings.h"
42 #include "SpellChecker.h"
43 #include "UndoStep.h"
44
45 #include "DOMUtilitiesPrivate.h"
46 #include "WebAutofillClient.h"
47 #include "WebEditingAction.h"
48 #include "WebElement.h"
49 #include "WebFrameClient.h"
50 #include "WebFrameImpl.h"
51 #include "WebInputElement.h"
52 #include "WebInputEventConversion.h"
53 #include "WebKit.h"
54 #include "WebNode.h"
55 #include "WebPermissionClient.h"
56 #include "WebRange.h"
57 #include "WebSpellCheckClient.h"
58 #include "WebTextAffinity.h"
59 #include "WebTextCheckingCompletionImpl.h"
60 #include "WebTextCheckingResult.h"
61 #include "WebViewClient.h"
62 #include "WebViewImpl.h"
63 #include <wtf/text/WTFString.h>
64
65 using namespace WebCore;
66
67 namespace WebKit {
68
69 // Arbitrary depth limit for the undo stack, to keep it from using
70 // unbounded memory.  This is the maximum number of distinct undoable
71 // actions -- unbroken stretches of typed characters are coalesced
72 // into a single action.
73 static const size_t maximumUndoStackDepth = 1000;
74
75 EditorClientImpl::EditorClientImpl(WebViewImpl* webview)
76     : m_webView(webview)
77     , m_inRedo(false)
78     , m_spellCheckThisFieldStatus(SpellCheckAutomatic)
79 {
80 }
81
82 EditorClientImpl::~EditorClientImpl()
83 {
84 }
85
86 void EditorClientImpl::pageDestroyed()
87 {
88     // Our lifetime is bound to the WebViewImpl.
89 }
90
91 void EditorClientImpl::frameWillDetachPage(WebCore::Frame* frame)
92 {
93 }
94
95 bool EditorClientImpl::shouldShowDeleteInterface(HTMLElement* elem)
96 {
97     // Normally, we don't care to show WebCore's deletion UI, so we only enable
98     // it if in testing mode and the test specifically requests it by using this
99     // magic class name.
100     return layoutTestMode()
101            && elem->getAttribute(HTMLNames::classAttr) == "needsDeletionUI";
102 }
103
104 bool EditorClientImpl::smartInsertDeleteEnabled()
105 {
106     if (m_webView->client())
107         return m_webView->client()->isSmartInsertDeleteEnabled();
108     return true;
109 }
110
111 bool EditorClientImpl::isSelectTrailingWhitespaceEnabled()
112 {
113     if (m_webView->client())
114         return m_webView->client()->isSelectTrailingWhitespaceEnabled();
115 #if OS(WINDOWS)
116     return true;
117 #else
118     return false;
119 #endif
120 }
121
122 bool EditorClientImpl::shouldSpellcheckByDefault()
123 {
124     // Spellcheck should be enabled for all editable areas (such as textareas,
125     // contentEditable regions, and designMode docs), except text inputs.
126     const Frame* frame = m_webView->focusedWebCoreFrame();
127     if (!frame)
128         return false;
129     const Editor* editor = frame->editor();
130     if (!editor)
131         return false;
132     if (editor->isSpellCheckingEnabledInFocusedNode())
133         return true;
134     const Document* document = frame->document();
135     if (!document)
136         return false;
137     const Node* node = document->focusedNode();
138     // If |node| is null, we default to allowing spellchecking. This is done in
139     // order to mitigate the issue when the user clicks outside the textbox, as a
140     // result of which |node| becomes null, resulting in all the spell check
141     // markers being deleted. Also, the Frame will decide not to do spellchecking
142     // if the user can't edit - so returning true here will not cause any problems
143     // to the Frame's behavior.
144     if (!node)
145         return true;
146     const RenderObject* renderer = node->renderer();
147     if (!renderer)
148         return false;
149
150     return !renderer->isTextField();
151 }
152
153 bool EditorClientImpl::isContinuousSpellCheckingEnabled()
154 {
155     if (m_spellCheckThisFieldStatus == SpellCheckForcedOff)
156         return false;
157     if (m_spellCheckThisFieldStatus == SpellCheckForcedOn)
158         return true;
159     return shouldSpellcheckByDefault();
160 }
161
162 void EditorClientImpl::toggleContinuousSpellChecking()
163 {
164     if (isContinuousSpellCheckingEnabled())
165         m_spellCheckThisFieldStatus = SpellCheckForcedOff;
166     else
167         m_spellCheckThisFieldStatus = SpellCheckForcedOn;
168 }
169
170 bool EditorClientImpl::isGrammarCheckingEnabled()
171 {
172     const Frame* frame = m_webView->focusedWebCoreFrame();
173     return frame && frame->settings() && (frame->settings()->asynchronousSpellCheckingEnabled() || frame->settings()->unifiedTextCheckerEnabled());
174 }
175
176 void EditorClientImpl::toggleGrammarChecking()
177 {
178     notImplemented();
179 }
180
181 int EditorClientImpl::spellCheckerDocumentTag()
182 {
183     ASSERT_NOT_REACHED();
184     return 0;
185 }
186
187 bool EditorClientImpl::shouldBeginEditing(Range* range)
188 {
189     if (m_webView->client())
190         return m_webView->client()->shouldBeginEditing(WebRange(range));
191     return true;
192 }
193
194 bool EditorClientImpl::shouldEndEditing(Range* range)
195 {
196     if (m_webView->client())
197         return m_webView->client()->shouldEndEditing(WebRange(range));
198     return true;
199 }
200
201 bool EditorClientImpl::shouldInsertNode(Node* node,
202                                         Range* range,
203                                         EditorInsertAction action)
204 {
205     if (m_webView->client()) {
206         return m_webView->client()->shouldInsertNode(WebNode(node),
207                                                      WebRange(range),
208                                                      static_cast<WebEditingAction>(action));
209     }
210     return true;
211 }
212
213 bool EditorClientImpl::shouldInsertText(const String& text,
214                                         Range* range,
215                                         EditorInsertAction action)
216 {
217     if (m_webView->client()) {
218         return m_webView->client()->shouldInsertText(WebString(text),
219                                                      WebRange(range),
220                                                      static_cast<WebEditingAction>(action));
221     }
222     return true;
223 }
224
225
226 bool EditorClientImpl::shouldDeleteRange(Range* range)
227 {
228     if (m_webView->client())
229         return m_webView->client()->shouldDeleteRange(WebRange(range));
230     return true;
231 }
232
233 bool EditorClientImpl::shouldChangeSelectedRange(Range* fromRange,
234                                                  Range* toRange,
235                                                  EAffinity affinity,
236                                                  bool stillSelecting)
237 {
238     if (m_webView->client()) {
239         return m_webView->client()->shouldChangeSelectedRange(WebRange(fromRange),
240                                                               WebRange(toRange),
241                                                               static_cast<WebTextAffinity>(affinity),
242                                                               stillSelecting);
243     }
244     return true;
245 }
246
247 bool EditorClientImpl::shouldApplyStyle(StylePropertySet* style, Range* range)
248 {
249     if (m_webView->client()) {
250         // FIXME: Pass a reference to the CSSStyleDeclaration somehow.
251         return m_webView->client()->shouldApplyStyle(WebString(), WebRange(range));
252     }
253     return true;
254 }
255
256 bool EditorClientImpl::shouldMoveRangeAfterDelete(Range* range,
257                                                   Range* rangeToBeReplaced)
258 {
259     return true;
260 }
261
262 void EditorClientImpl::didBeginEditing()
263 {
264     if (m_webView->client())
265         m_webView->client()->didBeginEditing();
266 }
267
268 void EditorClientImpl::respondToChangedSelection(Frame* frame)
269 {
270     if (m_webView->client()) {
271         if (frame)
272             m_webView->client()->didChangeSelection(!frame->selection()->isRange());
273     }
274 }
275
276 void EditorClientImpl::respondToChangedContents()
277 {
278     if (m_webView->client())
279         m_webView->client()->didChangeContents();
280 }
281
282 void EditorClientImpl::didEndEditing()
283 {
284     if (m_webView->client())
285         m_webView->client()->didEndEditing();
286 }
287
288 void EditorClientImpl::didWriteSelectionToPasteboard()
289 {
290 }
291
292 void EditorClientImpl::willWriteSelectionToPasteboard(WebCore::Range*)
293 {
294 }
295
296 void EditorClientImpl::getClientPasteboardDataForRange(WebCore::Range*, Vector<String>& pasteboardTypes, Vector<RefPtr<WebCore::SharedBuffer> >& pasteboardData)
297 {
298 }
299
300 void EditorClientImpl::didSetSelectionTypesForPasteboard()
301 {
302 }
303
304 void EditorClientImpl::registerUndoStep(PassRefPtr<UndoStep> step)
305 {
306     if (m_undoStack.size() == maximumUndoStackDepth)
307         m_undoStack.removeFirst(); // drop oldest item off the far end
308     if (!m_inRedo)
309         m_redoStack.clear();
310     m_undoStack.append(step);
311 }
312
313 void EditorClientImpl::registerRedoStep(PassRefPtr<UndoStep> step)
314 {
315     m_redoStack.append(step);
316 }
317
318 void EditorClientImpl::clearUndoRedoOperations()
319 {
320     m_undoStack.clear();
321     m_redoStack.clear();
322 }
323
324 bool EditorClientImpl::canCopyCut(Frame* frame, bool defaultValue) const
325 {
326     if (!m_webView->permissionClient())
327         return defaultValue;
328     return m_webView->permissionClient()->allowWriteToClipboard(WebFrameImpl::fromFrame(frame), defaultValue);
329 }
330
331 bool EditorClientImpl::canPaste(Frame* frame, bool defaultValue) const
332 {
333     if (!m_webView->permissionClient())
334         return defaultValue;
335     return m_webView->permissionClient()->allowReadFromClipboard(WebFrameImpl::fromFrame(frame), defaultValue);
336 }
337
338 bool EditorClientImpl::canUndo() const
339 {
340     return !m_undoStack.isEmpty();
341 }
342
343 bool EditorClientImpl::canRedo() const
344 {
345     return !m_redoStack.isEmpty();
346 }
347
348 void EditorClientImpl::undo()
349 {
350     if (canUndo()) {
351         UndoManagerStack::iterator back = --m_undoStack.end();
352         RefPtr<UndoStep> step(*back);
353         m_undoStack.remove(back);
354         step->unapply();
355         // unapply will call us back to push this command onto the redo stack.
356     }
357 }
358
359 void EditorClientImpl::redo()
360 {
361     if (canRedo()) {
362         UndoManagerStack::iterator back = --m_redoStack.end();
363         RefPtr<UndoStep> step(*back);
364         m_redoStack.remove(back);
365
366         ASSERT(!m_inRedo);
367         m_inRedo = true;
368         step->reapply();
369         // reapply will call us back to push this command onto the undo stack.
370         m_inRedo = false;
371     }
372 }
373
374 //
375 // The below code was adapted from the WebKit file webview.cpp
376 //
377
378 static const unsigned CtrlKey = 1 << 0;
379 static const unsigned AltKey = 1 << 1;
380 static const unsigned ShiftKey = 1 << 2;
381 static const unsigned MetaKey = 1 << 3;
382 #if OS(DARWIN)
383 // Aliases for the generic key defintions to make kbd shortcuts definitions more
384 // readable on OS X.
385 static const unsigned OptionKey  = AltKey;
386
387 // Do not use this constant for anything but cursor movement commands. Keys
388 // with cmd set have their |isSystemKey| bit set, so chances are the shortcut
389 // will not be executed. Another, less important, reason is that shortcuts
390 // defined in the renderer do not blink the menu item that they triggered.  See
391 // http://crbug.com/25856 and the bugs linked from there for details.
392 static const unsigned CommandKey = MetaKey;
393 #endif
394
395 // Keys with special meaning. These will be delegated to the editor using
396 // the execCommand() method
397 struct KeyDownEntry {
398     unsigned virtualKey;
399     unsigned modifiers;
400     const char* name;
401 };
402
403 struct KeyPressEntry {
404     unsigned charCode;
405     unsigned modifiers;
406     const char* name;
407 };
408
409 static const KeyDownEntry keyDownEntries[] = {
410     { VKEY_LEFT,   0,                  "MoveLeft"                             },
411     { VKEY_LEFT,   ShiftKey,           "MoveLeftAndModifySelection"           },
412 #if OS(DARWIN)
413     { VKEY_LEFT,   OptionKey,          "MoveWordLeft"                         },
414     { VKEY_LEFT,   OptionKey | ShiftKey,
415         "MoveWordLeftAndModifySelection"                                      },
416 #else
417     { VKEY_LEFT,   CtrlKey,            "MoveWordLeft"                         },
418     { VKEY_LEFT,   CtrlKey | ShiftKey,
419         "MoveWordLeftAndModifySelection"                                      },
420 #endif
421     { VKEY_RIGHT,  0,                  "MoveRight"                            },
422     { VKEY_RIGHT,  ShiftKey,           "MoveRightAndModifySelection"          },
423 #if OS(DARWIN)
424     { VKEY_RIGHT,  OptionKey,          "MoveWordRight"                        },
425     { VKEY_RIGHT,  OptionKey | ShiftKey,
426       "MoveWordRightAndModifySelection"                                       },
427 #else
428     { VKEY_RIGHT,  CtrlKey,            "MoveWordRight"                        },
429     { VKEY_RIGHT,  CtrlKey | ShiftKey,
430       "MoveWordRightAndModifySelection"                                       },
431 #endif
432     { VKEY_UP,     0,                  "MoveUp"                               },
433     { VKEY_UP,     ShiftKey,           "MoveUpAndModifySelection"             },
434     { VKEY_PRIOR,  ShiftKey,           "MovePageUpAndModifySelection"         },
435     { VKEY_DOWN,   0,                  "MoveDown"                             },
436     { VKEY_DOWN,   ShiftKey,           "MoveDownAndModifySelection"           },
437     { VKEY_NEXT,   ShiftKey,           "MovePageDownAndModifySelection"       },
438 #if !OS(DARWIN)
439     { VKEY_PRIOR,  0,                  "MovePageUp"                           },
440     { VKEY_NEXT,   0,                  "MovePageDown"                         },
441 #endif
442     { VKEY_HOME,   0,                  "MoveToBeginningOfLine"                },
443     { VKEY_HOME,   ShiftKey,
444         "MoveToBeginningOfLineAndModifySelection"                             },
445 #if OS(DARWIN)
446     { VKEY_LEFT,   CommandKey,         "MoveToBeginningOfLine"                },
447     { VKEY_LEFT,   CommandKey | ShiftKey,
448       "MoveToBeginningOfLineAndModifySelection"                               },
449     { VKEY_PRIOR,  OptionKey,          "MovePageUp"                           },
450     { VKEY_NEXT,   OptionKey,          "MovePageDown"                         },
451 #endif
452 #if OS(DARWIN)
453     { VKEY_UP,     CommandKey,         "MoveToBeginningOfDocument"            },
454     { VKEY_UP,     CommandKey | ShiftKey,
455         "MoveToBeginningOfDocumentAndModifySelection"                         },
456 #else
457     { VKEY_HOME,   CtrlKey,            "MoveToBeginningOfDocument"            },
458     { VKEY_HOME,   CtrlKey | ShiftKey,
459         "MoveToBeginningOfDocumentAndModifySelection"                         },
460 #endif
461     { VKEY_END,    0,                  "MoveToEndOfLine"                      },
462     { VKEY_END,    ShiftKey,           "MoveToEndOfLineAndModifySelection"    },
463 #if OS(DARWIN)
464     { VKEY_DOWN,   CommandKey,         "MoveToEndOfDocument"                  },
465     { VKEY_DOWN,   CommandKey | ShiftKey,
466         "MoveToEndOfDocumentAndModifySelection"                               },
467 #else
468     { VKEY_END,    CtrlKey,            "MoveToEndOfDocument"                  },
469     { VKEY_END,    CtrlKey | ShiftKey,
470         "MoveToEndOfDocumentAndModifySelection"                               },
471 #endif
472 #if OS(DARWIN)
473     { VKEY_RIGHT,  CommandKey,         "MoveToEndOfLine"                      },
474     { VKEY_RIGHT,  CommandKey | ShiftKey,
475         "MoveToEndOfLineAndModifySelection"                                   },
476 #endif
477     { VKEY_BACK,   0,                  "DeleteBackward"                       },
478     { VKEY_BACK,   ShiftKey,           "DeleteBackward"                       },
479     { VKEY_DELETE, 0,                  "DeleteForward"                        },
480 #if OS(DARWIN)
481     { VKEY_BACK,   OptionKey,          "DeleteWordBackward"                   },
482     { VKEY_DELETE, OptionKey,          "DeleteWordForward"                    },
483 #else
484     { VKEY_BACK,   CtrlKey,            "DeleteWordBackward"                   },
485     { VKEY_DELETE, CtrlKey,            "DeleteWordForward"                    },
486 #endif
487     { 'B',         CtrlKey,            "ToggleBold"                           },
488     { 'I',         CtrlKey,            "ToggleItalic"                         },
489     { 'U',         CtrlKey,            "ToggleUnderline"                      },
490     { VKEY_ESCAPE, 0,                  "Cancel"                               },
491     { VKEY_OEM_PERIOD, CtrlKey,        "Cancel"                               },
492     { VKEY_TAB,    0,                  "InsertTab"                            },
493     { VKEY_TAB,    ShiftKey,           "InsertBacktab"                        },
494     { VKEY_RETURN, 0,                  "InsertNewline"                        },
495     { VKEY_RETURN, CtrlKey,            "InsertNewline"                        },
496     { VKEY_RETURN, AltKey,             "InsertNewline"                        },
497     { VKEY_RETURN, AltKey | ShiftKey,  "InsertNewline"                        },
498     { VKEY_RETURN, ShiftKey,           "InsertLineBreak"                      },
499     { VKEY_INSERT, CtrlKey,            "Copy"                                 },
500     { VKEY_INSERT, ShiftKey,           "Paste"                                },
501     { VKEY_DELETE, ShiftKey,           "Cut"                                  },
502 #if !OS(DARWIN)
503     // On OS X, we pipe these back to the browser, so that it can do menu item
504     // blinking.
505     { 'C',         CtrlKey,            "Copy"                                 },
506     { 'V',         CtrlKey,            "Paste"                                },
507     { 'V',         CtrlKey | ShiftKey, "PasteAndMatchStyle"                   },
508     { 'X',         CtrlKey,            "Cut"                                  },
509     { 'A',         CtrlKey,            "SelectAll"                            },
510     { 'Z',         CtrlKey,            "Undo"                                 },
511     { 'Z',         CtrlKey | ShiftKey, "Redo"                                 },
512     { 'Y',         CtrlKey,            "Redo"                                 },
513 #endif
514 };
515
516 static const KeyPressEntry keyPressEntries[] = {
517     { '\t',   0,                  "InsertTab"                                 },
518     { '\t',   ShiftKey,           "InsertBacktab"                             },
519     { '\r',   0,                  "InsertNewline"                             },
520     { '\r',   CtrlKey,            "InsertNewline"                             },
521     { '\r',   ShiftKey,           "InsertLineBreak"                           },
522     { '\r',   AltKey,             "InsertNewline"                             },
523     { '\r',   AltKey | ShiftKey,  "InsertNewline"                             },
524 };
525
526 const char* EditorClientImpl::interpretKeyEvent(const KeyboardEvent* evt)
527 {
528     const PlatformKeyboardEvent* keyEvent = evt->keyEvent();
529     if (!keyEvent)
530         return "";
531
532     static HashMap<int, const char*>* keyDownCommandsMap = 0;
533     static HashMap<int, const char*>* keyPressCommandsMap = 0;
534
535     if (!keyDownCommandsMap) {
536         keyDownCommandsMap = new HashMap<int, const char*>;
537         keyPressCommandsMap = new HashMap<int, const char*>;
538
539         for (unsigned i = 0; i < arraysize(keyDownEntries); i++) {
540             keyDownCommandsMap->set(keyDownEntries[i].modifiers << 16 | keyDownEntries[i].virtualKey,
541                                     keyDownEntries[i].name);
542         }
543
544         for (unsigned i = 0; i < arraysize(keyPressEntries); i++) {
545             keyPressCommandsMap->set(keyPressEntries[i].modifiers << 16 | keyPressEntries[i].charCode,
546                                      keyPressEntries[i].name);
547         }
548     }
549
550     unsigned modifiers = 0;
551     if (keyEvent->shiftKey())
552         modifiers |= ShiftKey;
553     if (keyEvent->altKey())
554         modifiers |= AltKey;
555     if (keyEvent->ctrlKey())
556         modifiers |= CtrlKey;
557     if (keyEvent->metaKey())
558         modifiers |= MetaKey;
559
560     if (keyEvent->type() == PlatformEvent::RawKeyDown) {
561         int mapKey = modifiers << 16 | evt->keyCode();
562         return mapKey ? keyDownCommandsMap->get(mapKey) : 0;
563     }
564
565     int mapKey = modifiers << 16 | evt->charCode();
566     return mapKey ? keyPressCommandsMap->get(mapKey) : 0;
567 }
568
569 bool EditorClientImpl::handleEditingKeyboardEvent(KeyboardEvent* evt)
570 {
571     const PlatformKeyboardEvent* keyEvent = evt->keyEvent();
572     // do not treat this as text input if it's a system key event
573     if (!keyEvent || keyEvent->isSystemKey())
574         return false;
575
576     Frame* frame = evt->target()->toNode()->document()->frame();
577     if (!frame)
578         return false;
579
580     String commandName = interpretKeyEvent(evt);
581     Editor::Command command = frame->editor()->command(commandName);
582
583     if (keyEvent->type() == PlatformEvent::RawKeyDown) {
584         // WebKit doesn't have enough information about mode to decide how
585         // commands that just insert text if executed via Editor should be treated,
586         // so we leave it upon WebCore to either handle them immediately
587         // (e.g. Tab that changes focus) or let a keypress event be generated
588         // (e.g. Tab that inserts a Tab character, or Enter).
589         if (command.isTextInsertion() || commandName.isEmpty())
590             return false;
591         if (command.execute(evt)) {
592             if (m_webView->client())
593                 m_webView->client()->didExecuteCommand(WebString(commandName));
594             return true;
595         }
596         return false;
597     }
598
599     if (command.execute(evt)) {
600         if (m_webView->client())
601             m_webView->client()->didExecuteCommand(WebString(commandName));
602         return true;
603     }
604
605     // Here we need to filter key events.
606     // On Gtk/Linux, it emits key events with ASCII text and ctrl on for ctrl-<x>.
607     // In Webkit, EditorClient::handleKeyboardEvent in
608     // WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp drop such events.
609     // On Mac, it emits key events with ASCII text and meta on for Command-<x>.
610     // These key events should not emit text insert event.
611     // Alt key would be used to insert alternative character, so we should let
612     // through. Also note that Ctrl-Alt combination equals to AltGr key which is
613     // also used to insert alternative character.
614     // http://code.google.com/p/chromium/issues/detail?id=10846
615     // Windows sets both alt and meta are on when "Alt" key pressed.
616     // http://code.google.com/p/chromium/issues/detail?id=2215
617     // Also, we should not rely on an assumption that keyboards don't
618     // send ASCII characters when pressing a control key on Windows,
619     // which may be configured to do it so by user.
620     // See also http://en.wikipedia.org/wiki/Keyboard_Layout
621     // FIXME(ukai): investigate more detail for various keyboard layout.
622     if (evt->keyEvent()->text().length() == 1) {
623         UChar ch = evt->keyEvent()->text()[0U];
624
625         // Don't insert null or control characters as they can result in
626         // unexpected behaviour
627         if (ch < ' ')
628             return false;
629 #if !OS(WINDOWS)
630         // Don't insert ASCII character if ctrl w/o alt or meta is on.
631         // On Mac, we should ignore events when meta is on (Command-<x>).
632         if (ch < 0x80) {
633             if (evt->keyEvent()->ctrlKey() && !evt->keyEvent()->altKey())
634                 return false;
635 #if OS(DARWIN)
636             if (evt->keyEvent()->metaKey())
637             return false;
638 #endif
639         }
640 #endif
641     }
642
643     if (!frame->editor()->canEdit())
644         return false;
645
646     return frame->editor()->insertText(evt->keyEvent()->text(), evt);
647 }
648
649 void EditorClientImpl::handleKeyboardEvent(KeyboardEvent* evt)
650 {
651     // Give the embedder a chance to handle the keyboard event.
652     if ((m_webView->client()
653          && m_webView->client()->handleCurrentKeyboardEvent())
654         || handleEditingKeyboardEvent(evt))
655         evt->setDefaultHandled();
656 }
657
658 void EditorClientImpl::handleInputMethodKeydown(KeyboardEvent* keyEvent)
659 {
660     // We handle IME within chrome.
661 }
662
663 void EditorClientImpl::textFieldDidBeginEditing(Element* element)
664 {
665 }
666
667 void EditorClientImpl::textFieldDidEndEditing(Element* element)
668 {
669     HTMLInputElement* inputElement = toHTMLInputElement(element);
670     if (m_webView->autofillClient() && inputElement)
671         m_webView->autofillClient()->textFieldDidEndEditing(WebInputElement(inputElement));
672
673     // Notification that focus was lost.  Be careful with this, it's also sent
674     // when the page is being closed.
675
676     // Hide any showing popup.
677     m_webView->hideAutofillPopup();
678 }
679
680 void EditorClientImpl::textDidChangeInTextField(Element* element)
681 {
682     ASSERT(element->hasLocalName(HTMLNames::inputTag));
683     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(element);
684     if (m_webView->autofillClient())
685         m_webView->autofillClient()->textFieldDidChange(WebInputElement(inputElement));
686 }
687
688 bool EditorClientImpl::doTextFieldCommandFromEvent(Element* element,
689                                                    KeyboardEvent* event)
690 {
691     HTMLInputElement* inputElement = toHTMLInputElement(element);
692     if (m_webView->autofillClient() && inputElement) {
693         m_webView->autofillClient()->textFieldDidReceiveKeyDown(WebInputElement(inputElement),
694                                                                 WebKeyboardEventBuilder(*event));
695     }
696
697     // The Mac code appears to use this method as a hook to implement special
698     // keyboard commands specific to Safari's auto-fill implementation.  We
699     // just return false to allow the default action.
700     return false;
701 }
702
703 void EditorClientImpl::textWillBeDeletedInTextField(Element*)
704 {
705 }
706
707 void EditorClientImpl::textDidChangeInTextArea(Element*)
708 {
709 }
710
711 bool EditorClientImpl::shouldEraseMarkersAfterChangeSelection(TextCheckingType type) const
712 {
713     const Frame* frame = m_webView->focusedWebCoreFrame();
714     return !frame || !frame->settings() || (!frame->settings()->asynchronousSpellCheckingEnabled() && !frame->settings()->unifiedTextCheckerEnabled());
715 }
716
717 void EditorClientImpl::ignoreWordInSpellDocument(const String&)
718 {
719     notImplemented();
720 }
721
722 void EditorClientImpl::learnWord(const String&)
723 {
724     notImplemented();
725 }
726
727 void EditorClientImpl::checkSpellingOfString(const UChar* text, int length,
728                                              int* misspellingLocation,
729                                              int* misspellingLength)
730 {
731     // SpellCheckWord will write (0, 0) into the output vars, which is what our
732     // caller expects if the word is spelled correctly.
733     int spellLocation = -1;
734     int spellLength = 0;
735
736     // Check to see if the provided text is spelled correctly.
737     if (m_webView->spellCheckClient())
738         m_webView->spellCheckClient()->spellCheck(WebString(text, length), spellLocation, spellLength, 0);
739     else {
740         spellLocation = 0;
741         spellLength = 0;
742     }
743
744     // Note: the Mac code checks if the pointers are null before writing to them,
745     // so we do too.
746     if (misspellingLocation)
747         *misspellingLocation = spellLocation;
748     if (misspellingLength)
749         *misspellingLength = spellLength;
750 }
751
752 void EditorClientImpl::requestCheckingOfString(WTF::PassRefPtr<WebCore::TextCheckingRequest> request)
753 {
754     if (m_webView->spellCheckClient()) {
755         String text = request->text();
756         m_webView->spellCheckClient()->requestCheckingOfText(text, new WebTextCheckingCompletionImpl(request));
757     }
758 }
759
760 String EditorClientImpl::getAutoCorrectSuggestionForMisspelledWord(const String& misspelledWord)
761 {
762     if (!(isContinuousSpellCheckingEnabled() && m_webView->client()))
763         return String();
764
765     // Do not autocorrect words with capital letters in it except the
766     // first letter. This will remove cases changing "IMB" to "IBM".
767     for (size_t i = 1; i < misspelledWord.length(); i++) {
768         if (u_isupper(static_cast<UChar32>(misspelledWord[i])))
769             return String();
770     }
771
772     if (m_webView->spellCheckClient())
773         return m_webView->spellCheckClient()->autoCorrectWord(WebString(misspelledWord));
774     return String();
775 }
776
777 void EditorClientImpl::checkGrammarOfString(const UChar* text, int length, WTF::Vector<GrammarDetail>& details, int* badGrammarLocation, int* badGrammarLength)
778 {
779     if (badGrammarLocation)
780         *badGrammarLocation = -1;
781     if (badGrammarLength)
782         *badGrammarLength = 0;
783
784     if (!m_webView->spellCheckClient())
785         return;
786     WebVector<WebTextCheckingResult> webResults;
787     m_webView->spellCheckClient()->checkTextOfParagraph(WebString(text, length), WebTextCheckingTypeGrammar, &webResults);
788     if (!webResults.size())
789         return;
790
791     // Convert a list of WebTextCheckingResults to a list of GrammarDetails. If
792     // the converted vector of GrammarDetails has grammar errors, we set
793     // badGrammarLocation and badGrammarLength to tell WebKit that the input
794     // text has grammar errors.
795     for (size_t i = 0; i < webResults.size(); ++i) {
796         if (webResults[i].type == WebTextCheckingTypeGrammar) {
797             GrammarDetail detail;
798             detail.location = webResults[i].location;
799             detail.length = webResults[i].length;
800             detail.userDescription = webResults[i].replacement;
801             details.append(detail);
802         }
803     }
804     if (!details.size())
805         return;
806     if (badGrammarLocation)
807         *badGrammarLocation = 0;
808     if (badGrammarLength)
809         *badGrammarLength = length;
810 }
811
812 void EditorClientImpl::checkTextOfParagraph(const UChar* text, int length,
813                                             TextCheckingTypeMask mask,
814                                             WTF::Vector<TextCheckingResult>& results)
815 {
816     if (!m_webView->spellCheckClient())
817         return;
818
819     WebTextCheckingTypeMask webMask = static_cast<WebTextCheckingTypeMask>(mask);
820     WebVector<WebTextCheckingResult> webResults;
821     m_webView->spellCheckClient()->checkTextOfParagraph(WebString(text, length), webMask, &webResults);
822
823     results.resize(webResults.size());
824     for (size_t i = 0; i < webResults.size(); ++i)
825         results[i] = webResults[i];
826 }
827
828 void EditorClientImpl::updateSpellingUIWithGrammarString(const String&,
829                                                          const GrammarDetail& detail)
830 {
831     notImplemented();
832 }
833
834 void EditorClientImpl::updateSpellingUIWithMisspelledWord(const String& misspelledWord)
835 {
836     if (m_webView->spellCheckClient())
837         m_webView->spellCheckClient()->updateSpellingUIWithMisspelledWord(WebString(misspelledWord));
838 }
839
840 void EditorClientImpl::showSpellingUI(bool show)
841 {
842     if (m_webView->spellCheckClient())
843         m_webView->spellCheckClient()->showSpellingUI(show);
844 }
845
846 bool EditorClientImpl::spellingUIIsShowing()
847 {
848     if (m_webView->spellCheckClient())
849         return m_webView->spellCheckClient()->isShowingSpellingUI();
850     return false;
851 }
852
853 void EditorClientImpl::getGuessesForWord(const String& word,
854                                          const String& context,
855                                          WTF::Vector<String>& guesses)
856 {
857     notImplemented();
858 }
859
860 bool EditorClientImpl::supportsGlobalSelection()
861 {
862 #if OS(UNIX) && !OS(DARWIN)
863     return true;
864 #else
865     return false;
866 #endif
867 }
868
869 void EditorClientImpl::willSetInputMethodState()
870 {
871     if (m_webView->client())
872         m_webView->client()->resetInputMethod();
873 }
874
875 void EditorClientImpl::setInputMethodState(bool)
876 {
877 }
878
879 } // namesace WebKit