Abstract WebContentsObserver from Autofill shared code

components/autofill/browser/autofill_manager.cc

 // Copyright (c) 2012 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/browser/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/autofill/browser/autocheckout/whitelist_manager.h"
 #include "components/autofill/browser/autocheckout_manager.h"
 #include "components/autofill/browser/autocomplete_history_manager.h"
 #include "components/autofill/browser/autofill_data_model.h"
+#include "components/autofill/browser/autofill_driver.h"
 #include "components/autofill/browser/autofill_external_delegate.h"
 #include "components/autofill/browser/autofill_field.h"
 #include "components/autofill/browser/autofill_manager_delegate.h"
 #include "components/autofill/browser/autofill_manager_test_delegate.h"
 #include "components/autofill/browser/autofill_metrics.h"
 #include "components/autofill/browser/autofill_profile.h"
 #include "components/autofill/browser/autofill_type.h"
 #include "components/autofill/browser/credit_card.h"
 #include "components/autofill/browser/form_structure.h"
 #include "components/autofill/browser/personal_data_manager.h"
 #include "components/autofill/browser/phone_number.h"
 #include "components/autofill/browser/phone_number_i18n.h"
 #include "components/autofill/common/autofill_messages.h"
 #include "components/autofill/common/autofill_pref_names.h"
 #include "components/autofill/common/autofill_switches.h"
 #include "components/autofill/common/form_data.h"
 #include "components/autofill/common/form_data_predictions.h"
 #include "components/autofill/common/form_field_data.h"
 #include "components/autofill/common/password_form_fill_data.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
+#include "content/public/common/frame_navigate_params.h"
 #include "content/public/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "grit/component_resources.h"
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebAutofillClient.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/rect.h"
 
 namespace autofill {
 
 typedef PersonalDataManager::GUIDPair GUIDPair;
 
 using base::TimeTicks;
 using content::BrowserThread;
 using content::RenderViewHost;
 using WebKit::WebFormElement;
 
 namespace {
 
-const char* kAutofillManagerWebContentsUserDataKey = "web_contents_autofill";
-
 // We only send a fraction of the forms to upload server.
 // The rate for positive/negative matches potentially could be different.
 const double kAutofillPositiveUploadRateDefaultValue = 0.20;
 const double kAutofillNegativeUploadRateDefaultValue = 0.20;
 
 const size_t kMaxRecentFormSignaturesToRemember = 3;
 
 // Set a conservative upper bound on the number of forms we are willing to
 // cache, simply to prevent unbounded memory consumption.
 const size_t kMaxFormCacheSize = 100;
@@ skipping 91 matching lines @@
 bool HasServerSpecifiedFieldTypes(const FormStructure& form_structure) {
   for (size_t i = 0; i < form_structure.field_count(); ++i) {
     if (form_structure.field(i)->server_type() != NO_SERVER_DATA)
       return true;
   }
   return false;
 }
 
 }  // namespace
 
-// static
-void AutofillManager::CreateForWebContentsAndDelegate(
-    content::WebContents* contents,
-    autofill::AutofillManagerDelegate* delegate,
-    const std::string& app_locale,
-    AutofillDownloadManagerState enable_download_manager) {
-  if (FromWebContents(contents))
-    return;
-
-  contents->SetUserData(
-      kAutofillManagerWebContentsUserDataKey,
-      new AutofillManager(
-          contents, delegate, app_locale, enable_download_manager));
-
-  // Trigger the lazy creation of AutocheckoutWhitelistManagerService, and
-  // schedule a fetch of the Autocheckout whitelist file if it's not already
-  // loaded. This helps ensure that the whitelist will be available by the time
-  // the user navigates to a form on which Autocheckout should be enabled.
-  delegate->GetAutocheckoutWhitelistManager();
-}
-
-// static
-AutofillManager* AutofillManager::FromWebContents(
-    content::WebContents* contents) {
-  return static_cast<AutofillManager*>(
-      contents->GetUserData(kAutofillManagerWebContentsUserDataKey));
-}
-
 AutofillManager::AutofillManager(
-    content::WebContents* web_contents,
+    AutofillDriver* driver,
     autofill::AutofillManagerDelegate* delegate,
     const std::string& app_locale,
     AutofillDownloadManagerState enable_download_manager)
-    : content::WebContentsObserver(web_contents),
+    : driver_(driver),
       manager_delegate_(delegate),
       app_locale_(app_locale),
       personal_data_(delegate->GetPersonalDataManager()),
-      autocomplete_history_manager_(web_contents),
+      autocomplete_history_manager_(driver),
       autocheckout_manager_(this),
       metric_logger_(new AutofillMetrics),
       has_logged_autofill_enabled_(false),
       has_logged_address_suggestions_count_(false),
       did_show_suggestions_(false),
       user_did_type_(false),
       user_did_autofill_(false),
       user_did_edit_autofilled_field_(false),
       external_delegate_(NULL),
       test_delegate_(NULL),
       weak_ptr_factory_(this) {
   if (enable_download_manager == ENABLE_AUTOFILL_DOWNLOAD_MANAGER) {
     download_manager_.reset(
-        new AutofillDownloadManager(web_contents->GetBrowserContext(), this));
+        new AutofillDownloadManager(
+            driver->GetWebContents()->GetBrowserContext(), this));
   }
 }
 
 AutofillManager::~AutofillManager() {}
 
 // static
 void AutofillManager::RegisterUserPrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(
       prefs::kAutofillEnabled,
@@ skipping 67 matching lines @@
     IPC_MESSAGE_HANDLER(AutofillHostMsg_ShowPasswordSuggestions,
                         OnShowPasswordSuggestions)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_SetDataList,
                         OnSetDataList)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_RequestAutocomplete,
                         OnRequestAutocomplete)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_ClickFailed,
                         OnClickFailed)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_MaybeShowAutocheckoutBubble,
                         OnMaybeShowAutocheckoutBubble)
