Move autofill related WebView{Delegate} methods into the WebKit API....

webkit/glue/webview_impl.cc

 // Copyright (c) 2007-2009 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.
 
 #include "config.h"
 #include "build/build_config.h"
 
 #include "base/compiler_specific.h"
 MSVC_PUSH_WARNING_LEVEL(0);
 #include "AXObjectCache.h"
@@ skipping 51 matching lines @@
 #include "base/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "webkit/api/public/WebAccessibilityObject.h"
 #include "webkit/api/public/WebDragData.h"
 #include "webkit/api/public/WebInputEvent.h"
 #include "webkit/api/public/WebMediaPlayerAction.h"
 #include "webkit/api/public/WebPoint.h"
 #include "webkit/api/public/WebRect.h"
 #include "webkit/api/public/WebString.h"
+#include "webkit/api/public/WebVector.h"
 #include "webkit/api/src/WebInputEventConversion.h"
 #include "webkit/api/src/WebSettingsImpl.h"
 #include "webkit/glue/dom_operations.h"
 #include "webkit/glue/glue_serialize.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/image_resource_fetcher.h"
 #include "webkit/glue/searchable_form_data.h"
 #include "webkit/glue/webdevtoolsagent_impl.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webpopupmenu_impl.h"
@@ skipping 22 matching lines @@
 using WebKit::WebDragOperationNone;
 using WebKit::WebDragOperationsMask;
 using WebKit::WebFrame;
 using WebKit::WebFrameClient;
 using WebKit::WebInputEvent;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebMediaPlayerAction;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
 using WebKit::WebNavigationPolicy;
+using WebKit::WebNode;
 using WebKit::WebPoint;
 using WebKit::WebRect;
 using WebKit::WebSettings;
 using WebKit::WebSettingsImpl;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebTextDirection;
 using WebKit::WebTextDirectionDefault;
 using WebKit::WebTextDirectionLeftToRight;
 using WebKit::WebTextDirectionRightToLeft;
 using WebKit::WebURL;
+using WebKit::WebVector;
 
-using webkit_glue::ImageResourceFetcher;
 using webkit_glue::AccessibilityObjectToWebAccessibilityObject;
 
 // Change the text zoom level by kTextSizeMultiplierRatio each time the user
 // zooms text in or out (ie., change by 20%).  The min and max values limit
 // text zoom to half and 3x the original text size.  These three values match
 // those in Apple's port in WebKit/WebKit/WebView/WebView.mm
 static const double kTextSizeMultiplierRatio = 1.2;
 static const double kMinTextSizeMultiplier = 0.5;
 static const double kMaxTextSizeMultiplier = 3.0;
 
