importer: Cleanup, remove all remaining using declarations.

chrome/browser/importer/nss_decryptor.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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/importer/nss_decryptor.h"
 
 #include <string>
 #include <vector>
 
+#include "base/base64.h"
 #include "base/scoped_ptr.h"
+#include "base/string_split.h"
+#include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/common/sqlite_utils.h"
+#include "webkit/glue/password_form.h"
 
 #if defined(USE_NSS)
 #include <pk11pub.h>
 #include <pk11sdr.h>
 #endif  // defined(USE_NSS)
 
-#include "base/base64.h"
-#include "base/string_split.h"
-#include "base/string_util.h"
-#include "base/utf_string_conversions.h"
-#include "webkit/glue/password_form.h"
-
-using webkit_glue::PasswordForm;
-
 // This method is based on some Firefox code in
 //   security/manager/ssl/src/nsSDR.cpp
 // The license block is:
 
 /* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
@@ skipping 70 matching lines @@
   return UTF8ToUTF16(plain);
 }
 
 // There are three versions of password files. They store saved user
 // names and passwords.
 // References:
 // http://kb.mozillazine.org/Signons.txt
 // http://kb.mozillazine.org/Signons2.txt
 // http://kb.mozillazine.org/Signons3.txt
 void NSSDecryptor::ParseSignons(const std::string& content,
-                                std::vector<PasswordForm>* forms) {
+                                std::vector<webkit_glue::PasswordForm>* forms) {
   forms->clear();
 
   // Splits the file content into lines.
   std::vector<std::string> lines;
   base::SplitString(content, '\n', &lines);
 
   // The first line is the file version. We skip the unknown versions.
   if (lines.empty())
     return;
   int version;
   if (lines[0] == "#2c")
     version = 1;
   else if (lines[0] == "#2d")
     version = 2;
   else if (lines[0] == "#2e")
     version = 3;
   else
     return;
 
   GURL::Replacements rep;
   rep.ClearQuery();
   rep.ClearRef();
   rep.ClearUsername();
   rep.ClearPassword();
 
   // Reads never-saved list. Domains are stored one per line.
   size_t i;
   for (i = 1; i < lines.size() && lines[i].compare(".") != 0; ++i) {
-    PasswordForm form;
+    webkit_glue::PasswordForm form;
     form.origin = GURL(lines[i]).ReplaceComponents(rep);
     form.signon_realm = form.origin.GetOrigin().spec();
     form.blacklisted_by_user = true;
     forms->push_back(form);
   }
   ++i;
 
   // Reads saved passwords. The information is stored in blocks
   // seperated by lines that only contain a dot. We find a block
   // by the seperator and parse them one by one.
   while (i < lines.size()) {
     size_t begin = i;
     size_t end = i + 1;
     while (end < lines.size() && lines[end].compare(".") != 0)
       ++end;
     i = end + 1;
 
     // A block has at least five lines.
     if (end - begin < 5)
       continue;
 
-    PasswordForm form;
+    webkit_glue::PasswordForm form;
 
     // The first line is the site URL.
     // For HTTP authentication logins, the URL may contain http realm,
     // which will be in bracket:
     //   sitename:8080 (realm)
     GURL url;
     std::string realm;
     const char kRealmBracketBegin[] = " (";
     const char kRealmBracketEnd[] = ")";
     if (lines[begin].find(kRealmBracketBegin) != std::string::npos) {
@@ skipping 67 matching lines @@
   if (s.prepare(db.get(), stmt) != SQLITE_OK)
     return false;
 
   GURL::Replacements rep;
   rep.ClearQuery();
   rep.ClearRef();
   rep.ClearUsername();
   rep.ClearPassword();
   // Read domains for which passwords are never saved.
   while (s.step() == SQLITE_ROW) {
-    PasswordForm form;
+    webkit_glue::PasswordForm form;
     form.origin = GURL(s.column_string(0)).ReplaceComponents(rep);
     form.signon_realm = form.origin.GetOrigin().spec();
     form.blacklisted_by_user = true;
     forms->push_back(form);
   }
 
   SQLStatement s2;
   const char* stmt2 = "SELECT hostname, httpRealm, formSubmitURL, "
                       "usernameField, passwordField, encryptedUsername, "
                       "encryptedPassword FROM moz_logins";
@@ skipping 10 matching lines @@
       if (host.find("://") == std::string::npos)
         host = "http://" + host;
       url = GURL(host);
     } else {
       url = GURL(s2.column_string(0));
     }
     // Skip this row if the URL is not valid.
     if (!url.is_valid())
       continue;
 
-    PasswordForm form;
+    webkit_glue::PasswordForm form;
     form.origin = url.ReplaceComponents(rep);
     form.signon_realm = form.origin.GetOrigin().spec();
     if (!realm.empty())
       form.signon_realm += realm;
     form.ssl_valid = form.origin.SchemeIsSecure();
     // The user name, password and action.
     form.username_element = UTF8ToUTF16(s2.column_string(3));
     form.username_value = Decrypt(s2.column_string(5));
     form.password_element = UTF8ToUTF16(s2.column_string(4));
     form.password_value = Decrypt(s2.column_string(6));
     form.action = GURL(s2.column_string(2)).ReplaceComponents(rep);
     forms->push_back(form);
   }
   return true;
 }