Moved ExternalExtensionLoaders/Providers into extensions namespace

chrome/browser/extensions/external_pref_loader.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/browser/extensions/external_pref_extension_loader.h"
+#include "chrome/browser/extensions/external_pref_loader.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
@@ skipping 64 matching lines @@
   if (extensions->GetAsDictionary(&ext_dictionary))
     return ext_dictionary;
 
   LOG(WARNING) << "Expected a JSON dictionary in file "
                << path.value() << ".";
   return new DictionaryValue;
 }
 
 }  // namespace
 
-ExternalPrefExtensionLoader::ExternalPrefExtensionLoader(int base_path_id,
-                                                         Options options)
-    : base_path_id_(base_path_id),
-      options_(options) {
+namespace extensions {
+
+ExternalPrefLoader::ExternalPrefLoader(int base_path_id, Options options)
+    : base_path_id_(base_path_id), options_(options) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
-const FilePath ExternalPrefExtensionLoader::GetBaseCrxFilePath() {
+const FilePath ExternalPrefLoader::GetBaseCrxFilePath() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // |base_path_| was set in LoadOnFileThread().
   return base_path_;
 }
 
-void ExternalPrefExtensionLoader::StartLoading() {
+void ExternalPrefLoader::StartLoading() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&ExternalPrefExtensionLoader::LoadOnFileThread, this));
+      base::Bind(&ExternalPrefLoader::LoadOnFileThread, this));
 }
 
-void ExternalPrefExtensionLoader::LoadOnFileThread() {
+void ExternalPrefLoader::LoadOnFileThread() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // TODO(skerner): Some values of base_path_id_ will cause
   // PathService::Get() to return false, because the path does
   // not exist.  Find and fix the build/install scripts so that
   // this can become a CHECK().  Known examples include chrome
   // OS developer builds and linux install packages.
   // Tracked as crbug.com/70402 .
   if (!PathService::Get(base_path_id_, &base_path_))
     return;
@@ skipping 19 matching lines @@
   }
 
   // If we have any records to process, then we must have
   // read at least one .json file.  If so, then we should have
   // set |base_path_|.
   if (!prefs_->empty())
     CHECK(!base_path_.empty());
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&ExternalPrefExtensionLoader::LoadFinished, this));
+      base::Bind(&ExternalPrefLoader::LoadFinished, this));
 }
 
-void ExternalPrefExtensionLoader::ReadExternalExtensionPrefFile(
-      DictionaryValue* prefs) {
+void ExternalPrefLoader::ReadExternalExtensionPrefFile(DictionaryValue* prefs) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   CHECK(NULL != prefs);
 
   FilePath json_file = base_path_.Append(kExternalExtensionJson);
 
   if (!file_util::PathExists(json_file)) {
     // This is not an error.  The file does not exist by default.
     return;
   }
 
@@ skipping 16 matching lines @@
 #endif  // defined(OS_MACOSX)
   }
 
   JSONFileValueSerializer serializer(json_file);
   scoped_ptr<DictionaryValue> ext_prefs(
       ExtractExtensionPrefs(&serializer, json_file));
   if (ext_prefs.get())
     prefs->MergeDictionary(ext_prefs.get());
 }
 
-void ExternalPrefExtensionLoader::ReadStandaloneExtensionPrefFiles(
-      DictionaryValue* prefs) {
+void ExternalPrefLoader::ReadStandaloneExtensionPrefFiles(
+    DictionaryValue* prefs) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   CHECK(NULL != prefs);
 
   // First list the potential .json candidates.
   std::set<FilePath>
       candidates = GetPrefsCandidateFilesFromFolder(base_path_);
   if (candidates.empty()) {
     DVLOG(1) << "Extension candidates list empty";
     return;
   }
@@ skipping 19 matching lines @@
     JSONFileValueSerializer serializer(extension_candidate_path);
     scoped_ptr<DictionaryValue> ext_prefs(
         ExtractExtensionPrefs(&serializer, extension_candidate_path));
     if (ext_prefs.get()) {
       DVLOG(1) << "Adding extension with id: " << id;
       prefs->Set(id, ext_prefs.release());
     }
   }
 }
 
-ExternalTestingExtensionLoader::ExternalTestingExtensionLoader(
-    const std::string& json_data,
-    const FilePath& fake_base_path)
+ExternalTestingLoader::ExternalTestingLoader(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);
   FilePath fake_json_path = fake_base_path.AppendASCII("fake.json");
   testing_prefs_.reset(ExtractExtensionPrefs(&serializer, fake_json_path));
 }
 
-void ExternalTestingExtensionLoader::StartLoading() {
+void ExternalTestingLoader::StartLoading() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   prefs_.reset(testing_prefs_->DeepCopy());
   LoadFinished();
 }
 
-ExternalTestingExtensionLoader::~ExternalTestingExtensionLoader() {}
+ExternalTestingLoader::~ExternalTestingLoader() {}
 
-const FilePath ExternalTestingExtensionLoader::GetBaseCrxFilePath() {
+const FilePath ExternalTestingLoader::GetBaseCrxFilePath() {
   return fake_base_path_;
 }
+
+}  // extensions