Make ExtensionPrefs paths relative, re-enable 2 ExtensionsService unit_tests

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2009 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/extensions/extension_prefs.h"
 
 #include "base/string_util.h"
 #include "chrome/common/extensions/extension.h"
 
 namespace {
@@ skipping 50 matching lines @@
       continue;
     }
     Extension::Location location =
         static_cast<Extension::Location>(location_value);
     callback->Run(WideToASCII(*extension_id), FilePath(path), location);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-ExtensionPrefs::ExtensionPrefs(PrefService* prefs) : prefs_(prefs) {
+ExtensionPrefs::ExtensionPrefs(PrefService* prefs, const FilePath& root_dir)
+    : prefs_(prefs),
+      install_directory_(root_dir) {
   if (!prefs_->FindPreference(kExtensionsPref))
     prefs_->RegisterDictionaryPref(kExtensionsPref);
   if (!prefs->FindPreference(kExtensionShelf))
     prefs->RegisterListPref(kExtensionShelf);
+  MakePathsRelative();
+}
+
+static FilePath::StringType MakePathRelative(const FilePath& parent,
+                                             const FilePath& child,
+                                             bool *dirty) {
+  if (!parent.IsParent(child))
+    return child.value();
+
+  if (dirty)
+    *dirty = true;
+  FilePath::StringType retval = child.value().substr(
+      parent.value().length());
+  if (FilePath::IsSeparator(retval[0]))
+    return retval.substr(1);
+  else
+    return retval;
+}
+
+void ExtensionPrefs::MakePathsRelative() {
+  bool dirty = false;
+  const DictionaryValue* dict = prefs_->GetMutableDictionary(kExtensionsPref);
+  if (!dict || dict->GetSize() == 0)
+    return;
+
+  for (DictionaryValue::key_iterator i = dict->begin_keys();
+       i != dict->end_keys(); ++i) {
+    DictionaryValue* extension_dict;
+    if (!dict->GetDictionary(*i, &extension_dict))
+      continue;
+    FilePath::StringType path_string;
+    if (!extension_dict->GetString(kPrefPath, &path_string))
+      continue;
+    FilePath path(path_string);
+    if (path.IsAbsolute()) {
+      extension_dict->SetString(kPrefPath,
+          MakePathRelative(install_directory_, path, &dirty));
+    }
+  }
+  if (dirty)
+    prefs_->ScheduleSavePersistentPrefs();
+}
+
+void ExtensionPrefs::MakePathsAbsolute(DictionaryValue* dict) {
+  if (!dict || dict->GetSize() == 0)
+    return;
+
+  for (DictionaryValue::key_iterator i = dict->begin_keys();
+       i != dict->end_keys(); ++i) {
+    DictionaryValue* extension_dict;
+    if (!dict->GetDictionary(*i, &extension_dict)) {
+      NOTREACHED();
+      continue;
+    }
+    FilePath::StringType path_string;
+    if (!extension_dict->GetString(kPrefPath, &path_string)) {
+      NOTREACHED();
+      continue;
+    }
+    DCHECK(!FilePath(path_string).IsAbsolute());
+    extension_dict->SetString(
+        kPrefPath, install_directory_.Append(path_string).value());
+  }
 }
 
 DictionaryValue* ExtensionPrefs::CopyCurrentExtensions() {
   const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
   if (extensions) {
     DictionaryValue* copy =
         static_cast<DictionaryValue*>(extensions->DeepCopy());
+    MakePathsAbsolute(copy);
     return copy;
   }
   return new DictionaryValue;
 }
 
 void ExtensionPrefs::GetKilledExtensionIds(std::set<std::string>* killed_ids) {
   const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
   if (!dict || dict->GetSize() == 0)
     return;
 
@@ skipping 44 matching lines @@
   }
   prefs_->ScheduleSavePersistentPrefs();
 }
 
 void ExtensionPrefs::OnExtensionInstalled(Extension* extension) {
   std::string id = extension->id();
   UpdateExtensionPref(id, kPrefState,
                       Value::CreateIntegerValue(Extension::ENABLED));
   UpdateExtensionPref(id, kPrefLocation,
                       Value::CreateIntegerValue(extension->location()));
-  UpdateExtensionPref(id, kPrefPath,
-                      Value::CreateStringValue(extension->path().value()));
+  FilePath::StringType path = MakePathRelative(install_directory_,
+      extension->path(), NULL);
+  UpdateExtensionPref(id, kPrefPath, Value::CreateStringValue(path));
   prefs_->ScheduleSavePersistentPrefs();
 }
 
 void ExtensionPrefs::OnExtensionUninstalled(const Extension* extension,
                                             bool external_uninstall) {
   // For external extensions, we save a preference reminding ourself not to try
   // and install the extension anymore (except when |external_uninstall| is
   // true, which signifies that the registry key was deleted or the pref file
   // no longer lists the extension).
   if (!external_uninstall &&
@@ skipping 33 matching lines @@
   DictionaryValue* extension = NULL;
   std::wstring id = ASCIIToWide(extension_id);
   if (!dict->GetDictionary(id, &extension)) {
     // Extension pref does not exist, create it.
     extension = new DictionaryValue();
     dict->Set(id, extension);
   }
   return extension;
 }