Move PasswordForm from //content to //autofill.

chrome/browser/password_manager/password_form_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_PASSWORD_MANAGER_PASSWORD_FORM_MANAGER_H_
 #define CHROME_BROWSER_PASSWORD_MANAGER_PASSWORD_FORM_MANAGER_H_
 
 #include <string>
 #include <vector>
 
 #include "build/build_config.h"
 
 #include "base/stl_util.h"
 #include "chrome/browser/password_manager/password_store_consumer.h"
-#include "content/public/common/password_form.h"
+#include "components/autofill/core/common/password_form.h"
 
 namespace content {
 class WebContents;
 }  // namespace content
 
 class PasswordManager;
 class PasswordStore;
 class Profile;
 
 // Per-password-form-{on-page, dialog} class responsible for interactions
 // between a given form, the per-tab PasswordManager, and the PasswordStore.
 class PasswordFormManager : public PasswordStoreConsumer {
  public:
   // profile contains the link to the PasswordStore and whether we're off
   //           the record
   // password_manager owns this object
   // form_on_page is the form that may be submitted and could need login data.
   // ssl_valid represents the security of the page containing observed_form,
   //           used to filter login results from database.
   PasswordFormManager(Profile* profile,
                       PasswordManager* password_manager,
                       content::WebContents* web_contents,
-                      const content::PasswordForm& observed_form,
+                      const autofill::PasswordForm& observed_form,
                       bool ssl_valid);
   virtual ~PasswordFormManager();
 
   enum ActionMatch {
     ACTION_MATCH_REQUIRED,
     ACTION_MATCH_NOT_REQUIRED
   };
 
   enum OtherPossibleUsernamesAction {
     ALLOW_OTHER_POSSIBLE_USERNAMES,
     IGNORE_OTHER_POSSIBLE_USERNAMES
   };
 
   // Compare basic data of observed_form_ with argument. Only check the action
   // URL when action match is required.
-  bool DoesManage(const content::PasswordForm& form,
+  bool DoesManage(const autofill::PasswordForm& form,
                   ActionMatch action_match) const;
 
   // Retrieves potential matching logins from the database.
   void FetchMatchingLoginsFromPasswordStore();
 
   // Simple state-check to verify whether this object as received a callback
   // from the PasswordStore and completed its matching phase. Note that the
   // callback in question occurs on the same (and only) main thread from which
   // instances of this class are ever used, but it is required since it is
   // conceivable that a user (or ui test) could attempt to submit a login
@@ skipping 22 matching lines @@
   // Checks if the form is a valid password form. Forms which lack either
   // login or password field are not considered valid.
   bool HasValidPasswordForm();
 
   // These functions are used to determine if this form has had it's password
   // auto generated by the browser.
   bool HasGeneratedPassword();
   void SetHasGeneratedPassword();
 
   // Determines if we need to autofill given the results of the query.
-  void OnRequestDone(const std::vector<content::PasswordForm*>& result);
+  void OnRequestDone(const std::vector<autofill::PasswordForm*>& result);
 
   // PasswordStoreConsumer implementation.
   virtual void OnPasswordStoreRequestDone(
       CancelableRequestProvider::Handle handle,
-      const std::vector<content::PasswordForm*>& result) OVERRIDE;
+      const std::vector<autofill::PasswordForm*>& result) OVERRIDE;
   virtual void OnGetPasswordStoreResults(
-      const std::vector<content::PasswordForm*>& results) OVERRIDE;
+      const std::vector<autofill::PasswordForm*>& results) OVERRIDE;
 
   // A user opted to 'never remember' passwords for this form.
   // Blacklist it so that from now on when it is seen we ignore it.
   void PermanentlyBlacklist();
 
   // If the user has submitted observed_form_, provisionally hold on to
   // the submitted credentials until we are told by PasswordManager whether
   // or not the login was successful. |action| describes how we deal with
   // possible usernames. If |action| is ALLOW_OTHER_POSSIBLE_USERNAMES we will
   // treat a possible usernames match as a sign that our original heuristics
   // were wrong and that the user selected the correct username from the
   // Autofill UI.
-  void ProvisionallySave(const content::PasswordForm& credentials,
+  void ProvisionallySave(const autofill::PasswordForm& credentials,
                          OtherPossibleUsernamesAction action);
 
   // Handles save-as-new or update of the form managed by this manager.
   // Note the basic data of updated_credentials must match that of
   // observed_form_ (e.g DoesManage(pending_credentials_) == true).
   void Save();
 
   // Call these if/when we know the form submission worked or failed.
   // These routines are used to update internal statistics ("ActionsTaken").
   void SubmitPassed();
@@ skipping 47 matching lines @@
     kSubmitResultMax
   };
 
   // The maximum number of combinations of the three preceding enums.
   // This is used when recording the actions taken by the form in UMA.
   static const int kMaxNumActionsTaken = kManagerActionMax * kUserActionMax *
                                          kSubmitResultMax;
 
   // Helper for OnPasswordStoreRequestDone to determine whether or not
   // the given result form is worth scoring.
