Allow relative paths to external extension files for some providers, error out for others.

chrome/browser/extensions/external_pref_extension_loader.cc

 // 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/extensions/external_pref_extension_loader.h"
 
 #include "app/app_paths.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
       NOTREACHED() << "Invalid json data";
     } else {
       return static_cast<DictionaryValue*>(extensions);
     }
   }
   return new DictionaryValue;
 }
 
 }  // namespace
 
-ExternalPrefExtensionLoader::ExternalPrefExtensionLoader() {
+ExternalPrefExtensionLoader::ExternalPrefExtensionLoader(int base_path_key)
+    : base_path_key_(base_path_key) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
+const FilePath ExternalPrefExtensionLoader::GetBaseCrxFilePath() {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // LoadOnFileThread() should set |external_file_path_| to a non-empty
+  // path.  This function should not be called until after LoadOnFileThread()
+  // is complete.
+  CHECK(!base_path_.empty());
+
+  return base_path_;
+}
+
 void ExternalPrefExtensionLoader::StartLoading() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           this,
           &ExternalPrefExtensionLoader::LoadOnFileThread));
 }
 
 void ExternalPrefExtensionLoader::LoadOnFileThread() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  CHECK(PathService::Get(base_path_key_, &base_path_));
+
   FilePath json_file;
-  PathService::Get(app::DIR_EXTERNAL_EXTENSIONS, &json_file);
-  json_file = json_file.Append(FILE_PATH_LITERAL("external_extensions.json"));
+  json_file = base_path_.Append(FILE_PATH_LITERAL("external_extensions.json"));
+
   scoped_ptr<DictionaryValue> prefs;
-
   if (file_util::PathExists(json_file)) {
     JSONFileValueSerializer serializer(json_file);
     prefs.reset(ExtractPrefs(&serializer));
   } else {
     prefs.reset(new DictionaryValue());
   }
 
   prefs_.reset(prefs.release());
   BrowserThread::PostTask(
        BrowserThread::UI, FROM_HERE,
        NewRunnableMethod(
            this,
            &ExternalPrefExtensionLoader::LoadFinished));
 }
 
 ExternalTestingExtensionLoader::ExternalTestingExtensionLoader(
-    const std::string& json_data) {
+    const std::string& json_data,
+    const FilePath& fake_base_path)
+    : fake_base_path_(fake_base_path) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   JSONStringValueSerializer serializer(json_data);
   testing_prefs_.reset(ExtractPrefs(&serializer));
 }
 
 void ExternalTestingExtensionLoader::StartLoading() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   prefs_.reset(testing_prefs_->DeepCopy());
   LoadFinished();
 }
+
+const FilePath ExternalTestingExtensionLoader::GetBaseCrxFilePath() {
+  return fake_base_path_;
+}