1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "chrome/browser/extensions/test_extension_environment.h"
6
7 #include <utility>
8
9 #include "base/command_line.h"
10 #include "base/json/json_writer.h"
11 #include "base/values.h"
12 #include "chrome/browser/extensions/extension_service.h"
13 #include "chrome/browser/extensions/test_extension_system.h"
14 #include "chrome/browser/sessions/session_tab_helper_factory.h"
15 #include "chrome/test/base/testing_profile.h"
16 #include "components/sessions/content/session_tab_helper.h"
17 #include "content/public/test/browser_task_environment.h"
18 #include "content/public/test/test_utils.h"
19 #include "content/public/test/web_contents_tester.h"
20 #include "extensions/browser/extension_prefs.h"
21 #include "extensions/common/extension_builder.h"
22 #include "extensions/common/value_builder.h"
23 #include "testing/gtest/include/gtest/gtest.h"
24
25 #if defined(OS_CHROMEOS)
26 #include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
27 #include "chrome/browser/chromeos/settings/device_settings_service.h"
28 #include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
29 #endif
30
31 namespace extensions {
32
33 using content::BrowserThread;
34
35 namespace {
36
MakeExtensionManifest(const base::Value & manifest_extra)37 std::unique_ptr<base::DictionaryValue> MakeExtensionManifest(
38 const base::Value& manifest_extra) {
39 std::unique_ptr<base::DictionaryValue> manifest =
40 DictionaryBuilder()
41 .Set("name", "Extension")
42 .Set("version", "1.0")
43 .Set("manifest_version", 2)
44 .Build();
45 const base::DictionaryValue* manifest_extra_dict;
46 if (manifest_extra.GetAsDictionary(&manifest_extra_dict)) {
47 manifest->MergeDictionary(manifest_extra_dict);
48 } else {
49 std::string manifest_json;
50 base::JSONWriter::Write(manifest_extra, &manifest_json);
51 ADD_FAILURE() << "Expected dictionary; got \"" << manifest_json << "\"";
52 }
53 return manifest;
54 }
55
MakePackagedAppManifest()56 std::unique_ptr<base::DictionaryValue> MakePackagedAppManifest() {
57 return extensions::DictionaryBuilder()
58 .Set("name", "Test App Name")
59 .Set("version", "2.0")
60 .Set("manifest_version", 2)
61 .Set("app", extensions::DictionaryBuilder()
62 .Set("background",
63 extensions::DictionaryBuilder()
64 .Set("scripts", extensions::ListBuilder()
65 .Append("background.js")
66 .Build())
67 .Build())
68 .Build())
69 .Build();
70 }
71
72 } // namespace
73
74 #if defined(OS_CHROMEOS)
75 // Extra environment state required for ChromeOS.
76 class TestExtensionEnvironment::ChromeOSEnv {
77 public:
ChromeOSEnv()78 ChromeOSEnv() {}
79
80 private:
81 chromeos::ScopedCrosSettingsTestHelper cros_settings_test_helper_;
82 chromeos::ScopedTestUserManager test_user_manager_;
83
84 DISALLOW_COPY_AND_ASSIGN(ChromeOSEnv);
85 };
86 #endif // defined(OS_CHROMEOS)
87
88 // static
CreateExtensionServiceForProfile(TestingProfile * profile)89 ExtensionService* TestExtensionEnvironment::CreateExtensionServiceForProfile(
90 TestingProfile* profile) {
91 TestExtensionSystem* extension_system =
92 static_cast<TestExtensionSystem*>(ExtensionSystem::Get(profile));
93 return extension_system->CreateExtensionService(
94 base::CommandLine::ForCurrentProcess(), base::FilePath(), false);
95 }
96
TestExtensionEnvironment(Type type)97 TestExtensionEnvironment::TestExtensionEnvironment(Type type)
98 : task_environment_(
99 type == Type::kWithTaskEnvironment
100 ? std::make_unique<content::BrowserTaskEnvironment>()
101 : nullptr),
102 #if defined(OS_CHROMEOS)
103 chromeos_env_(chromeos::DeviceSettingsService::IsInitialized()
104 ? nullptr
105 : std::make_unique<ChromeOSEnv>()),
106 #endif
107 profile_(std::make_unique<TestingProfile>()) {
108 }
109
~TestExtensionEnvironment()110 TestExtensionEnvironment::~TestExtensionEnvironment() {
111 }
112
profile() const113 TestingProfile* TestExtensionEnvironment::profile() const {
114 return profile_.get();
115 }
116
GetExtensionSystem()117 TestExtensionSystem* TestExtensionEnvironment::GetExtensionSystem() {
118 return static_cast<TestExtensionSystem*>(ExtensionSystem::Get(profile()));
119 }
120
GetExtensionService()121 ExtensionService* TestExtensionEnvironment::GetExtensionService() {
122 if (!extension_service_)
123 extension_service_ = CreateExtensionServiceForProfile(profile());
124 return extension_service_;
125 }
126
GetExtensionPrefs()127 ExtensionPrefs* TestExtensionEnvironment::GetExtensionPrefs() {
128 return ExtensionPrefs::Get(profile_.get());
129 }
130
MakeExtension(const base::Value & manifest_extra)131 const Extension* TestExtensionEnvironment::MakeExtension(
132 const base::Value& manifest_extra) {
133 std::unique_ptr<base::DictionaryValue> manifest =
134 MakeExtensionManifest(manifest_extra);
135 scoped_refptr<const Extension> result =
136 ExtensionBuilder().SetManifest(std::move(manifest)).Build();
137 GetExtensionService()->AddExtension(result.get());
138 return result.get();
139 }
140
MakeExtension(const base::Value & manifest_extra,const std::string & id)141 const Extension* TestExtensionEnvironment::MakeExtension(
142 const base::Value& manifest_extra,
143 const std::string& id) {
144 std::unique_ptr<base::DictionaryValue> manifest =
145 MakeExtensionManifest(manifest_extra);
146 scoped_refptr<const Extension> result =
147 ExtensionBuilder().SetManifest(std::move(manifest)).SetID(id).Build();
148 GetExtensionService()->AddExtension(result.get());
149 return result.get();
150 }
151
MakePackagedApp(const std::string & id,bool install)152 scoped_refptr<const Extension> TestExtensionEnvironment::MakePackagedApp(
153 const std::string& id,
154 bool install) {
155 scoped_refptr<const Extension> result =
156 ExtensionBuilder()
157 .SetManifest(MakePackagedAppManifest())
158 .AddFlags(Extension::FROM_WEBSTORE)
159 .SetID(id)
160 .Build();
161 if (install)
162 GetExtensionService()->AddExtension(result.get());
163 return result;
164 }
165
MakeTab() const166 std::unique_ptr<content::WebContents> TestExtensionEnvironment::MakeTab()
167 const {
168 std::unique_ptr<content::WebContents> contents(
169 content::WebContentsTester::CreateTestWebContents(profile(), nullptr));
170 // Create a tab id.
171 CreateSessionServiceTabHelper(contents.get());
172 return contents;
173 }
174
DeleteProfile()175 void TestExtensionEnvironment::DeleteProfile() {
176 profile_.reset();
177 extension_service_ = nullptr;
178 }
179
180 } // namespace extensions
181