path: root/webkit/glue/editor_client_impl.cc

// Copyright 2008, Google 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:
//
//    * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//    * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//    * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// The Mac interface forwards most of these commands to the application layer,
// and I'm not really sure what to do about most of them.

#include "config.h"
#pragma warning(push, 0)
#include "Document.h"
#include "EditCommand.h"
#include "Editor.h"
#include "EventHandler.h"
#include "EventNames.h"
#include "HTMLInputElement.h"
#include "Frame.h"
#include "KeyboardEvent.h"
#include "PlatformKeyboardEvent.h"
#include "PlatformString.h"
#pragma warning(pop)

#undef LOG

#include "base/string_util.h"
#include "webkit/glue/editor_client_impl.h"
#include "webkit/glue/glue_util.h"
#include "webkit/glue/webkit_glue.h"
#include "webkit/glue/webview.h"
#include "webkit/glue/webview_impl.h"

// The notImplemented() from NotImplemented.h is now being dragged in via
// webview_impl.h.  We want the one from LogWin.h instead.
#undef notImplemented
#include "LogWin.h"

// Arbitrary depth limit for the undo stack, to keep it from using
// unbounded memory.  This is the maximum number of distinct undoable
// actions -- unbroken stretches of typed characters are coalesced
// into a single action.
static const int kMaximumUndoStackDepth = 1000;

namespace {

// Record an editor command from the keyDownEntries[] below.  We ignore the
// Move* and Insert* commands because they're not that interesting.
void MaybeRecordCommand(WebViewDelegate* d, const char* command_name) {
  if (!d)
    return;

  const char* move_prefix = "Move";
  const char* insert_prefix = "Insert";
  const char* delete_prefix = "Delete";
  // Ignore all the Move*, Insert*, and Delete* commands.
  if (0 == strncmp(command_name, move_prefix, sizeof(move_prefix)) ||
      0 == strncmp(command_name, insert_prefix, sizeof(insert_prefix)) ||
      0 == strncmp(command_name, delete_prefix, sizeof(delete_prefix))) {
    return;
  }
  d->UserMetricsRecordComputedAction(UTF8ToWide(command_name));
}

}

EditorClientImpl::EditorClientImpl(WebView* web_view)
    : web_view_(static_cast<WebViewImpl*>(web_view)),
      use_editor_delegate_(false),
      in_redo_(false),
      preserve_(false),
      pending_inline_autocompleted_element_(NULL) {
}

EditorClientImpl::~EditorClientImpl() {
}

void EditorClientImpl::pageDestroyed() {
  // Called by the Page (which owns the editor client) when the page is going
  // away. This should cause us to delete ourselves, which is stupid. The page
  // should just delete us when it's going away. Oh well.
  delete this;
}

bool EditorClientImpl::shouldShowDeleteInterface(WebCore::HTMLElement* elem) {
  // Normally, we don't care to show WebCore's deletion UI, so we only enable
  // it if in testing mode and the test specifically requests it by using this
  // magic class name.
  return webkit_glue::IsLayoutTestMode() &&
         elem->className() == "needsDeletionUI";
}

bool EditorClientImpl::smartInsertDeleteEnabled() {
  if (use_editor_delegate_) {
    WebViewDelegate* d = web_view_->delegate();
    if (d)
      return d->SmartInsertDeleteEnabled();
  }
  return true;
}

bool EditorClientImpl::isContinuousSpellCheckingEnabled() {
  // Spell check everything if possible.
  // FIXME(brettw) This should be modified to do reasonable defaults depending
  // on input type, and probably also allow the user to turn spellchecking on
  // for individual fields.
  return true;
}

void EditorClientImpl::toggleContinuousSpellChecking() {
  notImplemented();
}

bool EditorClientImpl::isGrammarCheckingEnabled() {
  notImplemented();
  return false;
}

void EditorClientImpl::toggleGrammarChecking() {
  notImplemented();
}

int EditorClientImpl::spellCheckerDocumentTag() {
  notImplemented();
  return 0;
}

bool EditorClientImpl::isEditable() {
  notImplemented();
  return false;
}

bool EditorClientImpl::shouldBeginEditing(WebCore::Range* range) {
  if (use_editor_delegate_) {
    WebViewDelegate* d = web_view_->delegate();
    if (d)
      return d->ShouldBeginEditing(web_view_, Describe(range));
  }
  return true;
}

