ca8d4f99e97c18ccf610d6bf2dbb92141373a7e1
[WebKit-https.git] / Source / WebKit / chromium / src / EditorClientImpl.cpp
1 /*
2  * Copyright (C) 2006, 2007 Apple, Inc.  All rights reserved.
3  * Copyright (C) 2010 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 "EditCommand.h"
32 #include "Editor.h"
33 #include "EventHandler.h"
34 #include "EventNames.h"
35 #include "Frame.h"
36 #include "HTMLInputElement.h"
37 #include "HTMLNames.h"
38 #include "KeyboardCodes.h"
39 #include "KeyboardEvent.h"
40 #include "PlatformKeyboardEvent.h"
41 #include "PlatformString.h"
42 #include "RenderObject.h"
43 #include "SpellChecker.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 "WebKit.h"
52 #include "WebInputElement.h"
53 #include "WebInputEventConversion.h"
54 #include "WebNode.h"
55 #include "WebPasswordAutocompleteListener.h"
56 #include "WebPermissionClient.h"
57 #include "WebRange.h"
58 #include "WebSpellCheckClient.h"
59 #include "WebTextAffinity.h"
60 #include "WebTextCheckingCompletionImpl.h"
61 #include "WebViewClient.h"
62 #include "WebViewImpl.h"
63
64 using namespace WebCore;
65
66 namespace WebKit {
67
68 // Arbitrary depth limit for the undo stack, to keep it from using
69 // unbounded memory.  This is the maximum number of distinct undoable
70 // actions -- unbroken stretches of typed characters are coalesced
71 // into a single action.
72 static const size_t maximumUndoStackDepth = 1000;
73
74 // The size above which we stop triggering autofill for an input text field
75 // (so to avoid sending long strings through IPC).
76 static const size_t maximumTextSizeForAutofill = 1000;
77
78 EditorClientImpl::EditorClientImpl(WebViewImpl* webview)
79     : m_webView(webview)
80     , m_inRedo(false)
81     , m_backspaceOrDeletePressed(false)
82     , m_spellCheckThisFieldStatus(SpellCheckAutomatic)
83     , m_autofillTimer(this, &EditorClientImpl::doAutofill)
84 {
85 }
86
87 EditorClientImpl::~EditorClientImpl()
88 {
89 }
90
91 void EditorClientImpl::pageDestroyed()
92 {
93     // Our lifetime is bound to the WebViewImpl.
94 }
95
96 bool EditorClientImpl::shouldShowDeleteInterface(HTMLElement* elem)
97 {
98     // Normally, we don't care to show WebCore's deletion UI, so we only enable
99     // it if in testing mode and the test specifically requests it by using this
100     // magic class name.
101     return layoutTestMode()
102            && elem->getAttribute(HTMLNames::classAttr) == "needsDeletionUI";
103 }
104
105 bool EditorClientImpl::smartInsertDeleteEnabled()
106 {
107     if (m_webView->client())
108         return m_webView->client()->isSmartInsertDeleteEnabled();
109     return true;
110 }
111
112 bool EditorClientImpl::isSelectTrailingWhitespaceEnabled()
113 {
114     if (m_webView->client())
115         return m_webView->client()->isSelectTrailingWhitespaceEnabled();
116 #if OS(WINDOWS)
117     return true;
118 #else
119     return false;
120 #endif
121 }
122
123 bool EditorClientImpl::shouldSpellcheckByDefault()
124 {
125     // Spellcheck should be enabled for all editable areas (such as textareas,
126     // contentEditable regions, and designMode docs), except text inputs.
127     const Frame* frame = m_webView->focusedWebCoreFrame();
128     if (!frame)
129         return false;
130     const Editor* editor = frame->editor();
131     if (!editor)
132         return false;
133     if (editor->isSpellCheckingEnabledInFocusedNode())
134         return true;
135     const Document* document = frame->document();
136     if (!document)
137         return false;
138     const Node* node = document->focusedNode();
139     // If |node| is null, we default to allowing spellchecking. This is done in
140     // order to mitigate the issue when the user clicks outside the textbox, as a
141     // result of which |node| becomes null, resulting in all the spell check
142     // markers being deleted. Also, the Frame will decide not to do spellchecking
143     // if the user can't edit - so returning true here will not cause any problems
144     // to the Frame's behavior.
145     if (!node)
146         return true;
147     const RenderObject* renderer = node->renderer();
148     if (!renderer)
149         return false;
150
151     return !renderer->isTextField();
152 }
153
154 bool EditorClientImpl::isContinuousSpellCheckingEnabled()
155 {
156     if (m_spellCheckThisFieldStatus == SpellCheckForcedOff)
157         return false;
158     if (m_spellCheckThisFieldStatus == SpellCheckForcedOn)
159         return true;
160     return shouldSpellcheckByDefault();
161 }
162
163 void EditorClientImpl::toggleContinuousSpellChecking()
164 {
165     if (isContinuousSpellCheckingEnabled())
166         m_spellCheckThisFieldStatus = SpellCheckForcedOff;
167     else
168         m_spellCheckThisFieldStatus = SpellCheckForcedOn;
169 }
170
171 bool EditorClientImpl::isGrammarCheckingEnabled()
172 {
173     return false;
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(CSSStyleDeclaration* style,
248                                         Range* range)
249 {
250     if (m_webView->client()) {
251         // FIXME: Pass a reference to the CSSStyleDeclaration somehow.
252         return m_webView->client()->shouldApplyStyle(WebString(),
253                                                      WebRange(range));
254     }
255     return true;
256 }
257
258 bool EditorClientImpl::shouldMoveRangeAfterDelete(Range* range,
259                                                   Range* rangeToBeReplaced)
260 {
261     return true;
262 }
263
264 void EditorClientImpl::didBeginEditing()
265 {
266     if (m_webView->client())
267         m_webView->client()->didBeginEditing();
268 }
269
270 void EditorClientImpl::respondToChangedSelection()
271 {
272     if (m_webView->client()) {
273         Frame* frame = m_webView->focusedWebCoreFrame();
274         if (frame)
275             m_webView->client()->didChangeSelection(!frame->selection()->isRange());
276     }
277 }
278
279 void EditorClientImpl::respondToChangedContents()
280 {
281     if (m_webView->client())
282         m_webView->client()->didChangeContents();
283 }
284
285 void EditorClientImpl::didEndEditing()
286 {
287     if (m_webView->client())
288         m_webView->client()->didEndEditing();
289 }
290
291 void EditorClientImpl::didWriteSelectionToPasteboard()
292 {
293 }
294
295 void EditorClientImpl::didSetSelectionTypesForPasteboard()
296 {
297 }
298
299 void EditorClientImpl::registerCommandForUndo(PassRefPtr<EditCommand> command)
300 {
301     if (m_undoStack.size() == maximumUndoStackDepth)
302         m_undoStack.removeFirst(); // drop oldest item off the far end
303     if (!m_inRedo)
304         m_redoStack.clear();
305     m_undoStack.append(command);
306 }
307
308 void EditorClientImpl::registerCommandForRedo(PassRefPtr<EditCommand> command)
309 {
310     m_redoStack.append(command);
311 }
312
313 void EditorClientImpl::clearUndoRedoOperations()
314 {
315     m_undoStack.clear();
316     m_redoStack.clear();
317 }
318
319 bool EditorClientImpl::canCopyCut(Frame* frame, bool defaultValue) const
320 {
321     if (!m_webView->permissionClient())
322         return defaultValue;
323     return m_webView->permissionClient()->allowWriteToClipboard(WebFrameImpl::fromFrame(frame), defaultValue);
324 }
325
326 bool EditorClientImpl::canPaste(Frame* frame, bool defaultValue) const
327 {
328     if (!m_webView->permissionClient())
329         return defaultValue;
330     return m_webView->permissionClient()->allowReadFromClipboard(WebFrameImpl::fromFrame(frame), defaultValue);
331 }
332
333 bool EditorClientImpl::canUndo() const
334 {
335     return !m_undoStack.isEmpty();
336 }
337
338 bool EditorClientImpl::canRedo() const
339 {
340     return !m_redoStack.isEmpty();
341 }
342
343 void EditorClientImpl::undo()
344 {
345     if (canUndo()) {
346         EditCommandStack::iterator back = --m_undoStack.end();
347         RefPtr<EditCommand> command(*back);
348         m_undoStack.remove(back);
349         command->unapply();
350         // unapply will call us back to push this command onto the redo stack.
351     }
352 }
353
354 void EditorClientImpl::redo()
355 {
356     if (canRedo()) {
357         EditCommandStack::iterator back = --m_redoStack.end();
358         RefPtr<EditCommand> command(*back);
359         m_redoStack.remove(back);
360
361         ASSERT(!m_inRedo);
362         m_inRedo = true;
363         command->reapply();
364         // reapply will call us back to push this command onto the undo stack.
365         m_inRedo = false;
366     }
367 }
368
369 //
370 // The below code was adapted from the WebKit file webview.cpp
371 //
372
373 static const unsigned CtrlKey = 1 << 0;
374 static const unsigned AltKey = 1 << 1;
375 static const unsigned ShiftKey = 1 << 2;
376 static const unsigned MetaKey = 1 << 3;
377 #if OS(DARWIN)
378 // Aliases for the generic key defintions to make kbd shortcuts definitions more
379 // readable on OS X.
380 static const unsigned OptionKey  = AltKey;
381
382 // Do not use this constant for anything but cursor movement commands. Keys
383 // with cmd set have their |isSystemKey| bit set, so chances are the shortcut
384 // will not be executed. Another, less important, reason is that shortcuts
385 // defined in the renderer do not blink the menu item that they triggered.  See
386 // http://crbug.com/25856 and the bugs linked from there for details.
387 static const unsigned CommandKey = MetaKey;
388 #endif
389
390 // Keys with special meaning. These will be delegated to the editor using
391 // the execCommand() method
392 struct KeyDownEntry {
393     unsigned virtualKey;
394     unsigned modifiers;
395     const char* name;
396 };
397
398 struct KeyPressEntry {
399     unsigned charCode;
400     unsigned modifiers;
401     const char* name;
402 };
403
404 static const KeyDownEntry keyDownEntries[] = {
405     { VKEY_LEFT,   0,                  "MoveLeft"                             },
406     { VKEY_LEFT,   ShiftKey,           "MoveLeftAndModifySelection"           },
407 #if OS(DARWIN)
408     { VKEY_LEFT,   OptionKey,          "MoveWordLeft"                         },
409     { VKEY_LEFT,   OptionKey | ShiftKey,
410         "MoveWordLeftAndModifySelection"                                      },
411 #else
412     { VKEY_LEFT,   CtrlKey,            "MoveWordLeft"                         },
413     { VKEY_LEFT,   CtrlKey | ShiftKey,
414         "MoveWordLeftAndModifySelection"                                      },
415 #endif
416     { VKEY_RIGHT,  0,                  "MoveRight"                            },
417     { VKEY_RIGHT,  ShiftKey,           "MoveRightAndModifySelection"          },
418 #if OS(DARWIN)
419     { VKEY_RIGHT,  OptionKey,          "MoveWordRight"                        },
420     { VKEY_RIGHT,  OptionKey | ShiftKey,
421       "MoveWordRightAndModifySelection"                                       },
422 #else
423     { VKEY_RIGHT,  CtrlKey,            "MoveWordRight"                        },
424     { VKEY_RIGHT,  CtrlKey | ShiftKey,
425       "MoveWordRightAndModifySelection"                                       },
426 #endif
427     { VKEY_UP,     0,                  "MoveUp"                               },
428     { VKEY_UP,     ShiftKey,           "MoveUpAndModifySelection"             },
429     { VKEY_PRIOR,  ShiftKey,           "MovePageUpAndModifySelection"         },
430     { VKEY_DOWN,   0,                  "MoveDown"                             },
431     { VKEY_DOWN,   ShiftKey,           "MoveDownAndModifySelection"           },
432     { VKEY_NEXT,   ShiftKey,           "MovePageDownAndModifySelection"       },
433 #if !OS(DARWIN)
434     { VKEY_PRIOR,  0,                  "MovePageUp"                           },
435     { VKEY_NEXT,   0,                  "MovePageDown"                         },
436 #endif
437     { VKEY_HOME,   0,                  "MoveToBeginningOfLine"                },
438     { VKEY_HOME,   ShiftKey,
439         "MoveToBeginningOfLineAndModifySelection"                             },
440 #if OS(DARWIN)
441     { VKEY_LEFT,   CommandKey,         "MoveToBeginningOfLine"                },
442     { VKEY_LEFT,   CommandKey | ShiftKey,
443       "MoveToBeginningOfLineAndModifySelection"                               },
444     { VKEY_PRIOR,  OptionKey,          "MovePageUp"                           },
445     { VKEY_NEXT,   OptionKey,          "MovePageDown"                         },
446 #endif
447 #if OS(DARWIN)
448     { VKEY_UP,     CommandKey,         "MoveToBeginningOfDocument"            },
449     { VKEY_UP,     CommandKey | ShiftKey,
450         "MoveToBeginningOfDocumentAndModifySelection"                         },
451 #else
452     { VKEY_HOME,   CtrlKey,            "MoveToBeginningOfDocument"            },
453     { VKEY_HOME,   CtrlKey | ShiftKey,
454         "MoveToBeginningOfDocumentAndModifySelection"                         },
455 #endif
456     { VKEY_END,    0,                  "MoveToEndOfLine"                      },
457     { VKEY_END,    ShiftKey,           "MoveToEndOfLineAndModifySelection"    },
458 #if OS(DARWIN)
459     { VKEY_DOWN,   CommandKey,         "MoveToEndOfDocument"                  },
460     { VKEY_DOWN,   CommandKey | ShiftKey,
461         "MoveToEndOfDocumentAndModifySelection"                               },
462 #else
463     { VKEY_END,    CtrlKey,            "MoveToEndOfDocument"                  },
464     { VKEY_END,    CtrlKey | ShiftKey,
465         "MoveToEndOfDocumentAndModifySelection"                               },
466 #endif
467 #if OS(DARWIN)
468     { VKEY_RIGHT,  CommandKey,         "MoveToEndOfLine"                      },
469     { VKEY_RIGHT,  CommandKey | ShiftKey,
470         "MoveToEndOfLineAndModifySelection"                                   },
471 #endif
472     { VKEY_BACK,   0,                  "DeleteBackward"                       },
473     { VKEY_BACK,   ShiftKey,           "DeleteBackward"                       },
474     { VKEY_DELETE, 0,                  "DeleteForward"                        },
475 #if OS(DARWIN)
476     { VKEY_BACK,   OptionKey,          "DeleteWordBackward"                   },
477     { VKEY_DELETE, OptionKey,          "DeleteWordForward"                    },
478 #else
479     { VKEY_BACK,   CtrlKey,            "DeleteWordBackward"                   },
480     { VKEY_DELETE, CtrlKey,            "DeleteWordForward"                    },
481 #endif
482     { 'B',         CtrlKey,            "ToggleBold"                           },
483     { 'I',         CtrlKey,            "ToggleItalic"                         },
484     { 'U',         CtrlKey,            "ToggleUnderline"                      },
485     { VKEY_ESCAPE, 0,                  "Cancel"                               },
486     { VKEY_OEM_PERIOD, CtrlKey,        "Cancel"                               },
487     { VKEY_TAB,    0,                  "InsertTab"                            },
488     { VKEY_TAB,    ShiftKey,           "InsertBacktab"                        },
489     { VKEY_RETURN, 0,                  "InsertNewline"                        },
490     { VKEY_RETURN, CtrlKey,            "InsertNewline"                        },
491     { VKEY_RETURN, AltKey,             "InsertNewline"                        },
492     { VKEY_RETURN, AltKey | ShiftKey,  "InsertNewline"                        },
493     { VKEY_RETURN, ShiftKey,           "InsertLineBreak"                      },
494     { VKEY_INSERT, CtrlKey,            "Copy"                                 },
495     { VKEY_INSERT, ShiftKey,           "Paste"                                },
496     { VKEY_DELETE, ShiftKey,           "Cut"                                  },
497 #if !OS(DARWIN)
498     // On OS X, we pipe these back to the browser, so that it can do menu item
499     // blinking.
500     { 'C',         CtrlKey,            "Copy"                                 },
501     { 'V',         CtrlKey,            "Paste"                                },
502     { 'V',         CtrlKey | ShiftKey, "PasteAndMatchStyle"                   },
503     { 'X',         CtrlKey,            "Cut"                                  },
504     { 'A',         CtrlKey,            "SelectAll"                            },
505     { 'Z',         CtrlKey,            "Undo"                                 },
506     { 'Z',         CtrlKey | ShiftKey, "Redo"                                 },
507     { 'Y',         CtrlKey,            "Redo"                                 },
508 #endif
509 };
510
511 static const KeyPressEntry keyPressEntries[] = {
512     { '\t',   0,                  "InsertTab"                                 },
513     { '\t',   ShiftKey,           "InsertBacktab"                             },
514     { '\r',   0,                  "InsertNewline"                             },
515     { '\r',   CtrlKey,            "InsertNewline"                             },
516     { '\r',   ShiftKey,           "InsertLineBreak"                           },
517     { '\r',   AltKey,             "InsertNewline"                             },
518     { '\r',   AltKey | ShiftKey,  "InsertNewline"                             },
519 };
520
521 const char* EditorClientImpl::interpretKeyEvent(const KeyboardEvent* evt)
522 {
523     const PlatformKeyboardEvent* keyEvent = evt->keyEvent();
524     if (!keyEvent)
525         return "";
526
527     static HashMap<int, const char*>* keyDownCommandsMap = 0;
528     static HashMap<int, const char*>* keyPressCommandsMap = 0;
529
530     if (!keyDownCommandsMap) {
531         keyDownCommandsMap = new HashMap<int, const char*>;
532         keyPressCommandsMap = new HashMap<int, const char*>;
533
534         for (unsigned i = 0; i < arraysize(keyDownEntries); i++) {
535             keyDownCommandsMap->set(keyDownEntries[i].modifiers << 16 | keyDownEntries[i].virtualKey,
536                                     keyDownEntries[i].name);
537         }
538
539         for (unsigned i = 0; i < arraysize(keyPressEntries); i++) {
540             keyPressCommandsMap->set(keyPressEntries[i].modifiers << 16 | keyPressEntries[i].charCode,
541                                      keyPressEntries[i].name);
542         }
543     }
544
545     unsigned modifiers = 0;
546     if (keyEvent->shiftKey())
547         modifiers |= ShiftKey;
548     if (keyEvent->altKey())
549         modifiers |= AltKey;
550     if (keyEvent->ctrlKey())
551         modifiers |= CtrlKey;
552     if (keyEvent->metaKey())
553         modifiers |= MetaKey;
554
555     if (keyEvent->type() == PlatformKeyboardEvent::RawKeyDown) {
556         int mapKey = modifiers << 16 | evt->keyCode();
557         return mapKey ? keyDownCommandsMap->get(mapKey) : 0;
558     }
559
560     int mapKey = modifiers << 16 | evt->charCode();
561     return mapKey ? keyPressCommandsMap->get(mapKey) : 0;
562 }
563
564 bool EditorClientImpl::handleEditingKeyboardEvent(KeyboardEvent* evt)
565 {
566     const PlatformKeyboardEvent* keyEvent = evt->keyEvent();
567     // do not treat this as text input if it's a system key event
568     if (!keyEvent || keyEvent->isSystemKey())
569         return false;
570
571     Frame* frame = evt->target()->toNode()->document()->frame();
572     if (!frame)
573         return false;
574
575     String commandName = interpretKeyEvent(evt);
576     Editor::Command command = frame->editor()->command(commandName);
577
578     if (keyEvent->type() == PlatformKeyboardEvent::RawKeyDown) {
579         // WebKit doesn't have enough information about mode to decide how
580         // commands that just insert text if executed via Editor should be treated,
581         // so we leave it upon WebCore to either handle them immediately
582         // (e.g. Tab that changes focus) or let a keypress event be generated
583         // (e.g. Tab that inserts a Tab character, or Enter).
584         if (command.isTextInsertion() || commandName.isEmpty())
585             return false;
586         if (command.execute(evt)) {
587             if (m_webView->client())
588                 m_webView->client()->didExecuteCommand(WebString(commandName));
589             return true;
590         }
591         return false;
592     }
593
594     if (command.execute(evt)) {
595         if (m_webView->client())
596             m_webView->client()->didExecuteCommand(WebString(commandName));
597         return true;
598     }
599
600     // Here we need to filter key events.
601     // On Gtk/Linux, it emits key events with ASCII text and ctrl on for ctrl-<x>.
602     // In Webkit, EditorClient::handleKeyboardEvent in
603     // WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp drop such events.
604     // On Mac, it emits key events with ASCII text and meta on for Command-<x>.
605     // These key events should not emit text insert event.
606     // Alt key would be used to insert alternative character, so we should let
607     // through. Also note that Ctrl-Alt combination equals to AltGr key which is
608     // also used to insert alternative character.
609     // http://code.google.com/p/chromium/issues/detail?id=10846
610     // Windows sets both alt and meta are on when "Alt" key pressed.
611     // http://code.google.com/p/chromium/issues/detail?id=2215
612     // Also, we should not rely on an assumption that keyboards don't
613     // send ASCII characters when pressing a control key on Windows,
614     // which may be configured to do it so by user.
615     // See also http://en.wikipedia.org/wiki/Keyboard_Layout
616     // FIXME(ukai): investigate more detail for various keyboard layout.
617     if (evt->keyEvent()->text().length() == 1) {
618         UChar ch = evt->keyEvent()->text()[0U];
619
620         // Don't insert null or control characters as they can result in
621         // unexpected behaviour
622         if (ch < ' ')
623             return false;
624 #if !OS(WINDOWS)
625         // Don't insert ASCII character if ctrl w/o alt or meta is on.
626         // On Mac, we should ignore events when meta is on (Command-<x>).
627         if (ch < 0x80) {
628             if (evt->keyEvent()->ctrlKey() && !evt->keyEvent()->altKey())
629                 return false;
630 #if OS(DARWIN)
631             if (evt->keyEvent()->metaKey())
632             return false;
633 #endif
634         }
635 #endif
636     }
637
638     if (!frame->editor()->canEdit())
639         return false;
640
641     return frame->editor()->insertText(evt->keyEvent()->text(), evt);
642 }
643
644 void EditorClientImpl::handleKeyboardEvent(KeyboardEvent* evt)
645 {
646     if (evt->keyCode() == VKEY_DOWN
647         || evt->keyCode() == VKEY_UP) {
648         ASSERT(evt->target()->toNode());
649         showFormAutofillForNode(evt->target()->toNode());
650     }
651
652     // Give the embedder a chance to handle the keyboard event.
653     if ((m_webView->client()
654          && m_webView->client()->handleCurrentKeyboardEvent())
655         || handleEditingKeyboardEvent(evt))
656         evt->setDefaultHandled();
657 }
658
659 void EditorClientImpl::handleInputMethodKeydown(KeyboardEvent* keyEvent)
660 {
661     // We handle IME within chrome.
662 }
663
664 void EditorClientImpl::textFieldDidBeginEditing(Element* element)
665 {
666     HTMLInputElement* inputElement = toHTMLInputElement(element);
667     if (m_webView->autofillClient() && inputElement)
668         m_webView->autofillClient()->textFieldDidBeginEditing(WebInputElement(inputElement));
669 }
670
671 void EditorClientImpl::textFieldDidEndEditing(Element* element)
672 {
673     HTMLInputElement* inputElement = toHTMLInputElement(element);
674     if (m_webView->autofillClient() && inputElement)
675         m_webView->autofillClient()->textFieldDidEndEditing(WebInputElement(inputElement));
676
677     // Notification that focus was lost.  Be careful with this, it's also sent
678     // when the page is being closed.
679
680     // Cancel any pending DoAutofill call.
681     m_autofillArgs.clear();
682     m_autofillTimer.stop();
683
684     // Hide any showing popup.
685     m_webView->hideAutofillPopup();
686
687     if (!m_webView->client())
688         return; // The page is getting closed, don't fill the password.
689
690     // Notify any password-listener of the focus change.
691     if (!inputElement)
692         return;
693
694     WebFrameImpl* webframe = WebFrameImpl::fromFrame(inputElement->document()->frame());
695     if (!webframe)
696         return;
697
698     WebPasswordAutocompleteListener* listener = webframe->getPasswordListener(inputElement);
699     if (!listener)
700         return;
701
702     listener->didBlurInputElement(inputElement->value());
703 }
704
705 void EditorClientImpl::textDidChangeInTextField(Element* element)
706 {
707     ASSERT(element->hasLocalName(HTMLNames::inputTag));
708     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(element);
709     if (m_webView->autofillClient())
710         m_webView->autofillClient()->textFieldDidChange(WebInputElement(inputElement));
711
712     // Note that we only show the autofill popup in this case if the caret is at
713     // the end.  This matches FireFox and Safari but not IE.
714     autofill(inputElement, false, false, true);
715 }
716
717 bool EditorClientImpl::showFormAutofillForNode(Node* node)
718 {
719     HTMLInputElement* inputElement = toHTMLInputElement(node);
720     if (inputElement)
721         return autofill(inputElement, true, true, false);
722     return false;
723 }
724
725 bool EditorClientImpl::autofill(HTMLInputElement* inputElement,
726                                 bool autofillFormOnly,
727                                 bool autofillOnEmptyValue,
728                                 bool requireCaretAtEnd)
729 {
730     // Cancel any pending DoAutofill call.
731     m_autofillArgs.clear();
732     m_autofillTimer.stop();
733
734     // Let's try to trigger autofill for that field, if applicable.
735     if (!inputElement->isEnabledFormControl() || !inputElement->isTextField()
736         || inputElement->isPasswordField() || !inputElement->shouldAutocomplete()
737         || inputElement->isReadOnlyFormControl())
738         return false;
739
740     WebString name = WebInputElement(inputElement).nameForAutofill();
741     if (name.isEmpty()) // If the field has no name, then we won't have values.
742         return false;
743
744     // Don't attempt to autofill with values that are too large.
745     if (inputElement->value().length() > maximumTextSizeForAutofill)
746         return false;
747
748     m_autofillArgs = adoptPtr(new AutofillArgs);
749     m_autofillArgs->inputElement = inputElement;
750     m_autofillArgs->autofillFormOnly = autofillFormOnly;
751     m_autofillArgs->autofillOnEmptyValue = autofillOnEmptyValue;
752     m_autofillArgs->requireCaretAtEnd = requireCaretAtEnd;
753     m_autofillArgs->backspaceOrDeletePressed = m_backspaceOrDeletePressed;
754
755     if (!requireCaretAtEnd)
756         doAutofill(0);
757     else {
758         // We post a task for doing the autofill as the caret position is not set
759         // properly at this point (http://bugs.webkit.org/show_bug.cgi?id=16976)
760         // and we need it to determine whether or not to trigger autofill.
761         m_autofillTimer.startOneShot(0.0);
762     }
763     return true;
764 }
765
766 void EditorClientImpl::doAutofill(Timer<EditorClientImpl>* timer)
767 {
768     OwnPtr<AutofillArgs> args(m_autofillArgs.release());
769     HTMLInputElement* inputElement = args->inputElement.get();
770
771     const String& value = inputElement->value();
772
773     // Enforce autofill_on_empty_value and caret_at_end.
774
775     bool isCaretAtEnd = true;
776     if (args->requireCaretAtEnd)
777         isCaretAtEnd = inputElement->selectionStart() == inputElement->selectionEnd()
778                        && inputElement->selectionEnd() == static_cast<int>(value.length());
779
780     if ((!args->autofillOnEmptyValue && value.isEmpty()) || !isCaretAtEnd) {
781         m_webView->hideAutofillPopup();
782         return;
783     }
784
785     // First let's see if there is a password listener for that element.
786     // We won't trigger form autofill in that case, as having both behavior on
787     // a node would be confusing.
788     WebFrameImpl* webframe = WebFrameImpl::fromFrame(inputElement->document()->frame());
789     if (!webframe)
790         return;
791     WebPasswordAutocompleteListener* listener = webframe->getPasswordListener(inputElement);
792     if (listener) {
793         if (args->autofillFormOnly)
794             return;
795
796         listener->performInlineAutocomplete(value,
797                                             args->backspaceOrDeletePressed,
798                                             true);
799         return;
800     }
801 }
802
803 void EditorClientImpl::cancelPendingAutofill()
804 {
805     m_autofillArgs.clear();
806     m_autofillTimer.stop();
807 }
808
809 bool EditorClientImpl::doTextFieldCommandFromEvent(Element* element,
810                                                    KeyboardEvent* event)
811 {
812     HTMLInputElement* inputElement = toHTMLInputElement(element);
813     if (m_webView->autofillClient() && inputElement) {
814         m_webView->autofillClient()->textFieldDidReceiveKeyDown(WebInputElement(inputElement),
815                                                                 WebKeyboardEventBuilder(*event));
816     }
817
818     // Remember if backspace was pressed for the autofill.  It is not clear how to
819     // find if backspace was pressed from textFieldDidBeginEditing and
820     // textDidChangeInTextField as when these methods are called the value of the
821     // input element already contains the type character.
822     m_backspaceOrDeletePressed = event->keyCode() == VKEY_BACK || event->keyCode() == VKEY_DELETE;
823
824     // The Mac code appears to use this method as a hook to implement special
825     // keyboard commands specific to Safari's auto-fill implementation.  We
826     // just return false to allow the default action.
827     return false;
828 }
829
830 void EditorClientImpl::textWillBeDeletedInTextField(Element*)
831 {
832 }
833
834 void EditorClientImpl::textDidChangeInTextArea(Element*)
835 {
836 }
837
838 void EditorClientImpl::ignoreWordInSpellDocument(const String&)
839 {
840     notImplemented();
841 }
842
843 void EditorClientImpl::learnWord(const String&)
844 {
845     notImplemented();
846 }
847
848 void EditorClientImpl::checkSpellingOfString(const UChar* text, int length,
849                                              int* misspellingLocation,
850                                              int* misspellingLength)
851 {
852     // SpellCheckWord will write (0, 0) into the output vars, which is what our
853     // caller expects if the word is spelled correctly.
854     int spellLocation = -1;
855     int spellLength = 0;
856
857     // Check to see if the provided text is spelled correctly.
858     if (isContinuousSpellCheckingEnabled() && m_webView->spellCheckClient())
859         m_webView->spellCheckClient()->spellCheck(WebString(text, length), spellLocation, spellLength, 0);
860     else {
861         spellLocation = 0;
862         spellLength = 0;
863     }
864
865     // Note: the Mac code checks if the pointers are null before writing to them,
866     // so we do too.
867     if (misspellingLocation)
868         *misspellingLocation = spellLocation;
869     if (misspellingLength)
870         *misspellingLength = spellLength;
871 }
872
873 void EditorClientImpl::requestCheckingOfString(SpellChecker* sender, int identifier, TextCheckingTypeMask, const String& text)
874 {
875     if (m_webView->spellCheckClient())
876         m_webView->spellCheckClient()->requestCheckingOfText(text, new WebTextCheckingCompletionImpl(identifier, sender));
877 }
878
879 String EditorClientImpl::getAutoCorrectSuggestionForMisspelledWord(const String& misspelledWord)
880 {
881     if (!(isContinuousSpellCheckingEnabled() && m_webView->client()))
882         return String();
883
884     // Do not autocorrect words with capital letters in it except the
885     // first letter. This will remove cases changing "IMB" to "IBM".
886     for (size_t i = 1; i < misspelledWord.length(); i++) {
887         if (u_isupper(static_cast<UChar32>(misspelledWord[i])))
888             return String();
889     }
890
891     if (m_webView->spellCheckClient())
892         return m_webView->spellCheckClient()->autoCorrectWord(WebString(misspelledWord));
893     return String();
894 }
895
896 void EditorClientImpl::checkGrammarOfString(const UChar*, int length,
897                                             WTF::Vector<GrammarDetail>&,
898                                             int* badGrammarLocation,
899                                             int* badGrammarLength)
900 {
901     notImplemented();
902     if (badGrammarLocation)
903         *badGrammarLocation = 0;
904     if (badGrammarLength)
905         *badGrammarLength = 0;
906 }
907
908 void EditorClientImpl::updateSpellingUIWithGrammarString(const String&,
909                                                          const GrammarDetail& detail)
910 {
911     notImplemented();
912 }
913
914 void EditorClientImpl::updateSpellingUIWithMisspelledWord(const String& misspelledWord)
915 {
916     if (m_webView->spellCheckClient())
917         m_webView->spellCheckClient()->updateSpellingUIWithMisspelledWord(WebString(misspelledWord));
918 }
919
920 void EditorClientImpl::showSpellingUI(bool show)
921 {
922     if (m_webView->spellCheckClient())
923         m_webView->spellCheckClient()->showSpellingUI(show);
924 }
925
926 bool EditorClientImpl::spellingUIIsShowing()
927 {
928     if (m_webView->spellCheckClient())
929         return m_webView->spellCheckClient()->isShowingSpellingUI();
930     return false;
931 }
932
933 void EditorClientImpl::getGuessesForWord(const String& word,
934                                          const String& context,
935                                          WTF::Vector<String>& guesses)
936 {
937     notImplemented();
938 }
939
940 void EditorClientImpl::willSetInputMethodState()
941 {
942     if (m_webView->client())
943         m_webView->client()->resetInputMethod();
944 }
945
946 void EditorClientImpl::setInputMethodState(bool)
947 {
948 }
949
950 } // namesace WebKit