Integration with Toolbar autofill servers....

chrome/browser/autofill/autofill_manager.cc

 // Copyright (c) 2010 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/browser/autofill/autofill_manager.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "chrome/browser/autofill/autofill_dialog.h"
 #include "chrome/browser/autofill/autofill_infobar_delegate.h"
+#include "chrome/browser/autofill/autofill_xml_parser.h"
 #include "chrome/browser/autofill/form_structure.h"
 #include "chrome/browser/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "webkit/glue/form_data.h"
 #include "webkit/glue/form_field.h"
 #include "webkit/glue/form_field_values.h"
 
 AutoFillManager::AutoFillManager(TabContents* tab_contents)
     : tab_contents_(tab_contents),
       personal_data_(NULL),
       infobar_(NULL) {
   DCHECK(tab_contents);
 
   personal_data_ =
       tab_contents_->profile()->GetOriginalProfile()->GetPersonalDataManager();
   DCHECK(personal_data_);
+  download_manager_.SetObserver(this);
 }
 
 AutoFillManager::~AutoFillManager() {
   // This is NULL in the MockAutoFillManager.
   if (personal_data_)
     personal_data_->RemoveObserver(this);
+  download_manager_.SetObserver(NULL);
 }
 
 // static
 void AutoFillManager::RegisterBrowserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(prefs::kAutoFillDialogPlacement);
 }
 
 // static
 void AutoFillManager::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kAutoFillInfoBarShown, false);
@@ skipping 32 matching lines @@
     const std::vector<webkit_glue::FormFieldValues>& forms) {
   if (!IsAutoFillEnabled())
     return;
 
   for (std::vector<webkit_glue::FormFieldValues>::const_iterator iter =
            forms.begin();
        iter != forms.end(); ++iter) {
     FormStructure* form_structure = new FormStructure(*iter);
     DeterminePossibleFieldTypes(form_structure);
     form_structures_.push_back(form_structure);
+    std::string request_xml;
+    if (form_structure->IsAutoFillable() &&
+        form_structure->EncodeUploadRequest(true, true, &request_xml)) {
+      download_manager_.StartRequest(request_xml,
+                                     form_structure->FormSignature(),
+                                     true,
+                                     false);
+    }
   }
 }
 
 bool AutoFillManager::GetAutoFillSuggestions(
     int query_id, const webkit_glue::FormField& field) {
   if (!IsAutoFillEnabled())
     return false;
 
   RenderViewHost* host = tab_contents_->render_view_host();
   if (!host)
@@ skipping 175 matching lines @@
 void AutoFillManager::OnInfoBarCancelled() {
   PrefService* prefs = tab_contents_->profile()->GetPrefs();
   prefs->SetBoolean(prefs::kAutoFillEnabled, false);
 }
 
 void AutoFillManager::Reset() {
   upload_form_structure_.reset();
   form_structures_.reset();
 }
 
+void AutoFillManager::OnLoadedAutoFillHeuristics(
+    const std::string& form_signature,
+    const std::string& heuristic_xml) {
+  for (ScopedVector<FormStructure>::iterator it = form_structures_.begin();
+      it != form_structures_.end();
+      ++it) {
+    if ((*it)->FormSignature() == form_signature) {
+      // Create a vector of AutoFillFieldTypes,
+      // to assign the parsed field types to.
+      std::vector<AutoFillFieldType> field_types;
+      UploadRequired upload_required = USE_UPLOAD_RATES;
+
+      // Create a parser.
+      AutoFillQueryXmlParser parse_handler(&field_types, &upload_required);
+      buzz::XmlParser parser(&parse_handler);
+      parser.Parse(heuristic_xml.c_str(), heuristic_xml.length(), true);
+      if (parse_handler.succeeded()) {
+        DCHECK(field_types.size() == (*it)->field_count());
+        if (field_types.size() == (*it)->field_count()) {
+          for (size_t i = 0; i < (*it)->field_count(); ++i) {
+            if (field_types[i] != NO_SERVER_DATA &&
+                field_types[i] != UNKNOWN_TYPE) {
+             FieldTypeSet types = (*it)->field(i)->possible_types();
+             types.insert(field_types[i]);
+             (*it)->set_possible_types(i, types);
+            }
+          }
+        }
+        return;
+      }
+    }
+  }
+}
+
+void AutoFillManager::OnUploadedAutoFillHeuristics(
+    const std::string& form_signature) {
+}
+
+void AutoFillManager::OnHeuristicsRequestError(
+    const std::string& form_signature, int http_error) {
+}
+
 void AutoFillManager::DeterminePossibleFieldTypes(
     FormStructure* form_structure) {
   // TODO(jhawkins): Update field text.
 
   form_structure->GetHeuristicAutoFillTypes();
 
   for (size_t i = 0; i < form_structure->field_count(); i++) {
     const AutoFillField* field = form_structure->field(i);
     FieldTypeSet field_types;
     personal_data_->GetPossibleFieldTypes(field->value(), &field_types);
     form_structure->set_possible_types(i, field_types);
   }
 }
 
 void AutoFillManager::HandleSubmit() {
   // If there wasn't enough data to import then we don't want to send an upload
   // to the server.
   if (!personal_data_->ImportFormData(form_structures_.get(), this))
     return;
 
   UploadFormData();
 }
 
 void AutoFillManager::UploadFormData() {
   std::string xml;
-  bool ok = upload_form_structure_->EncodeUploadRequest(false, &xml);
+  bool ok = upload_form_structure_->EncodeUploadRequest(false, false, &xml);
   DCHECK(ok);
 
-  // TODO(jhawkins): Initiate the upload request thread.
+  // TODO(georgey): enable upload request when we make sure that our data is in
+  // line with toolbar data:
+  // download_manager_.StartRequest(xml,
+  //                                upload_form_structure_->FormSignature(),
+  //                                false,
+  //                                form_is_autofilled);
 }
 
 bool AutoFillManager::IsAutoFillEnabled() {
   PrefService* prefs = tab_contents_->profile()->GetPrefs();
 
   // Migrate obsolete AutoFill pref.
   if (prefs->HasPrefPath(prefs::kFormAutofillEnabled)) {
     bool enabled = prefs->GetBoolean(prefs::kFormAutofillEnabled);
     prefs->ClearPref(prefs::kFormAutofillEnabled);
     prefs->SetBoolean(prefs::kAutoFillEnabled, enabled);
     return enabled;
   }
 
   return prefs->GetBoolean(prefs::kAutoFillEnabled);
 }
 
 AutoFillManager::AutoFillManager()
     : tab_contents_(NULL),
       personal_data_(NULL) {
 }