bool EditorClientImpl::shouldEndEditing(WebCore::Range* range) {
  if (use_editor_delegate_) {
    WebViewDelegate* d = web_view_->delegate();
    if (d)
      return d->ShouldEndEditing(web_view_, Describe(range));
  }
  return true;
}

bool EditorClientImpl::shouldInsertNode(WebCore::Node* node,
                                        WebCore::Range* range,
                                        WebCore::EditorInsertAction action) {
  if (use_editor_delegate_) {
    WebViewDelegate* d = web_view_->delegate();
    if (d) {
      return d->ShouldInsertNode(web_view_,
                                 Describe(node),
                                 Describe(range),
                                 Describe(action));
    }
  }
  return true;
}

bool EditorClientImpl::shouldInsertText(WebCore::String text,
                                        WebCore::Range* range,
                                        WebCore::EditorInsertAction action) {
  if (use_editor_delegate_) {
    WebViewDelegate* d = web_view_->delegate();
    if (d) {
      std::wstring wstr = webkit_glue::StringToStdWString(text);
      return d->ShouldInsertText(web_view_, 
                                 wstr, 
                                 Describe(range), 
                                 Describe(action));
    }
  }
  return true;
}


bool EditorClientImpl::shouldDeleteRange(WebCore::Range* range) {
  if (use_editor_delegate_) {
    WebViewDelegate* d = web_view_->delegate();
    if (d)
      return d->ShouldDeleteRange(web_view_, Describe(range));
  }
  return true;
}

void EditorClientImpl::PreserveSelection() {
  preserve_ = true;
}

bool EditorClientImpl::shouldChangeSelectedRange(WebCore::Range* fromRange, 
                                                 WebCore::Range* toRange, 
                                                 WebCore::EAffinity affinity, 
                                                 bool stillSelecting) {
  if (use_editor_delegate_) {
    WebViewDelegate* d = web_view_->delegate();
    if (d) {
      return d->ShouldChangeSelectedRange(web_view_, 
                                          Describe(fromRange), 
                                          Describe(toRange), 
                                          Describe(affinity), 
                                          stillSelecting);
    }
  }
  // Have we been told to preserve the selection? 
  // (See comments for PreserveSelection in header).
  if (preserve_) {
    preserve_ = false;
    return false;
  }
  return true;
}
                                                
bool EditorClientImpl::shouldApplyStyle(WebCore::CSSStyleDeclaration* style,
                                        WebCore::Range* range) {
  if (use_editor_delegate_) {
    WebViewDelegate* d = web_view_->delegate();
    if (d)
      return d->ShouldApplyStyle(web_view_, Describe(style), Describe(range));
  }
  return true;
}

bool EditorClientImpl::shouldMoveRangeAfterDelete(
    WebCore::Range* /*range*/,
    WebCore::Range* /*rangeToBeReplaced*/) {
  notImplemented();
  return true;
}

void EditorClientImpl::didBeginEditing() {
  if (use_editor_delegate_) {
    WebViewDelegate* d = web_view_->delegate();
    if (d)
      d->DidBeginEditing();
  }
}

void EditorClientImpl::respondToChangedSelection() {
  if (use_editor_delegate_) {
    WebViewDelegate* d = web_view_->delegate();
    if (d)
      d->DidChangeSelection();
  }
}

void EditorClientImpl::respondToChangedContents() {
  // Ugly Hack. (See also webkit bug #16976).
  // Something is wrong with webcore's focusController in that when selection
  // is set to a region within a text element when handling an input event, if
  // you don't re-focus the node then it only _APPEARS_ to have successfully
  // changed the selection (the UI "looks" right) but in reality there is no
  // selection of text. And to make matters worse, you can't just re-focus it,
  // you have to re-focus it in code executed after the entire event listener 
  // loop has finished; and hence here we are. Oh, and to make matters worse, 
  // this sequence of events _doesn't_ happen when you debug through the code 
  // -- in that case it works perfectly fine -- because swapping to the debugger 
  // causes the refocusing we artificially reproduce here.
  // TODO (timsteele): Clean this up once root webkit problem is identified and
  // the bug is patched. 
  if (pending_inline_autocompleted_element_) {
    pending_inline_autocompleted_element_->blur();
    pending_inline_autocompleted_element_->focus();
    pending_inline_autocompleted_element_ = NULL; 
  }

  if (use_editor_delegate_) {
    WebViewDelegate* d = web_view_->delegate();
    if (d)
      d->DidChangeContents();
  }
}