+    IPC_MESSAGE_HANDLER(AutofillHostMsg_RemoveAutocompleteEntry,
+                        RemoveAutocompleteEntry)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 bool AutofillManager::OnFormSubmitted(const FormData& form,
                                       const TimeTicks& timestamp) {
   // Let AutoComplete know as well.
   autocomplete_history_manager_.OnFormSubmitted(form);
 
   if (!IsAutofillEnabled())
     return false;
 
-  if (web_contents()->GetBrowserContext()->IsOffTheRecord())
+  if (driver_->GetWebContents()->GetBrowserContext()->IsOffTheRecord())
     return false;
 
   // Don't save data that was submitted through JavaScript.
   if (!form.user_submitted)
     return false;
 
   // Grab a copy of the form data.
   scoped_ptr<FormStructure> submitted_form(
       new FormStructure(form, GetAutocheckoutURLPrefix()));
 
@@ skipping 58 matching lines @@
 
 void AutofillManager::OnFormsSeen(const std::vector<FormData>& forms,
                                   const TimeTicks& timestamp,
                                   autofill::FormsSeenState state) {
   bool is_post_document_load = state == autofill::DYNAMIC_FORMS_SEEN;
   bool has_more_forms = state == autofill::PARTIAL_FORMS_SEEN;
   // If new forms were added via AJAX or DHML, treat as new page.
   if (is_post_document_load)
     Reset();
 
-  RenderViewHost* host = web_contents()->GetRenderViewHost();
+  RenderViewHost* host = driver_->GetWebContents()->GetRenderViewHost();
   if (!host)
     return;
 
   if (!GetAutocheckoutURLPrefix().empty()) {
     // If whitelisted URL, fetch all the forms.
     if (has_more_forms)
       host->Send(new AutofillMsg_GetAllForms(host->GetRoutingID()));
     if (!is_post_document_load) {
       host->Send(
           new AutofillMsg_AutocheckoutSupported(host->GetRoutingID()));
@@ skipping 287 matching lines @@
 
   personal_data_->RemoveByGUID(data_model->guid());
 }
 
 void AutofillManager::RemoveAutocompleteEntry(const base::string16& name,
                                               const base::string16& value) {
   autocomplete_history_manager_.OnRemoveAutocompleteEntry(name, value);
 }
 
 content::WebContents* AutofillManager::GetWebContents() const {
-  return web_contents();
+  return driver_->GetWebContents();
 }
 
 const std::vector<FormStructure*>& AutofillManager::GetFormStructures() {
   return form_structures_.get();
 }
 
 void AutofillManager::ShowRequestAutocompleteDialog(
     const FormData& form,
     const GURL& source_url,
     autofill::DialogType dialog_type,
@@ skipping 51 matching lines @@
 
   base::Callback<void(const FormStructure*, const std::string&)> callback =
       base::Bind(&AutofillManager::ReturnAutocompleteData,
                  weak_ptr_factory_.GetWeakPtr());
   ShowRequestAutocompleteDialog(
       form, frame_url, autofill::DIALOG_TYPE_REQUEST_AUTOCOMPLETE, callback);
 }
 
 void AutofillManager::ReturnAutocompleteResult(
     WebFormElement::AutocompleteResult result, const FormData& form_data) {
-  // web_contents() will be NULL when the interactive autocomplete is closed due
-  // to a tab or browser window closing.
-  if (!web_contents())
+  // driver_->GetWebContents() will be NULL when the interactive autocomplete
+  // is closed due to a tab or browser window closing.
+  if (!driver_->GetWebContents())
     return;
 
-  RenderViewHost* host = web_contents()->GetRenderViewHost();
+  RenderViewHost* host = driver_->GetWebContents()->GetRenderViewHost();
   if (!host)
     return;
 
   host->Send(new AutofillMsg_RequestAutocompleteResult(host->GetRoutingID(),
                                                        result,
                                                        form_data));
 }
 
 void AutofillManager::ReturnAutocompleteData(
     const FormStructure* result,
@@ skipping 12 matching lines @@
   scoped_ptr<autofill::AutocheckoutPageMetaData> page_meta_data(
       new autofill::AutocheckoutPageMetaData());
 
   // Parse and store the server predictions.
   FormStructure::ParseQueryResponse(response_xml,
                                     form_structures_.get(),
                                     page_meta_data.get(),
                                     *metric_logger_);
 
   if (page_meta_data->IsInAutofillableFlow()) {
-    RenderViewHost* host = web_contents()->GetRenderViewHost();
+    RenderViewHost* host = driver_->GetWebContents()->GetRenderViewHost();
     if (host)
       host->Send(new AutofillMsg_AutocheckoutSupported(host->GetRoutingID()));
   }
 
   // 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());
 }
 
 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 (!web_contents())
+  if (!driver_->GetWebContents())
     return std::string();
 
   autofill::autocheckout::WhitelistManager* whitelist_manager =
       manager_delegate_->GetAutocheckoutWhitelistManager();
 
-  return whitelist_manager->GetMatchedURLPrefix(web_contents()->GetURL());
+  return whitelist_manager->GetMatchedURLPrefix(
+      driver_->GetWebContents()->GetURL());
 }
 
 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 = web_contents()->GetRenderViewHost();
+  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));
 }
 
