Make firefox_importer_utils.cc compile on Posix.

chrome/browser/importer/firefox_importer_utils.cc

 // Copyright (c) 2006-2008 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/firefox_importer_utils.h"
 
 #include <algorithm>
+
+#if defined(OS_WIN)
 #include <shlobj.h>
+#endif
 
 #include "base/file_util.h"
 #include "base/logging.h"
-#include "base/registry.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/time.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/search_engines/template_url_parser.h"
-#include "chrome/common/win_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/base64.h"
 
+#if defined(OS_WIN)
+#include "base/registry.h"
+#include "chrome/common/win_util.h"
+#endif
+
 namespace {
 
+#if defined(OS_WIN)
 // 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
 };
+#endif
 
 // 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 )
+    if (low_value.find("mozilla") != std::string::npos ||
+        low_value.find("firefox") != std::string::npos ||
+        low_value.find("moz:") != std::string::npos )
       return false;
     return true;
   }
 
  private:
   DISALLOW_EVIL_CONSTRUCTORS(FirefoxURLParameterFilter);
 };
 
+#if defined(OS_WIN)
 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_;
 };
+#endif
 
 }  // namespace
 
 int GetCurrentFirefoxMajorVersion() {
+#if defined(OS_WIN)
   TCHAR ver_buffer[128];
   DWORD ver_buffer_length = sizeof(ver_buffer);
   int highest_version = 0;
   // 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;
     highest_version = std::max(highest_version, _wtoi(ver_buffer));
   }
   return highest_version;
+#else
+  // TODO(port): Read in firefox configuration.
+  NOTIMPLEMENTED();
+  return 0;
+#endif
 }
 
+#if defined(OS_WIN)
 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();
@@ skipping 23 matching lines @@
         // 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);
       }
     }
   }
 }
+#endif
+
+std::wstring GetFirefoxInstallPath() {
+#if defined(OS_WIN)
+  // 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;
+#else
+  // TODO(port): Load firefox configuration.
+  NOTIMPLEMENTED();
+  return std::wstring();
+#endif
+}
 
 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) {
+  for (size_t 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);
@@ skipping 17 matching lines @@
           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_keyword(
+              TemplateURLModel::GenerateKeyword(GURL(WideToUTF8(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();
   }
 
@@ skipping 29 matching lines @@
 }
 
 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)
+  if (prop_index == std::string::npos)
     return "";
 
   size_t start = prop_index + pref_key.length();
-  size_t stop = -1;
-  if (start != -1)
+  size_t stop = std::string::npos;
+  if (start != std::string::npos)
     stop = content.find("\n", start + 1);
 
-  if (start == -1 || stop == -1 || (start == stop)) {
+  if (start == std::string::npos ||
+      stop == std::string::npos || (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)
+  if (prop_index == std::string::npos)
     return "";
 
   size_t start = prop_index + search_for.length();
-  size_t stop = -1;
-  if (start != -1)
+  size_t stop = std::string::npos;
+  if (start != std::string::npos)
     stop = content.find(")", start + 1);
 
-  if (start == -1 || stop == -1) {
+  if (start == std::string::npos || stop == std::string::npos) {
     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;
   }
 
@@ skipping 77 matching lines @@
 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),
+#if defined(OS_WIN)
       nss3_dll_(NULL), softokn3_dll_(NULL),
+#endif
       is_nss_initialized_(false) {
 }
 
 NSSDecryptor::~NSSDecryptor() {
   Free();
 }
 
 bool NSSDecryptor::Init(const std::wstring& dll_path,
                         const std::wstring& db_path) {
+#if defined(OS_WIN)
   // 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;
 
@@ skipping 69 matching lines @@
   }
 
   SECStatus result = NSS_Init(base::SysWideToNativeMB(db_path).c_str());
   if (result != SECSuccess) {
     Free();
     return false;
   }
 
   is_nss_initialized_ = true;
   return true;
+#else
+  // TODO(port): Load NSS.
+  NOTIMPLEMENTED();
+  return false;
+#endif
 }
 
 void NSSDecryptor::Free() {
   if (is_nss_initialized_) {
     NSS_Shutdown();
     PL_ArenaFinish();
     PR_Cleanup();
     is_nss_initialized_ = false;
   }
+#if defined(OS_WIN)
   if (softokn3_dll_ != NULL)
     FreeLibrary(softokn3_dll_);
   softokn3_dll_ = NULL;
   if (nss3_dll_ != NULL)
     FreeLibrary(nss3_dll_);
   nss3_dll_ = NULL;
+#endif
   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;
 }
@@ skipping 32 matching lines @@
 * 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 {
+#if defined(OS_WIN_)
   // Do nothing if NSS is not loaded.
   if (!nss3_dll_)
     return std::wstring();
+#else
+  // TODO(port): Load nss3.
+  NOTIMPLEMENTED();
+  return std::wstring();
+#endif
 
   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;
     net::Base64Decode(crypt, &decoded_data);
     PK11SlotInfo* slot = NULL;
     slot = PK11_GetInternalKeySlot();
@@ skipping 144 matching lines @@
       // Version 3 has an extra line for further use.
       if (version == 3) {
         ++begin;
       }
 
       forms->push_back(form);
     }
   }
 }