-  bool IgnoreResult(const content::PasswordForm& form) const;
+  bool IgnoreResult(const autofill::PasswordForm& form) const;
 
   // Helper for Save in the case that best_matches.size() == 0, meaning
   // we have no prior record of this form/username/password and the user
   // has opted to 'Save Password'. If |reset_preferred_login| is set,
   // the previously preferred login from |best_matches_| will be reset.
   void SaveAsNewLogin(bool reset_preferred_login);
 
   // Helper for OnPasswordStoreRequestDone to score an individual result
   // against the observed_form_.
-  int ScoreResult(const content::PasswordForm& form) const;
+  int ScoreResult(const autofill::PasswordForm& form) const;
 
   // Helper for Save in the case that best_matches.size() > 0, meaning
   // we have at least one match for this form/username/password. This
   // Updates the form managed by this object, as well as any matching forms
   // that now need to have preferred bit changed, since updated_credentials
   // is now implicitly 'preferred'.
   void UpdateLogin();
 
   // Update all login matches to reflect new preferred state - preferred flag
   // will be reset on all matched logins that different than the current
@@ skipping 10 matching lines @@
   // UMA.
   int GetActionsTaken();
 
   // Informs the renderer that the user has not blacklisted observed_form_ by
   // choosing "never save passwords for this site". This is used by the password
   // generation manager to deside whether to show the password generation icon.
   virtual void SendNotBlacklistedToRenderer();
 
   // Remove possible_usernames that may contains sensitive information and
   // duplicates.
-  void SanitizePossibleUsernames(content::PasswordForm* form);
+  void SanitizePossibleUsernames(autofill::PasswordForm* form);
 
   // Set of PasswordForms from the DB that best match the form
   // being managed by this. Use a map instead of vector, because we most
   // frequently require lookups by username value in IsNewLogin.
-  content::PasswordFormMap best_matches_;
+  autofill::PasswordFormMap best_matches_;
 
   // Cleans up when best_matches_ goes out of scope.
-  STLValueDeleter<content::PasswordFormMap> best_matches_deleter_;
+  STLValueDeleter<autofill::PasswordFormMap> best_matches_deleter_;
 
   // The PasswordForm from the page or dialog managed by this.
-  content::PasswordForm observed_form_;
+  autofill::PasswordForm observed_form_;
 
   // The origin url path of observed_form_ tokenized, for convenience when
   // scoring.
   std::vector<std::string> form_path_tokens_;
 
   // Stores updated credentials when the form was submitted but success is
   // still unknown.
-  content::PasswordForm pending_credentials_;
+  autofill::PasswordForm pending_credentials_;
 
   // Whether pending_credentials_ stores a new login or is an update
   // to an existing one.
   bool is_new_login_;
 
   // Whether this form has an auto generated password.
   bool has_generated_password_;
 
   // Set if the user has selected one of the other possible usernames in
   // |pending_credentials_|.
   string16 selected_username_;
 
   // PasswordManager owning this.
   const PasswordManager* const password_manager_;
 
   // Convenience pointer to entry in best_matches_ that is marked
   // as preferred. This is only allowed to be null if there are no best matches
   // at all, since there will always be one preferred login when there are
   // multiple matches (when first saved, a login is marked preferred).
-  const content::PasswordForm* preferred_match_;
+  const autofill::PasswordForm* preferred_match_;
 
   typedef enum {
     PRE_MATCHING_PHASE,      // Have not yet invoked a GetLogins query to find
                              // matching login information from password store.
     MATCHING_PHASE,          // We've made a GetLogins request, but
                              // haven't received or finished processing result.
     POST_MATCHING_PHASE      // We've queried the DB and processed matching
                              // login results.
   } PasswordFormManagerState;
 
@@ skipping 12 matching lines @@
   // These three fields record the "ActionsTaken" by the browser and
   // the user with this form, and the result. They are combined and
   // recorded in UMA when the manager is destroyed.
   ManagerAction manager_action_;
   UserAction user_action_;
   SubmitResult submit_result_;
 
   DISALLOW_COPY_AND_ASSIGN(PasswordFormManager);
 };
 #endif  // CHROME_BROWSER_PASSWORD_MANAGER_PASSWORD_FORM_MANAGER_H_