@@ skipping 84 matching lines @@
   user_did_type_ = false;
   user_did_autofill_ = false;
   user_did_edit_autofilled_field_ = false;
   forms_loaded_timestamp_ = TimeTicks();
   initial_interaction_timestamp_ = TimeTicks();
 
   if (external_delegate_)
     external_delegate_->Reset();
 }
 
-AutofillManager::AutofillManager(content::WebContents* web_contents,
+AutofillManager::AutofillManager(AutofillDriver* driver,
                                  autofill::AutofillManagerDelegate* delegate,
                                  PersonalDataManager* personal_data)
-    : content::WebContentsObserver(web_contents),
+    : driver_(driver),
       manager_delegate_(delegate),
       app_locale_("en-US"),
       personal_data_(personal_data),
-      autocomplete_history_manager_(web_contents),
+      autocomplete_history_manager_(driver),
       autocheckout_manager_(this),
       metric_logger_(new AutofillMetrics),
       has_logged_autofill_enabled_(false),
       has_logged_address_suggestions_count_(false),
       did_show_suggestions_(false),
       user_did_type_(false),
       user_did_autofill_(false),
       user_did_edit_autofilled_field_(false),
       external_delegate_(NULL),
       test_delegate_(NULL),
       weak_ptr_factory_(this) {
-  DCHECK(web_contents);
+  DCHECK(driver_);
+  DCHECK(driver_->GetWebContents());
   DCHECK(manager_delegate_);
 }
 
 void AutofillManager::set_metric_logger(const AutofillMetrics* metric_logger) {
   metric_logger_.reset(metric_logger);
 }
 
 bool AutofillManager::GetHost(RenderViewHost** host) const {
   if (!IsAutofillEnabled())
     return false;
 
   // No autofill data to return if the profiles are empty.
   if (personal_data_->GetProfiles().empty() &&
       personal_data_->GetCreditCards().empty()) {
     return false;
   }
 
-  *host = web_contents()->GetRenderViewHost();
+  *host = driver_->GetWebContents()->GetRenderViewHost();
   if (!*host)
     return false;
 
   return true;
 }
 
 bool AutofillManager::GetProfileOrCreditCard(
     int unique_id,
     const AutofillDataModel** data_model,
     size_t* variant) const {
@@ skipping 283 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