Add a test for KeywordExtensionsDelegateImpl::IsEnabledExtension().

chrome/browser/extensions/test_extension_system.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/test_extension_system.h"
 
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/extensions/blacklist.h"
 #include "chrome/browser/extensions/declarative_user_script_master.h"
@@ skipping 23 matching lines @@
 
 using content::BrowserThread;
 
 namespace extensions {
 
 TestExtensionSystem::TestExtensionSystem(Profile* profile)
     : profile_(profile),
       value_store_(NULL),
       info_map_(new InfoMap()),
       error_console_(new ErrorConsole(profile)),
-      quota_service_(new QuotaService()) {}
+      quota_service_(new QuotaService()),
+      extension_service_(NULL),
+      extension_service_owned_(true) {}
 
 TestExtensionSystem::~TestExtensionSystem() {
+  if (extension_service_owned_)

[Yoyo Zhou, 2014/09/05 16:21:33]

&& extension_service_?

[Lei Zhang, 2014/09/05 19:35:08]

Nope. http://www.parashift.com/c++-faq/delete-handles-null.html

+    delete extension_service_;
 }
 
 void TestExtensionSystem::Shutdown() {
   process_manager_.reset();
 }
 
 void TestExtensionSystem::CreateProcessManager() {
   process_manager_.reset(ProcessManager::Create(profile_));
 }
 
@@ skipping 39 matching lines @@
   value_store_ = value_store.get();
   state_store_.reset(
       new StateStore(profile_, value_store.PassAs<ValueStore>()));
   blacklist_.reset(new Blacklist(ExtensionPrefs::Get(profile_)));
   standard_management_policy_provider_.reset(
       new StandardManagementPolicyProvider(ExtensionPrefs::Get(profile_)));
   management_policy_.reset(new ManagementPolicy());
   management_policy_->RegisterProvider(
       standard_management_policy_provider_.get());
   runtime_data_.reset(new RuntimeData(ExtensionRegistry::Get(profile_)));
-  extension_service_.reset(new ExtensionService(profile_,
-                                                command_line,
-                                                install_directory,
-                                                ExtensionPrefs::Get(profile_),
-                                                blacklist_.get(),
-                                                autoupdate_enabled,
-                                                true,
-                                                &ready_));
+  if (extension_service_owned_)
+    delete extension_service_;
+  extension_service_ = new ExtensionService(profile_,
+                                            command_line,
+                                            install_directory,
+                                            ExtensionPrefs::Get(profile_),
+                                            blacklist_.get(),
+                                            autoupdate_enabled,
+                                            true,
+                                            &ready_);
+  extension_service_owned_ = true;
   extension_service_->ClearProvidersForTesting();
-  return extension_service_.get();
+  return extension_service_;
 }
 
 ExtensionService* TestExtensionSystem::extension_service() {
-  return extension_service_.get();
+  return extension_service_;
 }
 
 RuntimeData* TestExtensionSystem::runtime_data() {
   return runtime_data_.get();
 }
 
 ManagementPolicy* TestExtensionSystem::management_policy() {
   return management_policy_.get();
 }
 
-void TestExtensionSystem::SetExtensionService(ExtensionService* service) {
-  extension_service_.reset(service);
+void TestExtensionSystem::SetExtensionService(ExtensionService* service,
+                                              bool owned) {
+  if (extension_service_owned_)
+    delete extension_service_;
+  extension_service_ = service;
+  extension_service_owned_ = owned;
 }
 
 SharedUserScriptMaster* TestExtensionSystem::shared_user_script_master() {
   return NULL;
 }
 
 ProcessManager* TestExtensionSystem::process_manager() {
   return process_manager_.get();
 }
 
@@ skipping 72 matching lines @@
   }
   return master;
 }
 
 // static
 KeyedService* TestExtensionSystem::Build(content::BrowserContext* profile) {
   return new TestExtensionSystem(static_cast<Profile*>(profile));
 }
 
 }  // namespace extensions