Fixing Firefox 21+ password import

chrome/common/importer/firefox_importer_utils.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/common/importer/firefox_importer_utils.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/ini_parser.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 namespace {
 
 // Retrieves the file system path of the profile name.
@@ skipping 60 matching lines @@
   // since the other profiles are used mostly by developers for testing.
   for (std::vector<std::string>::const_iterator it = profiles.begin();
        it != profiles.end(); ++it)
     if (IsDefaultProfile(root, *it))
       return GetProfilePath(root, *it);
 
   // If no default profile is found, the path to Profile0 will be returned.
   return GetProfilePath(root, profiles.front());
 }
 
+#if defined(OS_MACOSX)
+// Find the "*.app" component of the path and build up from there.
+// The resulting path will be .../Firefox.app/Contents/MacOS.
+// We do this because we don't trust LastAppDir to always be
+// this particular path, without any subdirs, and we want to make
+// our assumption about Firefox's root being in that path explicit.
+bool ComposeMacAppPath(const std::string& path_from_file,
+                       base::FilePath* output) {
+  base::FilePath path(path_from_file);
+  typedef std::vector<base::FilePath::StringType> ComponentVector;
+  ComponentVector path_components;
+  path.GetComponents(&path_components);
+  if (path_components.empty())
+    return false;
+  // The first path component is special because it may be absolute. Calling
+  // Append with an absolute path component will trigger an assert, so we
+  // must handle it differently and initialize output with it.
+  *output = base::FilePath(path_components[0]);
+  // Append next path components untill we find the *.app component. When we do,
+  // append Contents/MacOS.
+  for (size_t i = 1; i < path_components.size(); ++i) {
+    *output = output->Append(path_components[i]);
+    if (EndsWith(path_components[i], ".app", true)) {
+      *output = output->Append("Contents");
+      *output = output->Append("MacOS");
+      return true;
+    }
+  }
+  LOG(ERROR) << path_from_file << " doesn't look like a valid Firefox "
+             << "installation path: missing /*.app/ directory.";
+  return false;
+}
+#endif  // OS_MACOSX
+
 bool GetFirefoxVersionAndPathFromProfile(const base::FilePath& profile_path,
                                          int* version,
                                          base::FilePath* app_path) {
   bool ret = false;
   base::FilePath compatibility_file =
       profile_path.AppendASCII("compatibility.ini");
   std::string content;
   base::ReadFileToString(compatibility_file, &content);
   ReplaceSubstringsAfterOffset(&content, 0, "\r\n", "\n");
   std::vector<std::string> lines;
   base::SplitString(content, '\n', &lines);
 
   for (size_t i = 0; i < lines.size(); ++i) {
     const std::string& line = lines[i];
     if (line.empty() || line[0] == '#' || line[0] == ';')
       continue;
     size_t equal = line.find('=');
     if (equal != std::string::npos) {
       std::string key = line.substr(0, equal);
       if (key == "LastVersion") {
         base::StringToInt(line.substr(equal + 1), version);
         ret = true;
       } else if (key == "LastAppDir") {
         // TODO(evanm): If the path in question isn't convertible to
         // UTF-8, what does Firefox do?  If it puts raw bytes in the
         // file, we could go straight from bytes -> filepath;
         // otherwise, we're out of luck here.
+#if defined(OS_MACOSX)
+        // Extract path from "LastAppDir=/actual/path"
+        size_t separator_pos = line.find_first_of('=');
+        const std::string& path_from_ini = line.substr(separator_pos + 1);
+        if (!ComposeMacAppPath(path_from_ini, app_path))
+          return false;
+#else  // !OS_MACOSX
         *app_path = base::FilePath::FromUTF8Unsafe(line.substr(equal + 1));
+#endif  // OS_MACOSX
       }
     }
   }
   return ret;
 }
 
 bool ReadPrefFile(const base::FilePath& path, std::string* content) {
   if (content == NULL)
     return false;
 
@@ skipping 143 matching lines @@
         }
       }
     }
   }
 
   StringToLowerASCII(&branding_name);
   if (branding_name.find("iceweasel") != std::string::npos)
     return l10n_util::GetStringUTF16(IDS_IMPORT_FROM_ICEWEASEL);
   return l10n_util::GetStringUTF16(IDS_IMPORT_FROM_FIREFOX);
 }