Setting up external delegate calls to allow a future delegate to handle autofill

chrome/renderer/autofill/autofill_agent.cc

 // Copyright (c) 2011 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 "chrome/renderer/autofill/autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/autofill_messages.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/renderer/autofill/form_autofill_util.h"
 #include "chrome/renderer/autofill/password_autofill_manager.h"
 #include "content/public/renderer/render_view.h"
 #include "grit/generated_resources.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormControlElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/glue/form_data.h"
 #include "webkit/glue/form_data_predictions.h"
 #include "webkit/glue/form_field.h"
 #include "webkit/glue/password_form.h"
 
 using WebKit::WebFormControlElement;
 using WebKit::WebFormElement;
@@ skipping 20 matching lines @@
     PasswordAutofillManager* password_autofill_manager)
     : content::RenderViewObserver(render_view),
       password_autofill_manager_(password_autofill_manager),
       autofill_query_id_(0),
       autofill_action_(AUTOFILL_NONE),
       display_warning_if_disabled_(false),
       was_query_node_autofilled_(false),
       suggestions_clear_index_(-1),
       suggestions_options_index_(-1),
       has_shown_autofill_popup_for_current_edit_(false),
+      has_external_delegate_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   render_view->GetWebView()->setAutofillClient(this);
 }
 
 AutofillAgent::~AutofillAgent() {}
 
 bool AutofillAgent::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AutofillAgent, message)
     IPC_MESSAGE_HANDLER(AutofillMsg_SuggestionsReturned, OnSuggestionsReturned)
     IPC_MESSAGE_HANDLER(AutofillMsg_FormDataFilled, OnFormDataFilled)
     IPC_MESSAGE_HANDLER(AutofillMsg_FieldTypePredictionsAvailable,
                         OnFieldTypePredictionsAvailable)
     IPC_MESSAGE_HANDLER(AutofillMsg_SelectAutofillSuggestionAtIndex,
                         OnSelectAutofillSuggestionAtIndex)
