Detecting form locale

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 <limits>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_cc_infobar_delegate.h"
 #include "chrome/browser/autofill/autofill_dialog.h"
 #include "chrome/browser/autofill/form_structure.h"
 #include "chrome/browser/autofill/select_control_handler.h"
 #include "chrome/browser/prefs/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/notification_source.h"
+#include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "webkit/glue/form_data.h"
 #include "webkit/glue/form_field.h"
 
 using webkit_glue::FormData;
 using webkit_glue::FormField;
 
 namespace {
 
@@ skipping 61 matching lines @@
 }  // namespace
 
 // TODO(jhawkins): Maybe this should be in a grd file?
 const char* kAutoFillLearnMoreUrl =
     "http://www.google.com/support/chrome/bin/answer.py?answer=142893";
 
 AutoFillManager::AutoFillManager(TabContents* tab_contents)
     : tab_contents_(tab_contents),
       personal_data_(NULL),
       download_manager_(tab_contents_->profile()),
+      locale_model_(tab_contents_),
       disable_download_manager_requests_(false) {
   DCHECK(tab_contents);
 
   // |personal_data_| is NULL when using TestTabContents.
   personal_data_ =
       tab_contents_->profile()->GetOriginalProfile()->GetPersonalDataManager();
   download_manager_.SetObserver(this);
+  notification_registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
+                              Source<TabContents>(tab_contents_));
 }
 
 AutoFillManager::~AutoFillManager() {
   download_manager_.SetObserver(NULL);
+  notification_registrar_.Remove(this,
+                                 NotificationType::TAB_LANGUAGE_DETERMINED,
+                                 Source<TabContents>(tab_contents_));
 }
 
 // static
 void AutoFillManager::RegisterBrowserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(prefs::kAutoFillDialogPlacement);
 }
 
 // static
 void AutoFillManager::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kAutoFillEnabled, true);
@@ skipping 14 matching lines @@
 
   if (tab_contents_->profile()->IsOffTheRecord())
     return;
 
   // Don't save data that was submitted through JavaScript.
   if (!form.user_submitted)
     return;
 
   // Grab a copy of the form data.
   upload_form_structure_.reset(new FormStructure(form));
+  if (locale_model_.tab_language_determined())
+    locale_model_.UpdateLocale(upload_form_structure_.get());
 
   if (!upload_form_structure_->IsAutoFillable())
     return;
 
   // Determine the possible field types and upload the form structure to the
   // PersonalDataManager.
   DeterminePossibleFieldTypes(upload_form_structure_.get());
   HandleSubmit();
 }
 
@@ skipping 210 matching lines @@
 
 void AutoFillManager::ShowAutoFillDialog() {
   ::ShowAutoFillDialog(tab_contents_->GetContentNativeView(),
                        personal_data_,
                        tab_contents_->profile()->GetOriginalProfile());
 }
 
 void AutoFillManager::Reset() {
   upload_form_structure_.reset();
   form_structures_.reset();
+  locale_model_.set_tab_language_determined(false);
 }
 
 void AutoFillManager::OnLoadedAutoFillHeuristics(
     const std::string& heuristic_xml) {
   // TODO(jhawkins): Store |upload_required| in the AutoFillManager.
   UploadRequired upload_required;
   FormStructure::ParseQueryResponse(heuristic_xml,
                                     form_structures_.get(),
                                     &upload_required);
 }
 
 void AutoFillManager::OnUploadedAutoFillHeuristics(
     const std::string& form_signature) {
 }
 
 void AutoFillManager::OnHeuristicsRequestError(
     const std::string& form_signature,
     AutoFillDownloadManager::AutoFillRequestType request_type,
     int http_error) {
 }
 
