Move SendAutofillTypePredictions() into AutofillDriver.

components/autofill/core/browser/autofill_manager.cc

 // Copyright 2013 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 "components/autofill/core/browser/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 758 matching lines @@
   }
 
   // TODO(ahutter): Remove this once Autocheckout is implemented on other
   // platforms. See http://crbug.com/173416.
 #if defined(TOOLKIT_VIEWS)
   if (!GetAutocheckoutURLPrefix().empty())
     autocheckout_manager_.OnLoadedPageMetaData(page_meta_data.Pass());
 #endif  // #if defined(TOOLKIT_VIEWS)
 
   // If the corresponding flag is set, annotate forms with the predicted types.
-  SendAutofillTypePredictions(form_structures_.get());
+  driver_->SendAutofillTypePredictionsToRenderer(form_structures_.get());
 }
 
 void AutofillManager::OnDidEndTextFieldEditing() {
   if (external_delegate_)
     external_delegate_->DidEndTextFieldEditing();
 }
 
 void AutofillManager::OnClickFailed(autofill::AutocheckoutStatus status) {
   autocheckout_manager_.OnClickFailed(status);
 }
 
 std::string AutofillManager::GetAutocheckoutURLPrefix() const {
   if (!driver_->GetWebContents())
     return std::string();
 
   autofill::autocheckout::WhitelistManager* whitelist_manager =
       manager_delegate_->GetAutocheckoutWhitelistManager();
 
   return whitelist_manager ? whitelist_manager->GetMatchedURLPrefix(
       driver_->GetWebContents()->GetURL()) : std::string();
 }
 
 bool AutofillManager::IsAutofillEnabled() const {
   return manager_delegate_->GetPrefs()->GetBoolean(prefs::kAutofillEnabled);
 }
 
-void AutofillManager::SendAutofillTypePredictions(
-    const std::vector<FormStructure*>& forms) const {
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-           switches::kShowAutofillTypePredictions))
-    return;
-
-  RenderViewHost* host = driver_->GetWebContents()->GetRenderViewHost();
-  if (!host)
-    return;
-
-  std::vector<FormDataPredictions> type_predictions;
-  FormStructure::GetFieldTypePredictions(forms, &type_predictions);
-  host->Send(
-      new AutofillMsg_FieldTypePredictionsAvailable(host->GetRoutingID(),
-                                                    type_predictions));
-}
-
 void AutofillManager::ImportFormData(const FormStructure& submitted_form) {
   const CreditCard* imported_credit_card;
   if (!personal_data_->ImportFormData(submitted_form, &imported_credit_card))
     return;
 
   // If credit card information was submitted, we need to confirm whether to
   // save it.
   if (imported_credit_card) {
     manager_delegate_->ConfirmSaveCreditCard(
         *metric_logger_,
@@ skipping 260 matching lines @@
       }
     }
 
     // Note: We _must not_ remove the original version of the cached form from
     // the list of |form_structures_|.  Otherwise, we break parsing of the
     // crowdsourcing server's response to our query.
   }
 
   // Annotate the updated form with its predicted types.
   std::vector<FormStructure*> forms(1, *updated_form);
-  SendAutofillTypePredictions(forms);
+  driver_->SendAutofillTypePredictionsToRenderer(forms);
 
   return true;
 }
 
 void AutofillManager::GetProfileSuggestions(
     FormStructure* form,
     const FormFieldData& field,
     AutofillFieldType type,
     std::vector<base::string16>* values,
     std::vector<base::string16>* labels,
@@ skipping 68 matching lines @@
        iter != non_queryable_forms.end(); ++iter) {
     form_structures_.push_back(*iter);
   }
 
   if (!form_structures_.empty())
     metric_logger_->LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED);
 
   // For the |non_queryable_forms|, we have all the field type info we're ever
   // going to get about them.  For the other forms, we'll wait until we get a
   // response from the server.
-  SendAutofillTypePredictions(non_queryable_forms);
+  driver_->SendAutofillTypePredictionsToRenderer(non_queryable_forms);
 }
 
 int AutofillManager::GUIDToID(const GUIDPair& guid) const {
   if (!base::IsValidGUID(guid.first))
     return 0;
 
   std::map<GUIDPair, int>::const_iterator iter = guid_id_map_.find(guid);
   if (iter == guid_id_map_.end()) {
     int id = guid_id_map_.size() + 1;
     guid_id_map_[guid] = id;
@@ skipping 47 matching lines @@
 
 void AutofillManager::UpdateInitialInteractionTimestamp(
     const TimeTicks& interaction_timestamp) {
   if (initial_interaction_timestamp_.is_null() ||
       interaction_timestamp < initial_interaction_timestamp_) {
     initial_interaction_timestamp_ = interaction_timestamp;
   }
 }
 
 }  // namespace autofill