Move PasswordForm from //content to //autofill.

components/autofill/content/renderer/password_generation_manager.cc

 // Copyright 2013 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/content/renderer/password_generation_manager.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/autofill/content/renderer/password_form_conversion_utils.h"
 #include "components/autofill/core/common/autofill_messages.h"
 #include "components/autofill/core/common/form_data.h"
+#include "components/autofill/core/common/password_form.h"
 #include "components/autofill/core/common/password_generation_util.h"
 #include "content/public/renderer/render_view.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "third_party/WebKit/public/platform/WebCString.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
@@ skipping 43 matching lines @@
 
   return false;
 }
 
 bool ContainsURL(const std::vector<GURL>& urls, const GURL& url) {
   return std::find(urls.begin(), urls.end(), url) != urls.end();
 }
 
 // Returns true if the |form1| is essentially equal to |form2|.
 bool FormEquals(const autofill::FormData& form1,
-                const content::PasswordForm& form2) {
+                const PasswordForm& form2) {
   // TODO(zysxqn): use more signals than just origin to compare.
   return form1.origin == form2.origin;
 }
 
 bool ContainsForm(const std::vector<autofill::FormData>& forms,
-                  const content::PasswordForm& form) {
+                  const PasswordForm& form) {
   for (std::vector<autofill::FormData>::const_iterator it =
            forms.begin(); it != forms.end(); ++it) {
     if (FormEquals(*it, form))
       return true;
   }
   return false;
 }
 
 }  // namespace
 
@@ skipping 13 matching lines @@
   // hear back from the browser. We only clear this state on main frame load
   // as we don't want subframe loads to clear state that we have recieved from
   // the main frame. Note that we assume there is only one account creation
   // form, but there could be multiple password forms in each frame.
   //
   // TODO(zysxqn): Add stat when local heuristic fires but we don't show the
   // password generation icon.
   if (!frame->parent()) {
     not_blacklisted_password_form_origins_.clear();
     account_creation_forms_.clear();
-    possible_account_creation_form_.reset(new content::PasswordForm());
+    possible_account_creation_form_.reset(new PasswordForm());
     passwords_.clear();
   }
 }
 
 void PasswordGenerationManager::DidFinishLoad(WebKit::WebFrame* frame) {
   // We don't want to generate passwords if the browser won't store or sync
   // them.
   if (!enabled_)
     return;
 
   if (!ShouldAnalyzeDocument(frame->document()))
     return;
 
   WebKit::WebVector<WebKit::WebFormElement> forms;
   frame->document().forms(forms);
   for (size_t i = 0; i < forms.size(); ++i) {
     if (forms[i].isNull())
       continue;
 
     // If we can't get a valid PasswordForm, we skip this form because the
     // the password won't get saved even if we generate it.
-    scoped_ptr<content::PasswordForm> password_form(
+    scoped_ptr<PasswordForm> password_form(
         CreatePasswordForm(forms[i]));
     if (!password_form.get()) {
       DVLOG(2) << "Skipping form as it would not be saved";
       continue;
     }
 
     // Do not generate password for GAIA since it is used to retrieve the
     // generated paswords.
     GURL realm(password_form->signon_realm);
     if (realm == GURL(GaiaUrls::GetInstance()->gaia_login_form_realm()))
@@ skipping 25 matching lines @@
     return false;
   }
 
   return true;
 }
 
 void PasswordGenerationManager::openPasswordGenerator(
     WebKit::WebInputElement& element) {
   WebKit::WebElement button(element.passwordGeneratorButtonElement());
   gfx::Rect rect(button.boundsInViewportSpace());
-  scoped_ptr<content::PasswordForm> password_form(
+  scoped_ptr<PasswordForm> password_form(
       CreatePasswordForm(element.form()));
   // We should not have shown the icon we can't create a valid PasswordForm.
   DCHECK(password_form.get());
 
   Send(new AutofillHostMsg_ShowPasswordGenerationPopup(routing_id(),
                                                        rect,
                                                        element.maxLength(),
                                                        *password_form));
   password_generation::LogPasswordGenerationEvent(
       password_generation::BUBBLE_SHOWN);
 }
 
 bool PasswordGenerationManager::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PasswordGenerationManager, message)
     IPC_MESSAGE_HANDLER(AutofillMsg_FormNotBlacklisted,
                         OnFormNotBlacklisted)
     IPC_MESSAGE_HANDLER(AutofillMsg_GeneratedPasswordAccepted,
                         OnPasswordAccepted)
     IPC_MESSAGE_HANDLER(AutofillMsg_PasswordGenerationEnabled,
                         OnPasswordGenerationEnabled)
     IPC_MESSAGE_HANDLER(AutofillMsg_AccountCreationFormsDetected,
                         OnAccountCreationFormsDetected)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void PasswordGenerationManager::OnFormNotBlacklisted(
-    const content::PasswordForm& form) {
+void PasswordGenerationManager::OnFormNotBlacklisted(const PasswordForm& form) {
   not_blacklisted_password_form_origins_.push_back(form.origin);
   MaybeShowIcon();
 }
 
 void PasswordGenerationManager::OnPasswordAccepted(
     const base::string16& password) {
   for (std::vector<WebKit::WebInputElement>::iterator it = passwords_.begin();
        it != passwords_.end(); ++it) {
     it->setValue(password);
     it->setAutofilled(true);
@@ skipping 36 matching lines @@
     return;
   }
 
   passwords_[0].passwordGeneratorButtonElement().setAttribute("style",
                                                               "display:block");
   password_generation::LogPasswordGenerationEvent(
       password_generation::ICON_SHOWN);
 }
 
 }  // namespace autofill