Move forms/ out of webkit/.

chrome/browser/sync/glue/password_model_associator.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/sync/glue/password_model_associator.h"
 
 #include <set>
 
 #include "base/location.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/password_manager/password_store.h"
 #include "chrome/browser/sync/profile_sync_service.h"
+#include "content/public/common/password_form.h"
 #include "net/base/escape.h"
 #include "sync/api/sync_error.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/protocol/password_specifics.pb.h"
-#include "webkit/forms/password_form.h"
 
 using content::BrowserThread;
 
 namespace browser_sync {
 
 const char kPasswordTag[] = "google_chrome_passwords";
 
 PasswordModelAssociator::PasswordModelAssociator(
     ProfileSyncService* sync_service,
     PasswordStore* password_store,
@@ skipping 19 matching lines @@
   syncer::SyncError error;
   DCHECK(expected_loop_ == MessageLoop::current());
   {
     base::AutoLock lock(abort_association_pending_lock_);
     abort_association_pending_ = false;
   }
 
   // We must not be holding a transaction when we interact with the password
   // store, as it can post tasks to the UI thread which can itself be blocked
   // on our transaction, resulting in deadlock. (http://crbug.com/70658)
-  std::vector<webkit::forms::PasswordForm*> passwords;
+  std::vector<content::PasswordForm*> passwords;
   if (!password_store_->FillAutofillableLogins(&passwords) ||
       !password_store_->FillBlacklistLogins(&passwords)) {
     STLDeleteElements(&passwords);
     return error_handler_->CreateAndUploadError(
         FROM_HERE,
         "Could not get the password entries.",
         model_type());
   }
 
   std::set<std::string> current_passwords;
   PasswordVector new_passwords;
   PasswordVector updated_passwords;
   {
     syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     syncer::ReadNode password_root(&trans);
     if (password_root.InitByTagLookup(kPasswordTag) !=
             syncer::BaseNode::INIT_OK) {
       return error_handler_->CreateAndUploadError(
           FROM_HERE,
           "Server did not create the top-level password node. We "
           "might be running against an out-of-date server.",
           model_type());
     }
 
-    for (std::vector<webkit::forms::PasswordForm*>::iterator ix =
+    for (std::vector<content::PasswordForm*>::iterator ix =
              passwords.begin();
          ix != passwords.end(); ++ix) {
       if (IsAbortPending()) {
         return syncer::SyncError();
       }
       std::string tag = MakeTag(**ix);
 
       syncer::ReadNode node(&trans);
       if (node.InitByClientTagLookup(syncer::PASSWORDS, tag) ==
               syncer::BaseNode::INIT_OK) {
         const sync_pb::PasswordSpecificsData& password =
             node.GetPasswordSpecifics();
         DCHECK_EQ(tag, MakeTag(password));
 
-        webkit::forms::PasswordForm new_password;
+        content::PasswordForm new_password;
 
         if (MergePasswords(password, **ix, &new_password)) {
           syncer::WriteNode write_node(&trans);
           if (write_node.InitByClientTagLookup(syncer::PASSWORDS, tag) !=
                   syncer::BaseNode::INIT_OK) {
             STLDeleteElements(&passwords);
             return error_handler_->CreateAndUploadError(
                 FROM_HERE,
                 "Failed to edit password sync node.",
                 model_type());
@@ skipping 35 matching lines @@
             "Failed to fetch child node.",
             model_type());
       }
       const sync_pb::PasswordSpecificsData& password =
           sync_child_node.GetPasswordSpecifics();
       std::string tag = MakeTag(password);
 
       // The password only exists on the server.  Add it to the local
       // model.
       if (current_passwords.find(tag) == current_passwords.end()) {
-        webkit::forms::PasswordForm new_password;
+        content::PasswordForm new_password;
 
         CopyPassword(password, &new_password);
         Associate(&tag, sync_child_node.GetId());
         new_passwords.push_back(new_password);
       }
 
       sync_child_id = sync_child_node.GetSuccessorId();
     }
   }
 
@@ skipping 153 matching lines @@
     // We have to notify password store observers of the change by hand since
     // we use internal password store interfaces to make changes synchronously.
     password_store_->PostNotifyLoginsChanged();
   }
   return syncer::SyncError();
 }
 
 // static
 void PasswordModelAssociator::CopyPassword(
         const sync_pb::PasswordSpecificsData& password,
-        webkit::forms::PasswordForm* new_password) {
+        content::PasswordForm* new_password) {
   new_password->scheme =
-      static_cast<webkit::forms::PasswordForm::Scheme>(password.scheme());
+      static_cast<content::PasswordForm::Scheme>(password.scheme());
   new_password->signon_realm = password.signon_realm();
   new_password->origin = GURL(password.origin());
   new_password->action = GURL(password.action());
   new_password->username_element =
       UTF8ToUTF16(password.username_element());
   new_password->password_element =
       UTF8ToUTF16(password.password_element());
   new_password->username_value =
       UTF8ToUTF16(password.username_value());
   new_password->password_value =
       UTF8ToUTF16(password.password_value());
   new_password->ssl_valid = password.ssl_valid();
   new_password->preferred = password.preferred();
   new_password->date_created =
       base::Time::FromInternalValue(password.date_created());
   new_password->blacklisted_by_user =
       password.blacklisted();
 }
 
 // static
 bool PasswordModelAssociator::MergePasswords(
         const sync_pb::PasswordSpecificsData& password,
-        const webkit::forms::PasswordForm& password_form,
-        webkit::forms::PasswordForm* new_password) {
+        const content::PasswordForm& password_form,
+        content::PasswordForm* new_password) {
   DCHECK(new_password);
 
   if (password.scheme() == password_form.scheme &&
       password_form.signon_realm == password.signon_realm() &&
       password_form.origin.spec() == password.origin() &&
       password_form.action.spec() == password.action() &&
       UTF16ToUTF8(password_form.username_element) ==
           password.username_element() &&
       UTF16ToUTF8(password_form.password_element) ==
           password.password_element() &&
@@ skipping 14 matching lines @@
     *new_password = password_form;
   } else {
     CopyPassword(password, new_password);
   }
 
   return true;
 }
 
 // static
 void PasswordModelAssociator::WriteToSyncNode(
-         const webkit::forms::PasswordForm& password_form,
+         const content::PasswordForm& password_form,
          syncer::WriteNode* node) {
   sync_pb::PasswordSpecificsData password;
   password.set_scheme(password_form.scheme);
   password.set_signon_realm(password_form.signon_realm);
   password.set_origin(password_form.origin.spec());
   password.set_action(password_form.action.spec());
   password.set_username_element(UTF16ToUTF8(password_form.username_element));
   password.set_password_element(UTF16ToUTF8(password_form.password_element));
   password.set_username_value(UTF16ToUTF8(password_form.username_value));
   password.set_password_value(UTF16ToUTF8(password_form.password_value));
   password.set_ssl_valid(password_form.ssl_valid);
   password.set_preferred(password_form.preferred);
   password.set_date_created(password_form.date_created.ToInternalValue());
   password.set_blacklisted(password_form.blacklisted_by_user);
 
   node->SetPasswordSpecifics(password);
 }
 
 // static
 std::string PasswordModelAssociator::MakeTag(
-                const webkit::forms::PasswordForm& password) {
+                const content::PasswordForm& password) {
   return MakeTag(password.origin.spec(),
                  UTF16ToUTF8(password.username_element),
                  UTF16ToUTF8(password.username_value),
                  UTF16ToUTF8(password.password_element),
                  password.signon_realm);
 }
 
 // static
 std::string PasswordModelAssociator::MakeTag(
                 const sync_pb::PasswordSpecificsData& password) {
@@ skipping 12 matching lines @@
     const std::string& password_element,
     const std::string& signon_realm) {
   return net::EscapePath(origin_url) + "|" +
          net::EscapePath(username_element) + "|" +
          net::EscapePath(username_value) + "|" +
          net::EscapePath(password_element) + "|" +
          net::EscapePath(signon_realm);
 }
 
 }  // namespace browser_sync