Add external extensions json source in proper mac location.

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 "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/path_service.h"
+#include "chrome/common/chrome_paths.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/json_value_serializer.h"
 
 namespace {
 
 // Caller takes ownership of the returned dictionary.
 DictionaryValue* ExtractPrefs(const FilePath& path,
                               base::ValueSerializer* serializer) {
   std::string error_msg;
   Value* extensions = serializer->Deserialize(NULL, &error_msg);
   if (!extensions) {
     LOG(WARNING) << "Unable to deserialize json data: " << error_msg
                  << " In file " << path.value() << " .";
   } else {
     if (!extensions->IsType(Value::TYPE_DICTIONARY)) {
       LOG(WARNING) << "Expected a JSON dictionary in file "
                    << path.value() << " .";
     } else {
       return static_cast<DictionaryValue*>(extensions);
     }
   }
   return new DictionaryValue;
 }
 
 }  // namespace
 
-ExternalPrefExtensionLoader::ExternalPrefExtensionLoader(int base_path_key)
-    : base_path_key_(base_path_key) {
+ExternalPrefExtensionLoader::ExternalPrefExtensionLoader(int base_path_key,
+                                                         Options options)
+    : base_path_key_(base_path_key),
+      options_(options){
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 const FilePath ExternalPrefExtensionLoader::GetBaseCrxFilePath() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // |base_path_| was set in LoadOnFileThread().
   return base_path_;
 }
 
@@ skipping 16 matching lines @@
   // OS developer builds and linux install packages.
   // Tracked as crbug.com/70402 .
 
   scoped_ptr<DictionaryValue> prefs;
   if (PathService::Get(base_path_key_, &base_path_)) {
     FilePath json_file;
     json_file =
         base_path_.Append(FILE_PATH_LITERAL("external_extensions.json"));
 
     if (file_util::PathExists(json_file)) {
-      JSONFileValueSerializer serializer(json_file);
-      prefs.reset(ExtractPrefs(json_file, &serializer));
+      if (IsOptionSet(ENSURE_PATH_CONTROLLED_BY_ADMIN) &&
+          !file_util::IsPathControlledByAdmin(json_file)) {
+        LOG(ERROR) << "Can not read external extensions source.  The file "
+                   << json_file.value() << " and every directory in its path "
+                   << "must be owned by root, and not be writable by all "
+                   << "users. This restriction prevents unprivleged users "
+                   << "from making chrome install extensions on other users' "
+                   << "accounts.";
+      } else {
+        JSONFileValueSerializer serializer(json_file);
+        prefs.reset(ExtractPrefs(json_file, &serializer));
+      }
     }
   }
 
   if (!prefs.get())
     prefs.reset(new DictionaryValue());
 
   prefs_.reset(prefs.release());
 
+  // We want to deprecate the external extensions file inside the app
+  // bundle on mac os.  Use a histogram to see how many extensions
+  // are installed in this way.  We can use this data to measure the
+  // effectiveness of asking developers to use the new path, or any
+  // automatic migration methods we implement.

[TVL, 2011/08/25 14:07:28]

fyi - if folks were modifying the bundle link this, they were breaking the code
signature on the app.  But nothing on the OS really checks this.

[Sam Kerner (Chrome), 2011/08/25 14:29:58]

  Mark mentioned that in the bug.  In order to figure out how we should migrate
away from the current setup, I would like to know more about this.  I think
someone mentioned that requests to read from the keychain would have extra
prompts.  Will these prompts happen every time while the file exists, or every
time the file is altered?  

+  if (base_path_key_ == chrome::DIR_DEPRICATED_EXTERNAL_EXTENSIONS) {
+    UMA_HISTOGRAM_COUNTS_100("Extensions.DepricatedExternalJsonCount",
+                             prefs_->size());

[asargent_no_longer_on_chrome, 2011/08/24 22:55:09]

Optional suggestion - do we want to also measure the count of extensions using
the new location? Then we could see the ratio of deprecated to new over time. 

[Sam Kerner (Chrome), 2011/08/25 14:04:37]

Good point.  Done.

+  }
+
   // If we have any records to process, then we must have
   // read the .json file.  If we read the .json file, then
   // we were should have set |base_path_|.
   if (!prefs_->empty())
     CHECK(!base_path_.empty());
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           this,
@@ skipping 14 matching lines @@
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   prefs_.reset(testing_prefs_->DeepCopy());
   LoadFinished();
 }
 
 ExternalTestingExtensionLoader::~ExternalTestingExtensionLoader() {}
 
 const FilePath ExternalTestingExtensionLoader::GetBaseCrxFilePath() {
   return fake_base_path_;
 }