Move 'theme' parsing out of Extension class

chrome/test/base/testing_profile.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/test/base/testing_profile.h"
 
 #include "build/build_config.h"
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
@@ skipping 190 matching lines @@
                                                 base::Unretained(this)));
   } else {
     FinishInit();
   }
 }
 
 TestingProfile::TestingProfile(
     const base::FilePath& path,
     Delegate* delegate,
     scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy,
-    scoped_ptr<PrefServiceSyncable> prefs,
-    bool off_the_record)
+    scoped_ptr<PrefServiceSyncable> prefs)
     : start_time_(Time::Now()),
       prefs_(prefs.release()),
       testing_prefs_(NULL),
-      incognito_(off_the_record),
+      incognito_(false),
       last_session_exited_cleanly_(true),
       extension_special_storage_policy_(extension_policy),
       profile_path_(path),
       profile_dependency_manager_(ProfileDependencyManager::GetInstance()),
       delegate_(delegate) {
 
   // If no profile path was supplied, create one.
   if (profile_path_.empty()) {
     CreateTempProfileDir();
     profile_path_ = temp_dir_.path();
@@ skipping 319 matching lines @@
 #if defined(ENABLE_CONFIGURATION_POLICY)
     policy::PolicyServiceImpl::Providers providers;
     policy_service_.reset(new policy::PolicyServiceImpl(providers));
 #else
     policy_service_.reset(new policy::PolicyServiceStub());
 #endif
   }
   return policy_service_.get();
 }
 
-void TestingProfile::SetPrefService(PrefServiceSyncable* prefs) {
-  prefs_.reset(prefs);
-}
-
 void TestingProfile::CreateTestingPrefService() {
   DCHECK(!prefs_.get());
   testing_prefs_ = new TestingPrefServiceSyncable();
   prefs_.reset(testing_prefs_);
   Profile::RegisterUserPrefs(testing_prefs_->registry());
   chrome::RegisterUserPrefs(testing_prefs_, testing_prefs_->registry());
 }
 
 PrefService* TestingProfile::GetPrefs() {
   if (!prefs_.get()) {
@@ skipping 212 matching lines @@
 bool TestingProfile::WasCreatedByVersionOrLater(const std::string& version) {
   return true;
 }
 
 Profile::ExitType TestingProfile::GetLastSessionExitType() {
   return last_session_exited_cleanly_ ? EXIT_NORMAL : EXIT_CRASHED;
 }
 
 TestingProfile::Builder::Builder()
     : build_called_(false),
-      delegate_(NULL),
-      off_the_record_(false) {
+      delegate_(NULL) {
 }
 
 TestingProfile::Builder::~Builder() {
 }
 
 void TestingProfile::Builder::SetPath(const base::FilePath& path) {
   path_ = path;
 }
 
 void TestingProfile::Builder::SetDelegate(Delegate* delegate) {
   delegate_ = delegate;
 }
 
 void TestingProfile::Builder::SetExtensionSpecialStoragePolicy(
     scoped_refptr<ExtensionSpecialStoragePolicy> policy) {
   extension_policy_ = policy;
 }
 
 void TestingProfile::Builder::SetPrefService(
     scoped_ptr<PrefServiceSyncable> prefs) {
   pref_service_ = prefs.Pass();
 }
 
-void TestingProfile::Builder::SetOffTheRecord() {
-  off_the_record_ = true;
-}
-
 scoped_ptr<TestingProfile> TestingProfile::Builder::Build() {
   DCHECK(!build_called_);
   build_called_ = true;
   return scoped_ptr<TestingProfile>(new TestingProfile(
       path_,
       delegate_,
       extension_policy_,
-      pref_service_.Pass(),
-      off_the_record_));
+      pref_service_.Pass()));
 }