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>
@@ skipping 32 matching lines @@
 #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 {
 
@@ skipping 135 matching lines @@
     content::WebContents* contents) {
   return static_cast<AutofillManager*>(
       contents->GetUserData(kAutofillManagerWebContentsUserDataKey));
 }
 
 AutofillManager::AutofillManager(
     content::WebContents* web_contents,
     autofill::AutofillManagerDelegate* delegate,
     const std::string& app_locale,
     AutofillDownloadManagerState enable_download_manager)
-    : content::WebContentsObserver(web_contents),
+    : web_contents_(web_contents),
       manager_delegate_(delegate),
       app_locale_(app_locale),
       personal_data_(delegate->GetPersonalDataManager()),
       autocomplete_history_manager_(web_contents),
       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),
@@ skipping 85 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 (web_contents_->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 = web_contents_->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 web_contents_;
 }
 
 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
+  // web_contents_ will be NULL when the interactive autocomplete is closed due

[blundell, 2013/06/04 17:30:48]

Hmm, I missed this comment. I had thought that replacing usages of
WebContentsObserver's web_contents() method by holding on to the WebContents*
passed in to the constructor would be a safe change to make, but this comment
makes me pause.

[Evan Stade, 2013/06/04 18:06:36]

so I guess you need to pipe through destruction notifications from the driver?

[blundell, 2013/06/11 15:35:47]

Added in an interface whereby the shared code can obtain the WebContents
instance from the driver, as that seems less fragile.

On 2013/06/04 18:06:36, Evan Stade wrote:

   // to a tab or browser window closing.
-  if (!web_contents())
+  if (!web_contents_)
     return;
 
-  RenderViewHost* host = web_contents()->GetRenderViewHost();
+  RenderViewHost* host = web_contents_->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 = web_contents_->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)
@@ skipping 18 matching lines @@
   if (!IsAutofillEnabled())
     return;
 
   autocheckout_manager_.MaybeShowAutocheckoutBubble(
       source_url,
       ssl_status,
       bounding_box);
 }
 
 std::string AutofillManager::GetAutocheckoutURLPrefix() const {
-  if (!web_contents())
+  if (!web_contents_)
     return std::string();
 
   autofill::autocheckout::WhitelistManager* whitelist_manager =
       manager_delegate_->GetAutocheckoutWhitelistManager();
 
-  return whitelist_manager->GetMatchedURLPrefix(web_contents()->GetURL());
+  return whitelist_manager->GetMatchedURLPrefix(web_contents_->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 = web_contents_->GetRenderViewHost();
   if (!host)
     return;
 
   std::vector<FormDataPredictions> type_predictions;
   FormStructure::GetFieldTypePredictions(forms, &type_predictions);
   host->Send(
       new AutofillMsg_FieldTypePredictionsAvailable(host->GetRoutingID(),
                                                     type_predictions));
 }
 
@@ skipping 64 matching lines @@
   forms_loaded_timestamp_ = TimeTicks();
   initial_interaction_timestamp_ = TimeTicks();
 
   if (external_delegate_)
     external_delegate_->Reset();
 }
 
 AutofillManager::AutofillManager(content::WebContents* web_contents,
                                  autofill::AutofillManagerDelegate* delegate,
                                  PersonalDataManager* personal_data)
-    : content::WebContentsObserver(web_contents),
+    : web_contents_(web_contents),
       manager_delegate_(delegate),
       app_locale_("en-US"),
       personal_data_(personal_data),
       autocomplete_history_manager_(web_contents),
       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),
@@ skipping 13 matching lines @@
 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 = web_contents_->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