Group forms-related files in webkit/glue in a forms/ subdirectory.

chrome/browser/sync/glue/password_model_associator.cc

 // Copyright (c) 2011 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/api/sync_error.h"
 #include "chrome/browser/sync/internal_api/read_node.h"
 #include "chrome/browser/sync/internal_api/read_transaction.h"
 #include "chrome/browser/sync/internal_api/write_node.h"
 #include "chrome/browser/sync/internal_api/write_transaction.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/protocol/password_specifics.pb.h"
 #include "net/base/escape.h"
-#include "webkit/glue/password_form.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 16 matching lines @@
 bool PasswordModelAssociator::AssociateModels(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_glue::PasswordForm*> passwords;
+  std::vector<webkit::forms::PasswordForm*> passwords;
   if (!password_store_->FillAutofillableLogins(&passwords) ||
       !password_store_->FillBlacklistLogins(&passwords)) {
     STLDeleteElements(&passwords);
     error->Reset(FROM_HERE,
                  "Could not get the password entries.",
                  model_type());
     return false;
   }
 
   std::set<std::string> current_passwords;
   PasswordVector new_passwords;
   PasswordVector updated_passwords;
   {
     sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     sync_api::ReadNode password_root(&trans);
     if (!password_root.InitByTagLookup(kPasswordTag)) {
       error->Reset(FROM_HERE,
                    "Server did not create the top-level password node. We "
                    "might be running against an out-of-date server.",
                    model_type());
       return false;
     }
 
-    for (std::vector<webkit_glue::PasswordForm*>::iterator ix =
+    for (std::vector<webkit::forms::PasswordForm*>::iterator ix =
              passwords.begin();
          ix != passwords.end(); ++ix) {
       if (IsAbortPending()) {
         error->Reset(FROM_HERE, "Abort pending", model_type());
         return false;
       }
       std::string tag = MakeTag(**ix);
 
       sync_api::ReadNode node(&trans);
       if (node.InitByClientTagLookup(syncable::PASSWORDS, tag)) {
         const sync_pb::PasswordSpecificsData& password =
             node.GetPasswordSpecifics();
         DCHECK_EQ(tag, MakeTag(password));
 
-        webkit_glue::PasswordForm new_password;
+        webkit::forms::PasswordForm new_password;
 
         if (MergePasswords(password, **ix, &new_password)) {
           sync_api::WriteNode write_node(&trans);
           if (!write_node.InitByClientTagLookup(syncable::PASSWORDS, tag)) {
             STLDeleteElements(&passwords);
             error->Reset(FROM_HERE,
                          "Failed to edit password sync node.",
                          model_type());
             return false;
           }
@@ skipping 30 matching lines @@
         error->Reset(FROM_HERE, "Failed to fetch child node.", model_type());
         return false;
       }
       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_glue::PasswordForm new_password;
+        webkit::forms::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 149 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 true;
 }
 
 // static
 void PasswordModelAssociator::CopyPassword(
         const sync_pb::PasswordSpecificsData& password,
-        webkit_glue::PasswordForm* new_password) {
+        webkit::forms::PasswordForm* new_password) {
   new_password->scheme =
-      static_cast<webkit_glue::PasswordForm::Scheme>(password.scheme());
+      static_cast<webkit::forms::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_glue::PasswordForm& password_form,
-        webkit_glue::PasswordForm* new_password) {
+        const webkit::forms::PasswordForm& password_form,
+        webkit::forms::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_glue::PasswordForm& password_form,
+         const webkit::forms::PasswordForm& password_form,
          sync_api::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_glue::PasswordForm& password) {
+                const webkit::forms::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