+void AutoFillManager::Observe(NotificationType type,
+                              const NotificationSource& source,
+                              const NotificationDetails& details) {
+  if (type != NotificationType::TAB_LANGUAGE_DETERMINED) {
+    NOTREACHED();
+    return;
+  }
+
+  DCHECK(source == Source<TabContents>(tab_contents_));
+
+  // Now that the tab language is known, update the locales of the forms we've
+  // seen.
+  locale_model_.set_tab_language_determined(true);
+  for (std::vector<FormStructure*>::iterator it = form_structures_.begin();
+       it != form_structures_.end(); ++it) {
+    locale_model_.UpdateLocale(*it);
+  }
+}
+
 bool AutoFillManager::IsAutoFillEnabled() const {
   PrefService* prefs = tab_contents_->profile()->GetPrefs();
 
   // Migrate obsolete AutoFill pref.
   if (prefs->FindPreference(prefs::kFormAutofillEnabled)) {
     bool enabled = prefs->GetBoolean(prefs::kFormAutofillEnabled);
     prefs->ClearPref(prefs::kFormAutofillEnabled);
     prefs->SetBoolean(prefs::kAutoFillEnabled, enabled);
     return enabled;
   }
@@ skipping 59 matching lines @@
 void AutoFillManager::OnInfoBarClosed(bool should_save) {
   if (should_save)
     personal_data_->SaveImportedCreditCard();
   UploadFormData();
 }
 
 AutoFillManager::AutoFillManager()
     : tab_contents_(NULL),
       personal_data_(NULL),
       download_manager_(NULL),
+      locale_model_(NULL),
       disable_download_manager_requests_(false) {
+  notification_registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
+                              Source<TabContents>(tab_contents_));
 }
 
 AutoFillManager::AutoFillManager(TabContents* tab_contents,
                                  PersonalDataManager* personal_data)
     : tab_contents_(tab_contents),
       personal_data_(personal_data),
       download_manager_(NULL),
+      locale_model_(tab_contents),
       disable_download_manager_requests_(false) {
   DCHECK(tab_contents);
+  notification_registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
+                              Source<TabContents>(tab_contents_));
 }
 
 void AutoFillManager::GetProfileSuggestions(FormStructure* form,
                                             const FormField& field,
                                             AutoFillType type,
                                             bool include_cc_labels,
                                             std::vector<string16>* values,
                                             std::vector<string16>* labels,
                                             std::vector<string16>* icons,
                                             std::vector<int>* unique_ids) {
@@ skipping 267 matching lines @@
     number = number.substr(kAutoFillPhoneNumberSuffixOffset,
                            kAutoFillPhoneNumberSuffixCount);
     field->set_value(number);
   } else {
     field->set_value(number);
   }
 }
 
 void AutoFillManager::ParseForms(
     const std::vector<webkit_glue::FormData>& forms) {
-  for (std::vector<FormData>::const_iterator iter =
-           forms.begin();
+  for (std::vector<FormData>::const_iterator iter = forms.begin();
        iter != forms.end(); ++iter) {
     scoped_ptr<FormStructure> form_structure(new FormStructure(*iter));
     if (!form_structure->ShouldBeParsed())
       continue;
 
     DeterminePossibleFieldTypes(form_structure.get());
+    if (locale_model_.tab_language_determined())
+      locale_model_.UpdateLocale(form_structure.get());
+
     form_structures_.push_back(form_structure.release());
   }
 
   // If none of the forms were parsed, no use querying the server.
   if (!form_structures_.empty() && !disable_download_manager_requests_)
     download_manager_.StartQueryRequest(form_structures_);
 }
 
 // When sending IDs (across processes) to the renderer we pack credit card and
 // profile IDs into a single integer.  Credit card IDs are sent in the high
 // word and profile IDs are sent in the low word.
 // static
 int AutoFillManager::PackIDs(int cc_id, int profile_id) {
   DCHECK(cc_id <= std::numeric_limits<unsigned short>::max());
   DCHECK(profile_id <= std::numeric_limits<unsigned short>::max());
 
   return cc_id << std::numeric_limits<unsigned short>::digits | profile_id;
 }
 
 // When receiving IDs (across processes) from the renderer we unpack credit card
 // and profile IDs from a single integer.  Credit card IDs are stored in the
 // high word and profile IDs are stored in the low word.
 // static
 void AutoFillManager::UnpackIDs(int id, int* cc_id, int* profile_id) {
   *cc_id = id >> std::numeric_limits<unsigned short>::digits &
       std::numeric_limits<unsigned short>::max();
   *profile_id = id & std::numeric_limits<unsigned short>::max();
 }