@@ skipping 21 matching lines @@
 
 // AutocompletePopupMenuClient
 class AutocompletePopupMenuClient : public WebCore::PopupMenuClient {
  public:
   AutocompletePopupMenuClient(WebViewImpl* webview) : text_field_(NULL),
                                                       selected_index_(0),
                                                       webview_(webview) {
   }
 
   void Init(WebCore::HTMLInputElement* text_field,
-            const std::vector<std::wstring>& suggestions,
+            const WebVector<WebString>& suggestions,
             int default_suggestion_index) {
     DCHECK(default_suggestion_index < static_cast<int>(suggestions.size()));
     text_field_ = text_field;
     selected_index_ = default_suggestion_index;
     SetSuggestions(suggestions);
 
     FontDescription font_description;
     webview_->theme()->systemFont(CSSValueWebkitControl, font_description);
     // Use a smaller font size to match IE/Firefox.
     // TODO(jcampan): http://crbug.com/7376 use the system size instead of a
@@ skipping 98 matching lines @@
       ScrollbarClient* client,
       ScrollbarOrientation orientation,
       ScrollbarControlSize size) {
     RefPtr<Scrollbar> widget = Scrollbar::createNativeScrollbar(client,
                                                                 orientation,
                                                                 size);
     return widget.release();
   }
 
   // AutocompletePopupMenuClient specific methods:
-  void SetSuggestions(const std::vector<std::wstring>& suggestions) {
+  void SetSuggestions(const WebVector<WebString>& suggestions) {
     suggestions_.clear();
-    for (std::vector<std::wstring>::const_iterator iter = suggestions.begin();
-         iter != suggestions.end(); ++iter) {
-      suggestions_.push_back(webkit_glue::StdWStringToString(*iter));
-    }
+    for (size_t i = 0; i < suggestions.size(); ++i)
+      suggestions_.append(webkit_glue::WebStringToString(suggestions[i]));
     // Try to preserve selection if possible.
     if (selected_index_ >= static_cast<int>(suggestions.size()))
       selected_index_ = -1;
   }
 
   void RemoveItemAtIndex(int index) {
     DCHECK(index >= 0 && index < static_cast<int>(suggestions_.size()));
-    suggestions_.erase(suggestions_.begin() + index);
+    suggestions_.remove(index);
   }
 
   WebCore::HTMLInputElement* text_field() const {
     return text_field_.get();
   }
 
   WebCore::RenderStyle* GetTextFieldStyle() const {
     WebCore::RenderStyle* style = text_field_->computedStyle();
     if (!style) {
       // It seems we can only have an NULL style in a TextField if the node is
       // dettached, in which case we the popup shoud not be showing.
       NOTREACHED() << "Please report this in http://crbug.com/7708 and include "
                       "the page you were visiting.";
     }
     return style;
   }
 
  private:
   RefPtr<WebCore::HTMLInputElement> text_field_;
-  std::vector<WebCore::String> suggestions_;
+  Vector<WebCore::String> suggestions_;
   int selected_index_;
   WebViewImpl* webview_;
   scoped_ptr<PopupMenuStyle> style_;
 };
 
 // Note that focusOnShow is false so that the autocomplete popup is shown not
 // activated.  We need the page to still have focus so the user can keep typing
 // while the popup is showing.
 static const WebCore::PopupContainerSettings kAutocompletePopupSettings = {
   false,  // focusOnShow
@@ skipping 341 matching lines @@
     }
     WebCore::Element* element = static_cast<WebCore::Element*>(node);
     if (!element->hasLocalName(WebCore::HTMLNames::inputTag)) {
       NOTREACHED();
       return false;
     }
 
     int selected_index = autocomplete_popup_->selectedIndex();
     WebCore::HTMLInputElement* input_element =
         static_cast<WebCore::HTMLInputElement*>(element);
-    std::wstring name = webkit_glue::StringToStdWString(input_element->name());
-    std::wstring value = webkit_glue::StringToStdWString(
-        autocomplete_popup_client_->itemText(selected_index ));
-    delegate()->RemoveStoredAutofillEntry(name, value);
+    const WebString& name = webkit_glue::StringToWebString(
+        input_element->name());
+    const WebString& value = webkit_glue::StringToWebString(
+        autocomplete_popup_client_->itemText(selected_index));
+    client()->removeAutofillSuggestions(name, value);
     // Update the entries in the currently showing popup to reflect the
     // deletion.
     autocomplete_popup_client_->RemoveItemAtIndex(selected_index);
     RefreshAutofillPopup();
     return false;
   }
 
   if (!autocomplete_popup_->isInterestedInEventForKey(event.windowsKeyCode))
     return false;
 
@@ skipping 970 matching lines @@
 WebAccessibilityObject WebViewImpl::accessibilityObject() {
   if (!main_frame())
     return WebAccessibilityObject();
 
   WebCore::Document* document = main_frame()->frame()->document();
 
   return AccessibilityObjectToWebAccessibilityObject(
       document->axObjectCache()->getOrCreate(document->renderer()));
 }
 
