Move many files that were suffixed Win.cpp to Chromium.cpp, and place them in...

webkit/glue/editor_client_impl.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // 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 size_t kMaximumUndoStackDepth = 1000;
 
 namespace {
 
 // Record an editor command from the keyDownEntries[] below.  We ignore the
 // Move* and Insert* commands because they're not that interesting.
@@ skipping 52 matching lines @@
 
 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();
+  NOTIMPLEMENTED();
 }
 
 bool EditorClientImpl::isGrammarCheckingEnabled() {
-  notImplemented();
   return false;
 }
 
 void EditorClientImpl::toggleGrammarChecking() {
-  notImplemented();
+  NOTIMPLEMENTED();
 }
 
 int EditorClientImpl::spellCheckerDocumentTag() {
-  notImplemented();
+  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;
@@ skipping 82 matching lines @@
     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();
+  NOTIMPLEMENTED();
   return true;
 }
 
 void EditorClientImpl::didBeginEditing() {
   if (use_editor_delegate_) {
     WebViewDelegate* d = web_view_->delegate();
     if (d)
       d->DidBeginEditing();
   }
 }
@@ skipping 35 matching lines @@
 
 void EditorClientImpl::didEndEditing() {
   if (use_editor_delegate_) {
     WebViewDelegate* d = web_view_->delegate();
     if (d)
       d->DidEndEditing();
   }
 }
 
 void EditorClientImpl::didWriteSelectionToPasteboard() {
-  notImplemented();
+  NOTIMPLEMENTED();
 }
 
 void EditorClientImpl::didSetSelectionTypesForPasteboard() {
-  notImplemented();
+  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);
 }
@@ skipping 255 matching lines @@
 //
 // 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();
+  NOTIMPLEMENTED();
 }
 
 void EditorClientImpl::textFieldDidBeginEditing(WebCore::Element*) {
-  notImplemented();
+  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();
+  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();
+  NOTIMPLEMENTED();
 }
 
 void EditorClientImpl::textDidChangeInTextArea(WebCore::Element*) {
-  notImplemented();
+  NOTIMPLEMENTED();
 }
 
 #if defined(OS_MACOSX)
 // TODO(pinkerton): implement these when we get to copy/paste
 NSData* EditorClientImpl::dataForArchivedSelection(WebCore::Frame*) {
-  notImplemented();
+  NOTIMPLEMENTED();
 }
 
 NSString* EditorClientImpl::userVisibleString(NSURL*) {
-  notImplemented();
+  NOTIMPLEMENTED();
 }
 
 #ifdef BUILDING_ON_TIGER
 NSArray* EditorClientImpl::pasteboardTypesForSelection(WebCore::Frame*) {
-  notImplemented();
+  NOTIMPLEMENTED();
 }
 #endif
 #endif
 
 void EditorClientImpl::ignoreWordInSpellDocument(const WebCore::String&) {
-  notImplemented();
+  NOTIMPLEMENTED();
 }
 
 void EditorClientImpl::learnWord(const WebCore::String&) {
-  notImplemented();
+  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();
@@ skipping 11 matching lines @@
   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();
+  NOTIMPLEMENTED();
   if (badGrammarLocation)
     *badGrammarLocation = 0;
   if (badGrammarLength)
     *badGrammarLength = 0;
 }
 
 void EditorClientImpl::updateSpellingUIWithGrammarString(const WebCore::String&,
                                                          const WebCore::GrammarDetail& detail) {
-  notImplemented();
+  NOTIMPLEMENTED();
 }
 
 void EditorClientImpl::updateSpellingUIWithMisspelledWord(const WebCore::String&) {
-  notImplemented();
+  NOTIMPLEMENTED();
 }
 
 void EditorClientImpl::showSpellingUI(bool show) {
-  notImplemented();
+  NOTIMPLEMENTED();
 }
 
 bool EditorClientImpl::spellingUIIsShowing() {
   return false;
 }
 
 void EditorClientImpl::getGuessesForWord(const WebCore::String&,
                                          WTF::Vector<WebCore::String>& guesses) {
-  notImplemented();
+  NOTIMPLEMENTED();
 }
 
 void EditorClientImpl::setInputMethodState(bool enabled) {
   WebViewDelegate* d = web_view_->delegate();
   if (d) {
     d->SetInputMethodState(enabled);
   }
 }
 
 
@@ skipping 72 matching lines @@
   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();
 }