Add chrome to the repository.

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@15 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 749 insertions, 0 deletions

diff --git a/chrome/browser/firefox_importer_utils.cc b/chrome/browser/firefox_importer_utils.cc
new file mode 100644
index 0000000..26fb2425
--- /dev/null
+++ b/chrome/browser/firefox_importer_utils.cc
@@ -0,0 +1,749 @@
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "chrome/browser/firefox_importer_utils.h"
+
+#include <shlobj.h>
+
+#include "base/file_util.h"
+#include "base/logging.h"
+#include "base/registry.h"
+#include "base/string_util.h"
+#include "base/time.h"
+#include "chrome/browser/template_url.h"
+#include "chrome/browser/template_url_model.h"
+#include "chrome/browser/template_url_parser.h"
+#include "chrome/common/win_util.h"
+#include "net/base/base64.h"
+
+namespace {
+
+// NOTE: Keep these in order since we need test all those paths according
+// to priority. For example. One machine has multiple users. One non-admin
+// user installs Firefox 2, which causes there is a Firefox2 entry under HKCU.
+// One admin user installs Firefox 3, which causes there is a Firefox 3 entry
+// under HKLM. So when the non-admin user log in, we should deal with Firefox 2
+// related data instead of Firefox 3.
+static const HKEY kFireFoxRegistryPaths[] = {
+  HKEY_CURRENT_USER,
+  HKEY_LOCAL_MACHINE
+};
+
+// FirefoxURLParameterFilter is used to remove parameter mentioning Firefox from
+// the search URL when importing search engines.
+class FirefoxURLParameterFilter : public TemplateURLParser::ParameterFilter {
+ public:
+  FirefoxURLParameterFilter() { }
+  ~FirefoxURLParameterFilter() { }
+
+  // TemplateURLParser::ParameterFilter method.
+  virtual bool KeepParameter(const std::string& key,
+                             const std::string& value) {
+    std::string low_value = StringToLowerASCII(value);
+    if (low_value.find("mozilla") != -1 || low_value.find("firefox") != -1 ||
+        low_value.find("moz:") != -1 )
+      return false;
+    return true;
+  }
+
+ private:
+  DISALLOW_EVIL_CONSTRUCTORS(FirefoxURLParameterFilter);
+};
+
+typedef BOOL (WINAPI* SetDllDirectoryFunc)(LPCTSTR lpPathName);
+
+// A helper class whose destructor calls SetDllDirectory(NULL) to undo the
+// effects of a previous SetDllDirectory call.
+class SetDllDirectoryCaller {
+ public:
+  explicit SetDllDirectoryCaller() : func_(NULL) { }
+
+  ~SetDllDirectoryCaller() {
+    if (func_)
+      func_(NULL);
+  }
+
+  // Sets the SetDllDirectory function pointer to activates this object.
+  void set_func(SetDllDirectoryFunc func) { func_ = func; }
+
+ private:
+  SetDllDirectoryFunc func_;
+};
+
+}  // namespace
+
+int GetCurrentFirefoxMajorVersion() {
+  TCHAR ver_buffer[128];
+  DWORD ver_buffer_length = sizeof(ver_buffer);
+  // When installing Firefox with admin account, the product keys will be
+  // written under HKLM\Mozilla. Otherwise it the keys will be written under
+  // HKCU\Mozilla.
+  for (int i = 0; i < arraysize(kFireFoxRegistryPaths); ++i) {
+    bool result = ReadFromRegistry(kFireFoxRegistryPaths[i],
+        L"Software\\Mozilla\\Mozilla Firefox",
+        L"CurrentVersion", ver_buffer, &ver_buffer_length);
+    if (!result)
+      continue;
+    return _wtoi(ver_buffer);
+  }
+  return 0;
+}
+
+std::wstring GetProfilesINI() {
+  // The default location of the profile folder containing user data is
+  // under the "Application Data" folder in Windows XP.
+  std::wstring ini_file;
+  wchar_t buffer[MAX_PATH] = {0};
+  if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_APPDATA, NULL,
+                                SHGFP_TYPE_CURRENT, buffer))) {
+    ini_file = buffer;
+    file_util::AppendToPath(&ini_file, L"Mozilla\\Firefox\\profiles.ini");
+  }
+  if (!file_util::PathExists(ini_file))
+    ini_file.clear();
+
+  return ini_file;
+}
+
+std::wstring GetFirefoxInstallPath() {
+  // Detects the path that Firefox is installed in.
+  std::wstring registry_path = L"Software\\Mozilla\\Mozilla Firefox";
+  TCHAR buffer[MAX_PATH];
+  DWORD buffer_length = sizeof(buffer);
+  bool result;
+  result = ReadFromRegistry(HKEY_LOCAL_MACHINE, registry_path.c_str(),
+                            L"CurrentVersion", buffer, &buffer_length);
+  if (!result)
+    return std::wstring();
+  registry_path += L"\\" + std::wstring(buffer) + L"\\Main";
+  buffer_length = sizeof(buffer);
+  result = ReadFromRegistry(HKEY_LOCAL_MACHINE, registry_path.c_str(),
+                            L"Install Directory", buffer, &buffer_length);
+  if (!result)
+    return std::wstring();
+  return buffer;
+}
+
+void ParseProfileINI(std::wstring file, DictionaryValue* root) {
+  // Reads the whole INI file.
+  std::string content;
+  file_util::ReadFileToString(file, &content);
+  ReplaceSubstringsAfterOffset(&content, 0, "\r\n", "\n");
+  std::vector<std::string> lines;
+  SplitString(content, '\n', &lines);
+
+  // Parses the file.
+  root->Clear();
+  std::wstring current_section;
+  for (size_t i = 0; i < lines.size(); ++i) {
+    std::wstring line = UTF8ToWide(lines[i]);
+    if (line.empty()) {
+      // Skips the empty line.
+      continue;
+    }
+    if (line[0] == L'#' || line[0] == L';') {
+      // This line is a comment.
+      continue;
+    }
+    if (line[0] == L'[') {
+      // It is a section header.
+      current_section = line.substr(1);
+      size_t end = current_section.rfind(L']');
+      if (end != std::wstring::npos)
+        current_section.erase(end);
+    } else {
+      std::wstring key, value;
+      size_t equal = line.find(L'=');
+      if (equal != std::wstring::npos) {
+        key = line.substr(0, equal);
+        value = line.substr(equal + 1);
+        // Checks whether the section and key contain a '.' character.
+        // Those sections and keys break DictionaryValue's path format,
+        // so we discard them.
+        if (current_section.find(L'.') == std::wstring::npos &&
+            key.find(L'.') == std::wstring::npos)
+          root->SetString(current_section + L"." + key, value);
+      }
+    }
+  }
+}
+
+bool CanImportURL(const GURL& url) {
+  const char* kInvalidSchemes[] = {"wyciwyg", "place", "about", "chrome"};
+
+  // The URL is not valid.
+  if (!url.is_valid())
+    return false;
+
+  // Filter out the URLs with unsupported schemes.
+  for (int i = 0; i < arraysize(kInvalidSchemes); ++i) {
+    if (url.SchemeIs(kInvalidSchemes[i]))
+      return false;
+  }
+
+  return true;
+}
+
+void ParseSearchEnginesFromXMLFiles(const std::vector<std::wstring>& xml_files,
+                                    std::vector<TemplateURL*>* search_engines) {
+  DCHECK(search_engines);
+
+  std::map<std::wstring, TemplateURL*> search_engine_for_url;
+  std::string content;
+  // The first XML file represents the default search engine in Firefox 3, so we
+  // need to keep it on top of the list.
+  TemplateURL* default_turl = NULL;
+  for (std::vector<std::wstring>::const_iterator iter = xml_files.begin();
+       iter != xml_files.end(); ++iter) {
+    file_util::ReadFileToString(*iter, &content);
+    TemplateURL* template_url = new TemplateURL();
+    FirefoxURLParameterFilter param_filter;
+    if (TemplateURLParser::Parse(
+        reinterpret_cast<const unsigned char*>(content.data()),
+        content.length(), &param_filter, template_url) &&
+        template_url->url()) {
+      std::wstring url = template_url->url()->url();
+      std::map<std::wstring, TemplateURL*>::iterator iter =
+          search_engine_for_url.find(url);
+      if (iter != search_engine_for_url.end()) {
+        // We have already found a search engine with the same URL.  We give
+        // priority to the latest one found, as GetSearchEnginesXMLFiles()
+        // returns a vector with first Firefox default search engines and then
+        // the user's ones.  We want to give priority to the user ones.
+        delete iter->second;
+        search_engine_for_url.erase(iter);
+      }
+      // Give this a keyword to facilitate tab-to-search, if possible.
+      template_url->set_keyword(TemplateURLModel::GenerateKeyword(GURL(url),
+                                                                  false));
+      template_url->set_show_in_default_list(true);
+      search_engine_for_url[url] = template_url;
+      if (!default_turl)
+        default_turl = template_url;
+    } else {
+      delete template_url;
+    }
+    content.clear();
+  }
+
+  // Put the results in the |search_engines| vector.
+  std::map<std::wstring, TemplateURL*>::iterator t_iter;
+  for (t_iter = search_engine_for_url.begin();
+       t_iter != search_engine_for_url.end(); ++t_iter) {
+    if (t_iter->second == default_turl)
+      search_engines->insert(search_engines->begin(), default_turl);
+    else
+      search_engines->push_back(t_iter->second);
+  }
+}
+
+bool ReadPrefFile(const std::wstring& path_name,
+                  const std::wstring& file_name,
+                  std::string* content) {
+  if (content == NULL)
+    return false;
+
+  std::wstring file = path_name;
+  file_util::AppendToPath(&file, file_name.c_str());
+
+  file_util::ReadFileToString(file, content);
+
+  if (content->empty()) {
+    NOTREACHED() << L"Firefox preference file " << file_name.c_str()
+                 << L" is empty.";
+    return false;
+  }
+
+  return true;
+}
+
+std::string ReadBrowserConfigProp(const std::wstring& app_path,
+                                  const std::string& pref_key) {
+  std::string content;
+  if (!ReadPrefFile(app_path, L"browserconfig.properties", &content))
+    return "";
+
+  // This file has the syntax: key=value.
+  size_t prop_index = content.find(pref_key + "=");
+  if (prop_index == -1)
+    return "";
+
+  size_t start = prop_index + pref_key.length();
+  size_t stop = -1;
+  if (start != -1)
+    stop = content.find("\n", start + 1);
+
+  if (start == -1 || stop == -1 || (start == stop)) {
+    NOTREACHED() << "Firefox property " << pref_key << " could not be parsed.";
+    return "";
+  }
+
+  return content.substr(start + 1, stop - start - 1);
+}
+
+std::string ReadPrefsJsValue(const std::wstring& profile_path,
+                             const std::string& pref_key) {
+  std::string content;
+  if (!ReadPrefFile(profile_path, L"prefs.js", &content))
+    return "";
+
+  // This file has the syntax: user_pref("key", value);
+  std::string search_for = std::string("user_pref(\"") + pref_key +
+                           std::string("\", ");
+  size_t prop_index = content.find(search_for);
+  if (prop_index == -1)
+    return "";
+
+  size_t start = prop_index + search_for.length();
+  size_t stop = -1;
+  if (start != -1)
+    stop = content.find(")", start + 1);
+
+  if (start == -1 || stop == -1) {
+    NOTREACHED() << "Firefox property " << pref_key << " could not be parsed.";
+    return "";
+  }
+
+  // String values have double quotes we don't need to return to the caller.
+  if (content[start] == '\"' && content[stop - 1] == '\"') {
+    ++start;
+    --stop;
+  }
+
+  return content.substr(start, stop - start);
+}
+
+int GetFirefoxDefaultSearchEngineIndex(
+    const std::vector<TemplateURL*>& search_engines,
+    const std::wstring& profile_path) {
+  // The default search engine is contained in the file prefs.js found in the
+  // profile directory.
+  // It is the "browser.search.selectedEngine" property.
+  if (search_engines.empty())
+    return -1;
+
+  std::wstring default_se_name = UTF8ToWide(
+      ReadPrefsJsValue(profile_path, "browser.search.selectedEngine"));
+
+  int default_se_index = -1;
+  for (std::vector<TemplateURL*>::const_iterator iter = search_engines.begin();
+       iter != search_engines.end(); ++iter) {
+    if (default_se_name == (*iter)->short_name()) {
+      default_se_index = static_cast<int>(iter - search_engines.begin());
+      break;
+    }
+  }
+  if (default_se_index == -1) {
+    NOTREACHED() <<
+        "Firefox default search engine not found in search engine list";
+  }
+
+  return default_se_index;
+}
+
+GURL GetHomepage(const std::wstring& profile_path) {
+  std::string home_page_list =
+      ReadPrefsJsValue(profile_path, "browser.startup.homepage");
+
+  size_t seperator = home_page_list.find_first_of('|');
+  if (seperator == std::string::npos)
+    return GURL(home_page_list);
+
+  return GURL(home_page_list.substr(0, seperator));
+}
+
+bool IsDefaultHomepage(const GURL& homepage,
+                       const std::wstring& app_path) {
+  if (!homepage.is_valid())
+    return false;
+
+  std::string default_homepages =
+      ReadBrowserConfigProp(app_path, "browser.startup.homepage");
+
+  size_t seperator = default_homepages.find_first_of('|');
+  if (seperator == std::string::npos)
+    return homepage.spec() == GURL(default_homepages).spec();
+
+  // Crack the string into separate homepage urls.
+  std::vector<std::string> urls;
+  SplitString(default_homepages, '|', &urls);
+
+  for (size_t i = 0; i < urls.size(); ++i) {
+    if (homepage.spec() == GURL(urls[i]).spec())
+      return true;
+  }
+
+  return false;
+}
+
+// class NSSDecryptor.
+
+// static
+const wchar_t NSSDecryptor::kNSS3Library[] = L"nss3.dll";
+const wchar_t NSSDecryptor::kSoftokn3Library[] = L"softokn3.dll";
+const wchar_t NSSDecryptor::kPLDS4Library[] = L"plds4.dll";
+const wchar_t NSSDecryptor::kNSPR4Library[] = L"nspr4.dll";
+
+NSSDecryptor::NSSDecryptor()
+    : NSS_Init(NULL), NSS_Shutdown(NULL), PK11_GetInternalKeySlot(NULL),
+      PK11_CheckUserPassword(NULL), PK11_FreeSlot(NULL),
+      PK11_Authenticate(NULL), PK11SDR_Decrypt(NULL), SECITEM_FreeItem(NULL),
+      PL_ArenaFinish(NULL), PR_Cleanup(NULL),
+      nss3_dll_(NULL), softokn3_dll_(NULL),
+      is_nss_initialized_(false) {
+}
+
+NSSDecryptor::~NSSDecryptor() {
+  Free();
+}
+
+bool NSSDecryptor::Init(const std::wstring& dll_path,
+                        const std::wstring& db_path) {
+  // We call SetDllDirectory to work around a Purify bug (GetModuleHandle
+  // fails inside Purify under certain conditions).  SetDllDirectory only
+  // exists on Windows XP SP1 or later, so we look up its address at run time.
+  HMODULE kernel32_dll = GetModuleHandle(L"kernel32.dll");
+  if (kernel32_dll == NULL)
+    return false;
+  SetDllDirectoryFunc set_dll_directory =
+      (SetDllDirectoryFunc)GetProcAddress(kernel32_dll, "SetDllDirectoryW");
+  SetDllDirectoryCaller caller;
+
+  if (set_dll_directory != NULL) {
+    if (!set_dll_directory(dll_path.c_str()))
+      return false;
+    caller.set_func(set_dll_directory);
+    nss3_dll_ = LoadLibrary(kNSS3Library);
+    if (nss3_dll_ == NULL)
+      return false;
+  } else {
+    // Fall back on LoadLibraryEx if SetDllDirectory isn't available.  We
+    // actually prefer this method because it doesn't change the DLL search
+    // path, which is a process-wide property.
+    std::wstring path = dll_path;
+    file_util::AppendToPath(&path, kNSS3Library);
+    nss3_dll_ = LoadLibraryEx(path.c_str(), NULL,
+                              LOAD_WITH_ALTERED_SEARCH_PATH);
+    if (nss3_dll_ == NULL)
+      return false;
+
+    // Firefox 2 uses NSS 3.11.  Firefox 3 uses NSS 3.12.  NSS 3.12 has two
+    // changes in its DLLs:
+    // 1. nss3.dll is not linked with softokn3.dll at build time, but rather
+    //    loads softokn3.dll using LoadLibrary in NSS_Init.
+    // 2. softokn3.dll has a new dependency sqlite3.dll.
+    // NSS_Init's LoadLibrary call has trouble finding sqlite3.dll.  To help
+    // it out, we preload softokn3.dll using LoadLibraryEx with the
+    // LOAD_WITH_ALTERED_SEARCH_PATH flag.  This helps because LoadLibrary
+    // doesn't load a DLL again if it's already loaded.  This workaround is
+    // harmless for NSS 3.11.
+    path = dll_path;
+    file_util::AppendToPath(&path, kSoftokn3Library);
+    softokn3_dll_ = LoadLibraryEx(path.c_str(), NULL,
+                                  LOAD_WITH_ALTERED_SEARCH_PATH);
+    if (softokn3_dll_ == NULL) {
+      Free();
+      return false;
+    }
+  }
+
+  // NSPR DLLs are already loaded now.
+  HMODULE plds4_dll = GetModuleHandle(kPLDS4Library);
+  HMODULE nspr4_dll = GetModuleHandle(kNSPR4Library);
+  if (plds4_dll == NULL || nspr4_dll == NULL) {
+    Free();
+    return false;
+  }
+
+  // Gets the function address.
+  NSS_Init = (NSSInitFunc)GetProcAddress(nss3_dll_, "NSS_Init");
+  NSS_Shutdown = (NSSShutdownFunc)GetProcAddress(nss3_dll_, "NSS_Shutdown");
+  PK11_GetInternalKeySlot = (PK11GetInternalKeySlotFunc)
+      GetProcAddress(nss3_dll_, "PK11_GetInternalKeySlot");
+  PK11_FreeSlot = (PK11FreeSlotFunc)GetProcAddress(nss3_dll_, "PK11_FreeSlot");
+  PK11_Authenticate = (PK11AuthenticateFunc)
+      GetProcAddress(nss3_dll_, "PK11_Authenticate");
+  PK11SDR_Decrypt = (PK11SDRDecryptFunc)
+      GetProcAddress(nss3_dll_, "PK11SDR_Decrypt");
+  SECITEM_FreeItem = (SECITEMFreeItemFunc)
+      GetProcAddress(nss3_dll_, "SECITEM_FreeItem");
+  PL_ArenaFinish = (PLArenaFinishFunc)
+      GetProcAddress(plds4_dll, "PL_ArenaFinish");
+  PR_Cleanup = (PRCleanupFunc)GetProcAddress(nspr4_dll, "PR_Cleanup");
+
+  if (NSS_Init == NULL || NSS_Shutdown == NULL ||
+      PK11_GetInternalKeySlot == NULL || PK11_FreeSlot == NULL ||
+      PK11_Authenticate == NULL || PK11SDR_Decrypt == NULL ||
+      SECITEM_FreeItem == NULL || PL_ArenaFinish == NULL ||
+      PR_Cleanup == NULL) {
+    Free();
+    return false;
+  }
+
+  SECStatus result = NSS_Init(WideToNativeMB(db_path).c_str());
+  if (result != SECSuccess) {
+    Free();
+    return false;
+  }
+
+  is_nss_initialized_ = true;
+  return true;
+}
+
+void NSSDecryptor::Free() {
+  if (is_nss_initialized_) {
+    NSS_Shutdown();
+    PL_ArenaFinish();
+    PR_Cleanup();
+    is_nss_initialized_ = false;
+  }
+  if (softokn3_dll_ != NULL)
+    FreeLibrary(softokn3_dll_);
+  softokn3_dll_ = NULL;
+  if (nss3_dll_ != NULL)
+    FreeLibrary(nss3_dll_);
+  nss3_dll_ = NULL;
+  NSS_Init = NULL;
+  NSS_Shutdown = NULL;
+  PK11_GetInternalKeySlot = NULL;
+  PK11_FreeSlot = NULL;
+  PK11_Authenticate = NULL;
+  PK11SDR_Decrypt = NULL;
+  SECITEM_FreeItem = NULL;
+  PL_ArenaFinish = NULL;
+  PR_Cleanup = NULL;
+}
+
+// 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
+* http://www.mozilla.org/MPL/
+*
+* Software distributed under the License is distributed on an "AS IS" basis,
+* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+* for the specific language governing rights and limitations under the
+* License.
+*
+* The Original Code is the Netscape security libraries.
+*
+* The Initial Developer of the Original Code is
+* Netscape Communications Corporation.
+* Portions created by the Initial Developer are Copyright (C) 1994-2000
+* the Initial Developer. All Rights Reserved.
+*
+* Contributor(s):
+*
+* Alternatively, the contents of this file may be used under the terms of
+* either the GNU General Public License Version 2 or later (the "GPL"), or
+* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+* in which case the provisions of the GPL or the LGPL are applicable instead
+* of those above. If you wish to allow use of your version of this file only
+* under the terms of either the GPL or the LGPL, and not to allow others to
+* use your version of this file under the terms of the MPL, indicate your
+* decision by deleting the provisions above and replace them with the notice
+* and other provisions required by the GPL or the LGPL. If you do not delete
+* the provisions above, a recipient may use your version of this file under
+* the terms of any one of the MPL, the GPL or the LGPL.
+*
+* ***** END LICENSE BLOCK ***** */
+
+std::wstring NSSDecryptor::Decrypt(const std::string& crypt) const {
+  // Do nothing if NSS is not loaded.
+  if (!nss3_dll_)
+    return std::wstring();
+
+  std::string plain;
+
+  // The old style password is encoded in base64. They are identified
+  // by a leading '~'. Otherwise, we should decrypt the text.
+  if (crypt[0] != '~') {
+    std::string decoded_data;
+    Base64Decode(crypt, &decoded_data);
+    PK11SlotInfo* slot = NULL;
+    slot = PK11_GetInternalKeySlot();
+    SECStatus result = PK11_Authenticate(slot, PR_TRUE, NULL);
+    if (result != SECSuccess) {
+      PK11_FreeSlot(slot);
+      return std::wstring();
+    }
+
+    SECItem request;
+    request.data = reinterpret_cast<unsigned char*>(
+        const_cast<char*>(decoded_data.data()));
+    request.len = static_cast<unsigned int>(decoded_data.size());
+    SECItem reply;
+    reply.data = NULL;
+    reply.len = 0;
+    result = PK11SDR_Decrypt(&request, &reply, NULL);
+    if (result == SECSuccess)
+      plain.assign(reinterpret_cast<char*>(reply.data), reply.len);
+
+    SECITEM_FreeItem(&reply, PR_FALSE);
+    PK11_FreeSlot(slot);
+  } else {
+    // Deletes the leading '~' before decoding.
+    Base64Decode(crypt.substr(1), &plain);
+  }
+
+  return UTF8ToWide(plain);
+}
+
+// There are three versions of password filess. 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) {
+  forms->clear();
+
+  // Splits the file content into lines.
+  std::vector<std::string> lines;
+  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;
+    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;
+
+    // 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) {
+      // In this case, the scheme may not exsit. We assume that the
+      // scheme is HTTP.
+      if (lines[begin].find("://") == std::string::npos)
+        lines[begin] = "http://" + lines[begin];
+
+      size_t start = lines[begin].find(kRealmBracketBegin);
+      url = GURL(lines[begin].substr(0, start));
+
+      start += std::string(kRealmBracketBegin).size();
+      size_t end = lines[begin].rfind(kRealmBracketEnd);
+      realm = lines[begin].substr(start, end - start);
+    } else {
+      // Don't have http realm. It is the URL that the following passwords
+      // belong to.
+      url = GURL(lines[begin]);
+    }
+    // Skips this block if the URL is not valid.
+    if (!url.is_valid())
+      continue;
+    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();
+    ++begin;
+
+    // There may be multiple username/password pairs for this site.
+    // In this case, they are saved in one block without a seperated
+    // line (contains a dot).
+    while (begin + 4 < end) {
+      // The user name.
+      form.username_element = UTF8ToWide(lines[begin++]);
+      form.username_value = Decrypt(lines[begin++]);
+      // The element name has a leading '*'.
+      if (lines[begin].at(0) == '*') {
+        form.password_element = UTF8ToWide(lines[begin++].substr(1));
+        form.password_value = Decrypt(lines[begin++]);
+      } else {
+        // Maybe the file is bad, we skip to next block.
+        break;
+      }
+      // The action attribute from the form element. This line exists
+      // in versin 2 or above.
+      if (version >= 2) {
+        if (begin < end)
+          form.action = GURL(lines[begin]).ReplaceComponents(rep);
+        ++begin;
+      }
+      // Version 3 has an extra line for further use.
+      if (version == 3) {
+        ++begin;
+      }
+
+      forms->push_back(form);
+    }
+  }
+}