+    IPC_MESSAGE_HANDLER(AutofillMsg_HasExternalDelegate,
+                        HasExternalDelegate)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void AutofillAgent::DidFinishDocumentLoad(WebFrame* frame) {
   // The document has now been fully loaded.  Scan for forms to be sent up to
   // the browser.
   std::vector<webkit_glue::FormData> forms;
   form_cache_.ExtractForms(*frame, &forms);
@@ skipping 30 matching lines @@
 bool AutofillAgent::InputElementClicked(const WebInputElement& element,
                                         bool was_focused,
                                         bool is_focused) {
   if (was_focused)
     ShowSuggestions(element, true, false, true);
 
   return false;
 }
 
 bool AutofillAgent::InputElementLostFocus() {
+  if (has_external_delegate_)
+    Send(new AutofillDelegateMsg_HideAutofillPopup(routing_id()));
+
   return false;
 }
 
 void AutofillAgent::didAcceptAutofillSuggestion(const WebNode& node,
                                                 const WebString& value,
                                                 const WebString& label,
                                                 int unique_id,
                                                 unsigned index) {
   if (password_autofill_manager_->DidAcceptAutofillSuggestion(node, value))
     return;
@@ skipping 108 matching lines @@
                                           const std::vector<string16>& labels,
                                           const std::vector<string16>& icons,
                                           const std::vector<int>& unique_ids) {
   WebKit::WebView* web_view = render_view()->GetWebView();
   if (!web_view || query_id != autofill_query_id_)
     return;
 
   if (values.empty()) {
     // No suggestions, any popup currently showing is obsolete.
     web_view->hidePopups();
+    if (has_external_delegate_)
+      Send(new AutofillDelegateMsg_HideAutofillPopup(routing_id()));

[Ilya Sherman, 2011/11/07 21:48:49]

This call shouldn't be necessary -- all the relevant information is already
available to the browser process.

[csharp1, 2011/11/08 19:59:00]

Done.

     return;
   }
 
   std::vector<string16> v(values);
   std::vector<string16> l(labels);
   std::vector<string16> i(icons);
   std::vector<int> ids(unique_ids);
   int separator_index = -1;
 
   DCHECK_GT(ids.size(), 0U);
@@ skipping 43 matching lines @@
     // Append the 'Chrome Autofill options' menu item;
     v.push_back(l10n_util::GetStringFUTF16(IDS_AUTOFILL_OPTIONS_POPUP,
         WideToUTF16(chrome::kBrowserAppName)));
     l.push_back(string16());
     i.push_back(string16());
     ids.push_back(0);
     suggestions_options_index_ = v.size() - 1;
     separator_index = values.size();
   }
 
-  // Send to WebKit for display.
   if (!v.empty() && !autofill_query_element_.isNull() &&
       autofill_query_element_.isFocusable()) {
-    web_view->applyAutofillSuggestions(
-        autofill_query_element_, v, l, i, ids, separator_index);
+    if (has_external_delegate_) {
+      // Send to an external delegate for display.
+      WebKit::WebRect  autofill_element_rect =
+          autofill_query_element_.getRect();
+
+      Send(new AutofillDelegateMsg_AutofillElementBounds(
+          routing_id(),
+          autofill_element_rect.x,
+          autofill_element_rect.y,
+          autofill_element_rect.width,
+          autofill_element_rect.height));
+
+      Send(new AutofillDelegateMsg_ShowAutofillSuggestions(
+           routing_id(), query_id, v, l, i, ids));

[Ilya Sherman, 2011/11/07 21:48:49]

We'll need to rework how warnings are handled; but otherwise, all of the
relevant information is already available on the browser-side.  Rather than
routing through the renderer, let's keep all this logic browser-side.  If you'd
like to ignore getting warnings working just right for now, feel free to file a
bug to tackle this later.

[csharp1, 2011/11/08 19:59:00]

So if I understand correctly, you are suggesting that we have a copy of this
logic browser-side to prevent the call?
If so, would this make sense to place the external_delegate base class?

On 2011/11/07 21:48:49, Ilya Sherman wrote:

[Ilya Sherman, 2011/11/08 21:06:16]

Right.  Once the transition to the browser-side UI is complete, we can remove
the copy of this code that lives in autofill_agent.
Yeah, I think that's a reasonable place for this code to live.

[csharp, 2011/11/09 16:18:37]

Ok, I've added a todo to copy the logic over. I quickly looked at it and it
looks like it might be enough work to deserve its own cl since it has several
member variables and functions that I'll need to figure out how to correctly
move over.

On 2011/11/08 21:06:16, Ilya Sherman wrote:

+    } else {
+      // Send to WebKit for display.
+      web_view->applyAutofillSuggestions(
+          autofill_query_element_, v, l, i, ids, separator_index);
+    }
+  } else {
+    if (has_external_delegate_)
+      Send(new AutofillDelegateMsg_HideAutofillPopup(routing_id()));
   }
 
   Send(new AutofillHostMsg_DidShowAutofillSuggestions(
       routing_id(),
       has_autofill_item && !has_shown_autofill_popup_for_current_edit_));
   has_shown_autofill_popup_for_current_edit_ |= has_autofill_item;
 }
 
 void AutofillAgent::OnFormDataFilled(int query_id,
                                      const webkit_glue::FormData& form) {
@@ skipping 22 matching lines @@
     form_cache_.ShowPredictions(forms[i]);
   }
 }
 
 void AutofillAgent::OnSelectAutofillSuggestionAtIndex(int listIndex) {
   NOTIMPLEMENTED();
   // TODO(jrg): enable once changes land in WebKit
   // render_view()->webview()->selectAutofillSuggestionAtIndex(listIndex);
 }
 
+void AutofillAgent::HasExternalDelegate(bool has_external_delegate) {
+  has_external_delegate_ = has_external_delegate;
+}
+
 void AutofillAgent::ShowSuggestions(const WebInputElement& element,
                                     bool autofill_on_empty_values,
                                     bool requires_caret_at_end,
                                     bool display_warning_if_disabled) {
   // If autocomplete is disabled at the form level, then we might want to show
   // a warning in place of suggestions. However, if autocomplete is disabled
   // specifically for this field, we never want to show a warning. Otherwise,
   // we might interfere with custom popups (e.g. search suggestions) used by
   // the website.
   const WebFormElement form = element.form();
@@ skipping 56 matching lines @@
     return;
   }
 
   autofill_action_ = action;
   was_query_node_autofilled_ = field.is_autofilled;
   Send(new AutofillHostMsg_FillAutofillFormData(
       routing_id(), autofill_query_id_, form, field, unique_id));
 }
 
 }  // namespace autofill