Switch AutofillManager to be UserData on WebContents.

chrome/browser/autofill/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 "chrome/browser/autofill/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/string16.h"
 #include "base/string_util.h"
+#include "base/supports_user_data.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/api/infobars/infobar_service.h"
 #include "chrome/browser/api/prefs/pref_service_base.h"
 #include "chrome/browser/api/sync/profile_sync_service_base.h"
 #include "chrome/browser/autofill/autocomplete_history_manager.h"
 #include "chrome/browser/autofill/autofill_cc_infobar_delegate.h"
 #include "chrome/browser/autofill/autofill_external_delegate.h"
 #include "chrome/browser/autofill/autofill_field.h"
 #include "chrome/browser/autofill/autofill_manager_delegate.h"
@@ skipping 31 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/rect.h"
 
 using base::TimeTicks;
 using content::BrowserThread;
 using content::RenderViewHost;
 using switches::kEnableAutofillFeedback;
 
 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 81 matching lines @@
 
     if (matching_types.empty())
       matching_types.insert(UNKNOWN_TYPE);
 
     field->set_possible_types(matching_types);
   }
 }
 
 }  // namespace
 
-AutofillManager::AutofillManager(autofill::AutofillManagerDelegate* delegate,
-                                 TabContents* tab_contents)
-    : content::WebContentsObserver(tab_contents->web_contents()),
+// static
+void AutofillManager::CreateForWebContentsAndDelegate(
+    content::WebContents* contents,
+    autofill::AutofillManagerDelegate* delegate) {
+  if (FromWebContents(contents))
+    return;
+
+  contents->SetUserData(kAutofillManagerWebContentsUserDataKey,
+                        new base::UserDataAdapter<AutofillManager>(
+                            new AutofillManager(contents, delegate)));
+}
+
+// static
+AutofillManager* AutofillManager::FromWebContents(
+    content::WebContents* contents) {
+  return base::UserDataAdapter<AutofillManager>::Get(
+      contents, kAutofillManagerWebContentsUserDataKey);
+}
+
+AutofillManager::AutofillManager(content::WebContents* web_contents,
+                                 autofill::AutofillManagerDelegate* delegate)
+    : content::WebContentsObserver(web_contents),
       manager_delegate_(delegate),
-      tab_contents_(tab_contents),
       personal_data_(NULL),
       download_manager_(delegate->GetBrowserContext(), this),
       disable_download_manager_requests_(false),
       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),
       password_generation_enabled_(false),
       external_delegate_(NULL) {
   // |personal_data_| is NULL when using test-enabled WebContents.
   personal_data_ = PersonalDataManagerFactory::GetForProfile(
       delegate->GetOriginalProfile());
   RegisterWithSyncService();
   registrar_.Init(manager_delegate_->GetPrefs());
   registrar_.Add(prefs::kPasswordGenerationEnabled, this);
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
   notification_registrar_.Add(this,
       chrome::NOTIFICATION_TAB_CONTENTS_DESTROYED,
       content::Source<TabContents>(tab_contents));
 }
 
 AutofillManager::~AutofillManager() {
 }
 
 // static
 void AutofillManager::RegisterUserPrefs(PrefServiceBase* prefs) {
@@ skipping 139 matching lines @@
                         OnSetDataList)
     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.
-  AutocompleteHistoryManager::FromWebContents(tab_contents_->web_contents())->
+  AutocompleteHistoryManager::FromWebContents(web_contents())->
       OnFormSubmitted(form);
 
   if (!IsAutofillEnabled())
     return false;
 
   if (web_contents()->GetBrowserContext()->IsOffTheRecord())
     return false;
 
   // Don't save data that was submitted through JavaScript.
   if (!form.user_submitted)
@@ skipping 182 matching lines @@
           metric_logger_->LogAddressSuggestionsCount(values.size());
           has_logged_address_suggestions_count_ = true;
         }
       }
     }
   }
 
   // Add the results from AutoComplete.  They come back asynchronously, so we
   // hand off what we generated and they will send the results back to the
   // renderer.
-  AutocompleteHistoryManager::FromWebContents(tab_contents_->web_contents())->
+  AutocompleteHistoryManager::FromWebContents(web_contents())->
       OnGetAutocompleteSuggestions(
           query_id, field.name, field.value, values, labels, icons, unique_ids);
 }
 
 void AutofillManager::OnFillAutofillFormData(int query_id,
                                              const FormData& form,
                                              const FormFieldData& field,
                                              int unique_id) {
   const std::vector<AutofillProfile*>& profiles = personal_data_->profiles();
   const std::vector<CreditCard*>& credit_cards = personal_data_->credit_cards();
@@ skipping 305 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(autofill::AutofillManagerDelegate* delegate,
-                                 TabContents* tab_contents,
+AutofillManager::AutofillManager(content::WebContents* web_contents,
+                                 autofill::AutofillManagerDelegate* delegate,
                                  PersonalDataManager* personal_data)
-    : content::WebContentsObserver(tab_contents->web_contents()),
+    : content::WebContentsObserver(web_contents),
       manager_delegate_(delegate),
-      tab_contents_(tab_contents),
       personal_data_(personal_data),
       download_manager_(delegate->GetBrowserContext(), this),
       disable_download_manager_requests_(true),
       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),
       password_generation_enabled_(false),
       external_delegate_(NULL) {
-  DCHECK(tab_contents_);
+  DCHECK(web_contents);
   DCHECK(manager_delegate_);
   RegisterWithSyncService();
   // Test code doesn't need registrar_.
 }
 
 void AutofillManager::set_metric_logger(const AutofillMetrics* metric_logger) {
   metric_logger_.reset(metric_logger);
 }
 
 bool AutofillManager::GetHost(const std::vector<AutofillProfile*>& profiles,
@@ skipping 474 matching lines @@
   *profile_guid = IDToGUID(profile_id);
 }
 
 void AutofillManager::UpdateInitialInteractionTimestamp(
     const TimeTicks& interaction_timestamp) {
   if (initial_interaction_timestamp_.is_null() ||
       interaction_timestamp < initial_interaction_timestamp_) {
     initial_interaction_timestamp_ = interaction_timestamp;
   }
 }