-// WebView --------------------------------------------------------------------
-
-bool WebViewImpl::setDropEffect(bool accept) {
-  if (drag_target_dispatch_) {
-    drop_effect_ = accept ? DROP_EFFECT_COPY : DROP_EFFECT_NONE;
-    return true;
-  } else {
-    return false;
-  }
-}
-
-void WebViewImpl::AutofillSuggestionsForNode(
-      int64 node_id,
-      const std::vector<std::wstring>& suggestions,
-      int default_suggestion_index) {
-  if (!page_.get() || suggestions.empty()) {
+void WebViewImpl::applyAutofillSuggestions(
+    const WebNode& node,
+    const WebVector<WebString>& suggestions,
+    int default_suggestion_index) {
+  if (!page_.get() || suggestions.isEmpty()) {
     HideAutoCompletePopup();
     return;
   }
 
   DCHECK(default_suggestion_index < static_cast<int>(suggestions.size()));
 
   if (RefPtr<Frame> focused = page_->focusController()->focusedFrame()) {
     RefPtr<Document> document = focused->document();
     if (!document.get()) {
       HideAutoCompletePopup();
       return;
     }
 
     RefPtr<Node> focused_node = document->focusedNode();
     // If the node for which we queried the autofill suggestions is not the
     // focused node, then we have nothing to do.
     // TODO(jcampan): also check the carret is at the end and that the text has
     // not changed.
     if (!focused_node.get() ||
-        reinterpret_cast<int64>(focused_node.get()) != node_id) {
+        focused_node != webkit_glue::WebNodeToNode(node)) {
       HideAutoCompletePopup();
       return;
     }
 
     if (!focused_node->hasTagName(WebCore::HTMLNames::inputTag)) {
       NOTREACHED();
       return;
     }
 
     WebCore::HTMLInputElement* input_elem =
@@ skipping 16 matching lines @@
       autocomplete_popup_client_->SetSuggestions(suggestions);
       RefreshAutofillPopup();
     } else {
       autocomplete_popup_->show(focused_node->getRect(),
                                 focused_node->ownerDocument()->view(), 0);
       autocomplete_popup_showing_ = true;
     }
   }
 }
 
+void WebViewImpl::hideAutofillPopup() {
+  HideAutoCompletePopup();
+}
+
+// WebView --------------------------------------------------------------------
+
+bool WebViewImpl::setDropEffect(bool accept) {
+  if (drag_target_dispatch_) {
+    drop_effect_ = accept ? DROP_EFFECT_COPY : DROP_EFFECT_NONE;
+    return true;
+  } else {
+    return false;
+  }
+}
+
 WebDevToolsAgent* WebViewImpl::GetWebDevToolsAgent() {
   return GetWebDevToolsAgentImpl();
 }
 
 WebDevToolsAgentImpl* WebViewImpl::GetWebDevToolsAgentImpl() {
   return devtools_agent_.get();
 }
 
 void WebViewImpl::setIsTransparent(bool is_transparent) {
   // Set any existing frames to be transparent.
@@ skipping 111 matching lines @@
 }
 
 #if ENABLE(NOTIFICATIONS)
 WebKit::NotificationPresenterImpl* WebViewImpl::GetNotificationPresenter() {
   if (!notification_presenter_.isInitialized() && client())
     notification_presenter_.initialize(client()->notificationPresenter());
   return &notification_presenter_;
 }
 #endif
 
-void WebViewImpl::HideAutofillPopup() {
-  HideAutoCompletePopup();
-}
-
 void WebViewImpl::RefreshAutofillPopup() {
   DCHECK(autocomplete_popup_showing_);
 
   // Hide the popup if it has become empty.
   if (autocomplete_popup_client_->listSize() == 0) {
     HideAutoCompletePopup();
     return;
   }
 
   IntRect old_bounds = autocomplete_popup_->boundsRect();
@@ skipping 27 matching lines @@
       hitTestResultAtPoint(doc_point, false);
 }
 
 void WebViewImpl::setTabsToLinks(bool enable) {
   tabs_to_links_ = enable;
 }
 
 bool WebViewImpl::tabsToLinks() const {
   return tabs_to_links_;
 }