void EditorClientImpl::didEndEditing() {
  if (use_editor_delegate_) {
    WebViewDelegate* d = web_view_->delegate();
    if (d)
      d->DidEndEditing();
  }
}

void EditorClientImpl::didWriteSelectionToPasteboard() {
  notImplemented();
}

void EditorClientImpl::didSetSelectionTypesForPasteboard() {
  notImplemented();
}

void EditorClientImpl::registerCommandForUndo(
    PassRefPtr<WebCore::EditCommand> command) {
  if (undo_stack_.size() == kMaximumUndoStackDepth)
    undo_stack_.pop_front();  // drop oldest item off the far end
  if (!in_redo_)
    redo_stack_.clear();
  undo_stack_.push_back(command);
}

void EditorClientImpl::registerCommandForRedo(
    PassRefPtr<WebCore::EditCommand> command) {
  redo_stack_.push_back(command);
}

void EditorClientImpl::clearUndoRedoOperations() {
  undo_stack_.clear();
  redo_stack_.clear();
}

bool EditorClientImpl::canUndo() const {
  return !undo_stack_.empty();
}

bool EditorClientImpl::canRedo() const {
  return !redo_stack_.empty();
}

void EditorClientImpl::undo() {
  if (canUndo()) {
    RefPtr<WebCore::EditCommand> command(undo_stack_.back());
    undo_stack_.pop_back();
    command->unapply();
    // unapply will call us back to push this command onto the redo stack.
  }
}

void EditorClientImpl::redo() {
  if (canRedo()) {
    RefPtr<WebCore::EditCommand> command(redo_stack_.back());
    redo_stack_.pop_back();

    ASSERT(!in_redo_);
    in_redo_ = true;
    command->reapply();
    // reapply will call us back to push this command onto the undo stack.
    in_redo_ = false;
  }
}

// Get the distance we should go (in pixels) when doing a pageup/pagedown.
static int GetVerticalPageDistance(WebCore::KeyboardEvent* event) {
  if (event->target()) {
    WebCore::Node* node = event->target()->toNode();
    if (node && node->renderer())
      return node->renderer()->contentHeight();
  }

  return 0;
}

// The below code was adapted from the WebKit file webview.cpp
// provided by Apple, Inc, and is subject to the following copyright
// notice and disclaimer.

