Convert autofill messages to use the new IPC macros

chrome/renderer/autofill/password_autofill_manager.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/password_autofill_manager.h"
 
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "chrome/common/autofill_messages.h"
 #include "chrome/renderer/render_view.h"
@@ skipping 34 matching lines @@
 // Helper to search the given form element for the specified input elements
 // in |data|, and add results to |result|.
 static bool FindFormInputElements(WebKit::WebFormElement* fe,
                                   const webkit_glue::FormData& data,
                                   FormElements* result) {
   // Loop through the list of elements we need to find on the form in order to
   // autofill it. If we don't find any one of them, abort processing this
   // form; it can't be the right one.
   for (size_t j = 0; j < data.fields.size(); j++) {
     WebKit::WebVector<WebKit::WebNode> temp_elements;
-    fe->getNamedElements(data.fields[j].name(), temp_elements);
+    fe->getNamedElements(data.fields[j].name, temp_elements);
 
     // Match the first input element, if any.
     // |getNamedElements| may return non-input elements where the names match,
     // so the results are filtered for input elements.
     // If more than one match is made, then we have ambiguity (due to misuse
     // of "name" attribute) so is it considered not found.
     bool found_input = false;
     for (size_t i = 0; i < temp_elements.size(); ++i) {
       if (temp_elements[i].to<WebKit::WebElement>().hasTagName("input")) {
         // Check for a non-unique match.
         if (found_input) {
           found_input = false;
           break;
         }
 
         // This element matched, add it to our temporary result. It's possible
         // there are multiple matches, but for purposes of identifying the form
         // one suffices and if some function needs to deal with multiple
         // matching elements it can get at them through the FormElement*.
         // Note: This assignment adds a reference to the InputElement.
-        result->input_elements[data.fields[j].name()] =
+        result->input_elements[data.fields[j].name] =
             temp_elements[i].to<WebKit::WebInputElement>();
         found_input = true;
       }
     }
 
     // A required element was not found. This is not the right form.
     // Make sure no input elements from a partially matched form in this
     // iteration remain in the result set.
     // Note: clear will remove a reference from each InputElement.
     if (!found_input) {
@@ skipping 49 matching lines @@
     }
   }
 }
 
 bool FillForm(FormElements* fe, const webkit_glue::FormData& data) {
   if (!fe->form_element.autoComplete())
     return false;
 
   std::map<string16, string16> data_map;
   for (size_t i = 0; i < data.fields.size(); i++)
-    data_map[data.fields[i].name()] = data.fields[i].value();
+    data_map[data.fields[i].name] = data.fields[i].value;
 
   for (FormInputElementMap::iterator it = fe->input_elements.begin();
        it != fe->input_elements.end(); ++it) {
     WebKit::WebInputElement element = it->second;
     // Don't fill a form that has pre-filled values.
     if (!element.value().isEmpty())
       return false;
   }
 
   for (FormInputElementMap::iterator it = fe->input_elements.begin();
@@ skipping 245 matching lines @@
     scoped_ptr<FormElements> form_elements(*iter);
 
     // If wait_for_username is true, we don't want to initially fill the form
     // until the user types in a valid username.
     if (!form_data.wait_for_username)
       FillForm(form_elements.get(), form_data.basic_data);
 
     // Attach autocomplete listener to enable selecting alternate logins.
     // First, get pointers to username element.
     WebKit::WebInputElement username_element =
-        form_elements->input_elements[form_data.basic_data.fields[0].name()];
+        form_elements->input_elements[form_data.basic_data.fields[0].name];
 
     // Get pointer to password element. (We currently only support single
     // password forms).
     WebKit::WebInputElement password_element =
-        form_elements->input_elements[form_data.basic_data.fields[1].name()];
+        form_elements->input_elements[form_data.basic_data.fields[1].name];
 
     DCHECK(login_to_password_info_.find(username_element) ==
         login_to_password_info_.end());
     PasswordInfo password_info;
     password_info.fill_data = form_data;
     password_info.password_field = password_element;
     login_to_password_info_[username_element] = password_info;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillManager, private:
 
 void PasswordAutofillManager::GetSuggestions(
     const webkit_glue::PasswordFormFillData& fill_data,
     const string16& input,
     std::vector<string16>* suggestions) {
-  if (StartsWith(fill_data.basic_data.fields[0].value(), input, false))
-    suggestions->push_back(fill_data.basic_data.fields[0].value());
+  if (StartsWith(fill_data.basic_data.fields[0].value, input, false))
+    suggestions->push_back(fill_data.basic_data.fields[0].value);
 
   webkit_glue::PasswordFormFillData::LoginCollection::const_iterator iter;
   for (iter = fill_data.additional_logins.begin();
        iter != fill_data.additional_logins.end(); ++iter) {
     if (StartsWith(iter->first, input, false))
       suggestions->push_back(iter->first);
   }
 }
 
 bool PasswordAutofillManager::ShowSuggestionPopup(
@@ skipping 23 matching lines @@
     WebKit::WebInputElement* password_element,
     const webkit_glue::PasswordFormFillData& fill_data,
     bool exact_username_match,
     bool set_selection) {
   string16 current_username = username_element->value();
   // username and password will contain the match found if any.
   string16 username;
   string16 password;
 
   // Look for any suitable matches to current field text.
-  if (DoUsernamesMatch(fill_data.basic_data.fields[0].value(), current_username,
+  if (DoUsernamesMatch(fill_data.basic_data.fields[0].value, current_username,
                        exact_username_match)) {
-    username = fill_data.basic_data.fields[0].value();
-    password = fill_data.basic_data.fields[1].value();
+    username = fill_data.basic_data.fields[0].value;
+    password = fill_data.basic_data.fields[1].value;
   } else {
     // Scan additional logins for a match.
     webkit_glue::PasswordFormFillData::LoginCollection::const_iterator iter;
     for (iter = fill_data.additional_logins.begin();
          iter != fill_data.additional_logins.end(); ++iter) {
       if (DoUsernamesMatch(iter->first, current_username,
                            exact_username_match)) {
         username = iter->first;
         password = iter->second;
         break;
@@ skipping 67 matching lines @@
   LoginToPasswordInfoMap::iterator iter = login_to_password_info_.find(input);
   if (iter == login_to_password_info_.end())
     return false;
 
   *found_input = input;
   *found_password = iter->second;
   return true;
 }
 
 }  // namespace autofill