/*
 * Copyright (C) 2006, 2007 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
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

static const unsigned CtrlKey = 1 << 0;
static const unsigned AltKey = 1 << 1;
static const unsigned ShiftKey = 1 << 2;

// Keys with special meaning. These will be delegated to the editor using
// the execCommand() method
struct KeyDownEntry {
  unsigned virtualKey;
  unsigned modifiers;
  const char* name;
};

struct KeyPressEntry {
  unsigned charCode;
  unsigned modifiers;
  const char* name;
};

static const KeyDownEntry keyDownEntries[] = {
  { VK_LEFT,   0,                  "MoveLeft"                                    },
  { VK_LEFT,   ShiftKey,           "MoveLeftAndModifySelection"                  },
  { VK_LEFT,   CtrlKey,            "MoveWordLeft"                                },
  { VK_LEFT,   CtrlKey | ShiftKey, "MoveWordLeftAndModifySelection"              },
  { VK_RIGHT,  0,                  "MoveRight"                                   },
  { VK_RIGHT,  ShiftKey,           "MoveRightAndModifySelection"                 },
  { VK_RIGHT,  CtrlKey,            "MoveWordRight"                               },
  { VK_RIGHT,  CtrlKey | ShiftKey, "MoveWordRightAndModifySelection"             },
  { VK_UP,     0,                  "MoveUp"                                      },
  { VK_UP,     ShiftKey,           "MoveUpAndModifySelection"                    },
  { VK_PRIOR,  ShiftKey,           "MovePageUpAndModifySelection"                },
  { VK_DOWN,   0,                  "MoveDown"                                    },
  { VK_DOWN,   ShiftKey,           "MoveDownAndModifySelection"                  },
  { VK_NEXT,   ShiftKey,           "MovePageDownAndModifySelection"              },
  { VK_PRIOR,  0,                  "MovePageUp"                                  },
  { VK_NEXT,   0,                  "MovePageDown"                                },
  { VK_HOME,   0,                  "MoveToBeginningOfLine"                       },
  { VK_HOME,   ShiftKey,           "MoveToBeginningOfLineAndModifySelection"     },
  { VK_HOME,   CtrlKey,            "MoveToBeginningOfDocument"                   },
  { VK_HOME,   CtrlKey | ShiftKey, "MoveToBeginningOfDocumentAndModifySelection" },
	
  { VK_END,    0,                  "MoveToEndOfLine"                             },
  { VK_END,    ShiftKey,           "MoveToEndOfLineAndModifySelection"           },
  { VK_END,    CtrlKey,            "MoveToEndOfDocument"                         },
  { VK_END,    CtrlKey | ShiftKey, "MoveToEndOfDocumentAndModifySelection"       },
	
  { VK_BACK,   0,                  "DeleteBackward"                              },
  { VK_BACK,   ShiftKey,           "DeleteBackward"                              },
  { VK_DELETE, 0,                  "DeleteForward"                               },
  { VK_BACK,   CtrlKey,            "DeleteWordBackward"                          },
  { VK_DELETE, CtrlKey,            "DeleteWordForward"                           },
	   
  { 'B',       CtrlKey,            "ToggleBold"                                  },
  { 'I',       CtrlKey,            "ToggleItalic"                                },
  { 'U',       CtrlKey,            "ToggleUnderline"                             },

  { VK_ESCAPE, 0,                  "Cancel"                                      },
  { VK_OEM_PERIOD, CtrlKey,        "Cancel"                                      },
  { VK_TAB,    0,                  "InsertTab"                                   },
  { VK_TAB,    ShiftKey,           "InsertBacktab"                               },
  { VK_RETURN, 0,                  "InsertNewline"                               },
  { VK_RETURN, CtrlKey,            "InsertNewline"                               },
  { VK_RETURN, AltKey,             "InsertNewline"                               },
  { VK_RETURN, AltKey | ShiftKey,  "InsertNewline"                               },
  { VK_RETURN, ShiftKey,           "InsertLineBreak"                             },	

  { 'C',       CtrlKey,            "Copy"                                        },
  { VK_INSERT, CtrlKey,            "Copy"                                        },	
  { 'V',       CtrlKey,            "Paste"                                       },
  { VK_INSERT, ShiftKey,           "Paste"                                       },	
  { 'V',       CtrlKey | ShiftKey, "PasteAndMatchStyle"                          },
  { 'X',       CtrlKey,            "Cut"                                         },
  { VK_DELETE, ShiftKey,           "Cut"                                         },	
  { 'A',       CtrlKey,            "SelectAll"                                   },
  { 'Z',       CtrlKey,            "Undo"                                        },
  { 'Z',       CtrlKey | ShiftKey, "Redo"                                        },
  { 'Y',       CtrlKey,            "Redo"                                        },
};

static const KeyPressEntry keyPressEntries[] = {
  { '\t',   0,                  "InsertTab"                                   },
  { '\t',   ShiftKey,           "InsertBacktab"                               },
  { '\r',   0,                  "InsertNewline"                               },
  { '\r',   CtrlKey,            "InsertNewline"                               },
  { '\r',   ShiftKey,           "InsertLineBreak"                             },
  { '\r',   AltKey,             "InsertNewline"                               },
  { '\r',   AltKey | ShiftKey,  "InsertNewline"                               },
};

const char* EditorClientImpl::interpretKeyEvent(
  const WebCore::KeyboardEvent* evt) {
  const WebCore::PlatformKeyboardEvent* keyEvent = evt->keyEvent();
  if (!keyEvent)
    return "";

  static HashMap<int, const char*>* keyDownCommandsMap = 0;
  static HashMap<int, const char*>* keyPressCommandsMap = 0;

  if (!keyDownCommandsMap) {
    keyDownCommandsMap = new HashMap<int, const char*>;
    keyPressCommandsMap = new HashMap<int, const char*>;

    for (unsigned i = 0; i < _countof(keyDownEntries); i++) {
      keyDownCommandsMap->set(
        keyDownEntries[i].modifiers << 16 | keyDownEntries[i].virtualKey,
        keyDownEntries[i].name);
    }

    for (unsigned i = 0; i < _countof(keyPressEntries); i++) {
      keyPressCommandsMap->set(
        keyPressEntries[i].modifiers << 16 | keyPressEntries[i].charCode, 
        keyPressEntries[i].name);
    }
  }

  unsigned modifiers = 0;
  if (keyEvent->shiftKey())
    modifiers |= ShiftKey;
  if (keyEvent->altKey())
    modifiers |= AltKey;
  if (keyEvent->ctrlKey())
    modifiers |= CtrlKey;

  if (evt->type() == WebCore::EventNames::keydownEvent) {
    int mapKey = modifiers << 16 | evt->keyCode();
      return mapKey ? keyDownCommandsMap->get(mapKey) : 0;
  }

  int mapKey = modifiers << 16 | evt->charCode();
  return mapKey ? keyPressCommandsMap->get(mapKey) : 0;
}

bool EditorClientImpl::handleEditingKeyboardEvent(
  WebCore::KeyboardEvent* evt) {
  const WebCore::PlatformKeyboardEvent* keyEvent = evt->keyEvent();
  // do not treat this as text input if it's a system key event
  if (!keyEvent || keyEvent->isSystemKey())
      return false;

  WebCore::Frame* frame = evt->target()->toNode()->document()->frame();
  if (!frame)
    return false;

  const char* command_name = interpretKeyEvent(evt);
  WebCore::Editor::Command command = frame->editor()->command(command_name);

  if (keyEvent->type() == WebCore::PlatformKeyboardEvent::RawKeyDown) {
    // WebKit doesn't have enough information about mode to decide how
    // commands that just insert text if executed via Editor should be treated,
    // so we leave it upon WebCore to either handle them immediately
    // (e.g. Tab that changes focus) or let a keypress event be generated
    // (e.g. Tab that inserts a Tab character, or Enter).
    if (command.isTextInsertion() || !command_name)
      return false;
    if (command.execute(evt)) {
      WebViewDelegate* d = web_view_->delegate();
      MaybeRecordCommand(d, command_name);
      return true;
    }
    return false;
  }

  if (command.execute(evt)) {
    WebViewDelegate* d = web_view_->delegate();
    MaybeRecordCommand(d, command_name);
    return true;
  }

  if (evt->keyEvent()->text().length() == 1) {
    UChar ch = evt->keyEvent()->text()[0];

    // Don't insert null or control characters as they can result in
    // unexpected behaviour
    if (ch < ' ')
      return false;
  }

  return frame->editor()->insertText(evt->keyEvent()->text(), evt);
}

//
// End of code block subject to Apple, Inc. copyright
//

void EditorClientImpl::handleKeyboardEvent(WebCore::KeyboardEvent* evt) {
  if (handleEditingKeyboardEvent(evt))
    evt->setDefaultHandled();
}

void EditorClientImpl::handleInputMethodKeydown(WebCore::KeyboardEvent* keyEvent) {
  notImplemented();
}

void EditorClientImpl::textFieldDidBeginEditing(WebCore::Element*) {
  notImplemented();
}

void EditorClientImpl::textFieldDidEndEditing(WebCore::Element*) {
  // Notification that focus was lost.
  // Be careful with this, it's also sent when the page is being closed.
  notImplemented();
}

void EditorClientImpl::textDidChangeInTextField(WebCore::Element* element) {
  // Track the element so we can blur/focus it in respondToChangedContents
  // so that the selected range is properly set. (See respondToChangedContents).
  if (static_cast<WebCore::HTMLInputElement*>(element)->autofilled())
    pending_inline_autocompleted_element_ = element;
}

bool EditorClientImpl::doTextFieldCommandFromEvent(WebCore::Element*,
                                                   WebCore::KeyboardEvent*) {
  // The Mac code appears to use this method as a hook to implement special
  // keyboard commands specific to Safari's auto-fill implementation.  We
  // just return false to allow the default action.
  return false;
}

void EditorClientImpl::textWillBeDeletedInTextField(WebCore::Element*) {
  notImplemented();
}

void EditorClientImpl::textDidChangeInTextArea(WebCore::Element*) {
  notImplemented();
}

void EditorClientImpl::ignoreWordInSpellDocument(const WebCore::String&) {
  notImplemented();
}

void EditorClientImpl::learnWord(const WebCore::String&) {
  notImplemented();
}

void EditorClientImpl::checkSpellingOfString(const UChar* str, int length,
                                             int* misspellingLocation,
                                             int* misspellingLength) {
  // SpellCheckWord will write (0, 0) into the output vars, which is what our
  // caller expects if the word is spelled correctly.
  int spell_location = -1;
  int spell_length = 0;
  WebViewDelegate* d = web_view_->delegate();
  if (web_view_->FocusedFrameNeedsSpellchecking() && d) {
    std::wstring word(str, length);
    d->SpellCheck(word, spell_location, spell_length);
  } else {
    spell_location = 0;
    spell_length = 0;
  }

  // Note: the Mac code checks if the pointers are NULL before writing to them,
  // so we do too.
  if (misspellingLocation)
    *misspellingLocation = spell_location;
  if (misspellingLength)
    *misspellingLength = spell_length;
}

void EditorClientImpl::checkGrammarOfString(const UChar*, int length,
                                            WTF::Vector<WebCore::GrammarDetail>&,
                                            int* badGrammarLocation,
                                            int* badGrammarLength) {
  notImplemented();
  if (badGrammarLocation)
    *badGrammarLocation = 0;
  if (badGrammarLength)
    *badGrammarLength = 0;
}

void EditorClientImpl::updateSpellingUIWithGrammarString(const WebCore::String&,
                                                         const WebCore::GrammarDetail& detail) {
  notImplemented();
}

void EditorClientImpl::updateSpellingUIWithMisspelledWord(const WebCore::String&) {
  notImplemented();
}

void EditorClientImpl::showSpellingUI(bool show) {
  notImplemented();
}

bool EditorClientImpl::spellingUIIsShowing() {
  return false;
}

void EditorClientImpl::getGuessesForWord(const WebCore::String&,
                                         WTF::Vector<WebCore::String>& guesses) {
  notImplemented();
}

void EditorClientImpl::setInputMethodState(bool enabled) {
  WebViewDelegate* d = web_view_->delegate();
  if (d) {
    d->SetInputMethodState(enabled);
  }
}


std::wstring EditorClientImpl::DescribeOrError(int number, 
                                               WebCore::ExceptionCode ec) {
  if (ec)
    return L"ERROR";

  wchar_t buffer[128];
  _itow_s(number, buffer, arraysize(buffer), 10);
  return std::wstring(buffer);
}

std::wstring EditorClientImpl::DescribeOrError(WebCore::Node* node, 
                                               WebCore::ExceptionCode ec) {
  if (ec)
    return L"ERROR";

  return Describe(node);
}

// These Describe() functions match the output expected by the layout tests.
std::wstring EditorClientImpl::Describe(WebCore::Range* range) {
  if (range) {
    WebCore::ExceptionCode exception = 0;
    std::wstring str = L"range from ";
    int offset = range->startOffset(exception);
    str.append(DescribeOrError(offset, exception));
    str.append(L" of ");
    WebCore::Node* container = range->startContainer(exception);
    str.append(DescribeOrError(container, exception));
    str.append(L" to ");
    offset = range->endOffset(exception);
    str.append(DescribeOrError(offset, exception));
    str.append(L" of ");
    container = range->endContainer(exception);
    str.append(DescribeOrError(container, exception));
    return str;
  }
  return L"(null)";
}

// See comment for Describe(), above.
std::wstring EditorClientImpl::Describe(WebCore::Node* node) {
  if (node) {
    std::wstring str = webkit_glue::StringToStdWString(node->nodeName());
    WebCore::Node* parent = node->parentNode();
    if (parent) {
      str.append(L" > ");
      str.append(Describe(parent));
    }
    return str;
  }
  return L"(null)";
}

// See comment for Describe(), above.
std::wstring EditorClientImpl::Describe(WebCore::EditorInsertAction action) {
  switch (action) {
    case WebCore::EditorInsertActionTyped:
      return L"WebViewInsertActionTyped";
    case WebCore::EditorInsertActionPasted:
      return L"WebViewInsertActionPasted";
    case WebCore::EditorInsertActionDropped:
      return L"WebViewInsertActionDropped";
  }
  return L"(UNKNOWN ACTION)";
}

// See comment for Describe(), above.
std::wstring EditorClientImpl::Describe(WebCore::EAffinity affinity) {
  switch (affinity) {
    case WebCore::UPSTREAM:
      return L"NSSelectionAffinityUpstream";
    case WebCore::DOWNSTREAM:
      return L"NSSelectionAffinityDownstream";
  }
  return L"(UNKNOWN AFFINITY)";
}

std::wstring EditorClientImpl::Describe(WebCore::CSSStyleDeclaration* style) {
  // TODO(pamg): Implement me.  It's not clear what WebKit produces for this
  // (their [style description] method), and none of the layout tests provide
  // an example.  But because none of them use it, it's not yet important.
  return std::wstring();
}