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/component_loader.h"
6
7 #include <string>
8
9 #include "base/command_line.h"
10 #include "base/files/file_util.h"
11 #include "base/json/json_string_value_serializer.h"
12 #include "base/metrics/field_trial.h"
13 #include "base/path_service.h"
14 #include "chrome/browser/extensions/extension_service.h"
15 #include "chrome/browser/search/hotword_service_factory.h"
16 #include "chrome/common/chrome_paths.h"
17 #include "chrome/common/chrome_switches.h"
18 #include "chrome/common/chrome_version_info.h"
19 #include "chrome/common/extensions/extension_constants.h"
20 #include "chrome/grit/generated_resources.h"
21 #include "components/crx_file/id_util.h"
22 #include "content/public/browser/browser_context.h"
23 #include "content/public/browser/browser_thread.h"
24 #include "content/public/browser/plugin_service.h"
25 #include "extensions/common/extension.h"
26 #include "extensions/common/file_util.h"
27 #include "extensions/common/manifest_constants.h"
28 #include "grit/browser_resources.h"
29 #include "ui/base/l10n/l10n_util.h"
30 #include "ui/base/resource/resource_bundle.h"
31
32 #if defined(OS_CHROMEOS)
33 #include "grit/keyboard_resources.h"
34 #include "ui/file_manager/grit/file_manager_resources.h"
35 #include "ui/keyboard/keyboard_util.h"
36 #endif
37
38 #if defined(GOOGLE_CHROME_BUILD)
39 #include "chrome/browser/defaults.h"
40 #endif
41
42 #if defined(OS_CHROMEOS)
43 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
44 #include "chromeos/chromeos_switches.h"
45 #include "content/public/browser/site_instance.h"
46 #include "content/public/browser/storage_partition.h"
47 #include "extensions/browser/extensions_browser_client.h"
48 #include "storage/browser/fileapi/file_system_context.h"
49 #endif
50
51 #if defined(ENABLE_APP_LIST)
52 #include "chrome/grit/chromium_strings.h"
53 #endif
54
55 using content::BrowserThread;
56
57 namespace extensions {
58
59 namespace {
60
61 static bool enable_background_extensions_during_testing = false;
62
GenerateId(const base::DictionaryValue * manifest,const base::FilePath & path)63 std::string GenerateId(const base::DictionaryValue* manifest,
64 const base::FilePath& path) {
65 std::string raw_key;
66 std::string id_input;
67 CHECK(manifest->GetString(manifest_keys::kPublicKey, &raw_key));
68 CHECK(Extension::ParsePEMKeyBytes(raw_key, &id_input));
69 std::string id = crx_file::id_util::GenerateId(id_input);
70 return id;
71 }
72
73 #if defined(OS_CHROMEOS)
74 scoped_ptr<base::DictionaryValue>
LoadManifestOnFileThread(const base::FilePath & chromevox_path,const char * manifest_filename)75 LoadManifestOnFileThread(
76 const base::FilePath& chromevox_path, const char* manifest_filename) {
77 DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
78 std::string error;
79 scoped_ptr<base::DictionaryValue> manifest(
80 file_util::LoadManifest(chromevox_path, manifest_filename, &error));
81 CHECK(manifest) << error;
82 return manifest.Pass();
83 }
84 #endif // defined(OS_CHROMEOS)
85
86 } // namespace
87
ComponentExtensionInfo(const base::DictionaryValue * manifest,const base::FilePath & directory)88 ComponentLoader::ComponentExtensionInfo::ComponentExtensionInfo(
89 const base::DictionaryValue* manifest, const base::FilePath& directory)
90 : manifest(manifest),
91 root_directory(directory) {
92 if (!root_directory.IsAbsolute()) {
93 CHECK(PathService::Get(chrome::DIR_RESOURCES, &root_directory));
94 root_directory = root_directory.Append(directory);
95 }
96 extension_id = GenerateId(manifest, root_directory);
97 }
98
ComponentLoader(ExtensionServiceInterface * extension_service,PrefService * profile_prefs,PrefService * local_state,content::BrowserContext * browser_context)99 ComponentLoader::ComponentLoader(ExtensionServiceInterface* extension_service,
100 PrefService* profile_prefs,
101 PrefService* local_state,
102 content::BrowserContext* browser_context)
103 : profile_prefs_(profile_prefs),
104 local_state_(local_state),
105 browser_context_(browser_context),
106 extension_service_(extension_service),
107 weak_factory_(this) {}
108
~ComponentLoader()109 ComponentLoader::~ComponentLoader() {
110 ClearAllRegistered();
111 }
112
LoadAll()113 void ComponentLoader::LoadAll() {
114 for (RegisteredComponentExtensions::iterator it =
115 component_extensions_.begin();
116 it != component_extensions_.end(); ++it) {
117 Load(*it);
118 }
119 }
120
ParseManifest(const std::string & manifest_contents) const121 base::DictionaryValue* ComponentLoader::ParseManifest(
122 const std::string& manifest_contents) const {
123 JSONStringValueSerializer serializer(manifest_contents);
124 scoped_ptr<base::Value> manifest(serializer.Deserialize(NULL, NULL));
125
126 if (!manifest.get() || !manifest->IsType(base::Value::TYPE_DICTIONARY)) {
127 LOG(ERROR) << "Failed to parse extension manifest.";
128 return NULL;
129 }
130 // Transfer ownership to the caller.
131 return static_cast<base::DictionaryValue*>(manifest.release());
132 }
133
ClearAllRegistered()134 void ComponentLoader::ClearAllRegistered() {
135 for (RegisteredComponentExtensions::iterator it =
136 component_extensions_.begin();
137 it != component_extensions_.end(); ++it) {
138 delete it->manifest;
139 }
140
141 component_extensions_.clear();
142 }
143
GetExtensionID(int manifest_resource_id,const base::FilePath & root_directory)144 std::string ComponentLoader::GetExtensionID(
145 int manifest_resource_id,
146 const base::FilePath& root_directory) {
147 std::string manifest_contents = ResourceBundle::GetSharedInstance().
148 GetRawDataResource(manifest_resource_id).as_string();
149 base::DictionaryValue* manifest = ParseManifest(manifest_contents);
150 if (!manifest)
151 return std::string();
152
153 ComponentExtensionInfo info(manifest, root_directory);
154 return info.extension_id;
155 }
156
Add(int manifest_resource_id,const base::FilePath & root_directory)157 std::string ComponentLoader::Add(int manifest_resource_id,
158 const base::FilePath& root_directory) {
159 std::string manifest_contents =
160 ResourceBundle::GetSharedInstance().GetRawDataResource(
161 manifest_resource_id).as_string();
162 return Add(manifest_contents, root_directory);
163 }
164
Add(const std::string & manifest_contents,const base::FilePath & root_directory)165 std::string ComponentLoader::Add(const std::string& manifest_contents,
166 const base::FilePath& root_directory) {
167 // The Value is kept for the lifetime of the ComponentLoader. This is
168 // required in case LoadAll() is called again.
169 base::DictionaryValue* manifest = ParseManifest(manifest_contents);
170 if (manifest)
171 return Add(manifest, root_directory);
172 return std::string();
173 }
174
Add(const base::DictionaryValue * parsed_manifest,const base::FilePath & root_directory)175 std::string ComponentLoader::Add(const base::DictionaryValue* parsed_manifest,
176 const base::FilePath& root_directory) {
177 ComponentExtensionInfo info(parsed_manifest, root_directory);
178 component_extensions_.push_back(info);
179 if (extension_service_->is_ready())
180 Load(info);
181 return info.extension_id;
182 }
183
AddOrReplace(const base::FilePath & path)184 std::string ComponentLoader::AddOrReplace(const base::FilePath& path) {
185 base::FilePath absolute_path = base::MakeAbsoluteFilePath(path);
186 std::string error;
187 scoped_ptr<base::DictionaryValue> manifest(
188 file_util::LoadManifest(absolute_path, &error));
189 if (!manifest) {
190 LOG(ERROR) << "Could not load extension from '" <<
191 absolute_path.value() << "'. " << error;
192 return std::string();
193 }
194 Remove(GenerateId(manifest.get(), absolute_path));
195
196 return Add(manifest.release(), absolute_path);
197 }
198
Reload(const std::string & extension_id)199 void ComponentLoader::Reload(const std::string& extension_id) {
200 for (RegisteredComponentExtensions::iterator it =
201 component_extensions_.begin(); it != component_extensions_.end();
202 ++it) {
203 if (it->extension_id == extension_id) {
204 Load(*it);
205 break;
206 }
207 }
208 }
209
Load(const ComponentExtensionInfo & info)210 void ComponentLoader::Load(const ComponentExtensionInfo& info) {
211 // TODO(abarth): We should REQUIRE_MODERN_MANIFEST_VERSION once we've updated
212 // our component extensions to the new manifest version.
213 int flags = Extension::REQUIRE_KEY;
214
215 std::string error;
216
217 scoped_refptr<const Extension> extension(Extension::Create(
218 info.root_directory,
219 Manifest::COMPONENT,
220 *info.manifest,
221 flags,
222 &error));
223 if (!extension.get()) {
224 LOG(ERROR) << error;
225 return;
226 }
227
228 CHECK_EQ(info.extension_id, extension->id()) << extension->name();
229 extension_service_->AddComponentExtension(extension.get());
230 }
231
Remove(const base::FilePath & root_directory)232 void ComponentLoader::Remove(const base::FilePath& root_directory) {
233 // Find the ComponentExtensionInfo for the extension.
234 RegisteredComponentExtensions::iterator it = component_extensions_.begin();
235 for (; it != component_extensions_.end(); ++it) {
236 if (it->root_directory == root_directory) {
237 Remove(GenerateId(it->manifest, root_directory));
238 break;
239 }
240 }
241 }
242
Remove(const std::string & id)243 void ComponentLoader::Remove(const std::string& id) {
244 RegisteredComponentExtensions::iterator it = component_extensions_.begin();
245 for (; it != component_extensions_.end(); ++it) {
246 if (it->extension_id == id) {
247 UnloadComponent(&(*it));
248 it = component_extensions_.erase(it);
249 break;
250 }
251 }
252 }
253
Exists(const std::string & id) const254 bool ComponentLoader::Exists(const std::string& id) const {
255 RegisteredComponentExtensions::const_iterator it =
256 component_extensions_.begin();
257 for (; it != component_extensions_.end(); ++it)
258 if (it->extension_id == id)
259 return true;
260 return false;
261 }
262
AddFileManagerExtension()263 void ComponentLoader::AddFileManagerExtension() {
264 #if defined(OS_CHROMEOS)
265 #ifndef NDEBUG
266 const CommandLine* command_line = CommandLine::ForCurrentProcess();
267 if (command_line->HasSwitch(switches::kFileManagerExtensionPath)) {
268 base::FilePath filemgr_extension_path(
269 command_line->GetSwitchValuePath(switches::kFileManagerExtensionPath));
270 AddWithNameAndDescription(IDR_FILEMANAGER_MANIFEST,
271 filemgr_extension_path,
272 IDS_FILEMANAGER_APP_NAME,
273 IDS_FILEMANAGER_APP_DESCRIPTION);
274 return;
275 }
276 #endif // NDEBUG
277 AddWithNameAndDescription(IDR_FILEMANAGER_MANIFEST,
278 base::FilePath(FILE_PATH_LITERAL("file_manager")),
279 IDS_FILEMANAGER_APP_NAME,
280 IDS_FILEMANAGER_APP_DESCRIPTION);
281 #endif // defined(OS_CHROMEOS)
282 }
283
AddVideoPlayerExtension()284 void ComponentLoader::AddVideoPlayerExtension() {
285 #if defined(OS_CHROMEOS)
286 Add(IDR_VIDEO_PLAYER_MANIFEST,
287 base::FilePath(FILE_PATH_LITERAL("video_player")));
288 #endif // defined(OS_CHROMEOS)
289 }
290
AddGalleryExtension()291 void ComponentLoader::AddGalleryExtension() {
292 #if defined(OS_CHROMEOS)
293 Add(IDR_GALLERY_MANIFEST, base::FilePath(FILE_PATH_LITERAL("gallery")));
294 #endif
295 }
296
AddHangoutServicesExtension()297 void ComponentLoader::AddHangoutServicesExtension() {
298 #if defined(GOOGLE_CHROME_BUILD) || defined(ENABLE_HANGOUT_SERVICES_EXTENSION)
299 Add(IDR_HANGOUT_SERVICES_MANIFEST,
300 base::FilePath(FILE_PATH_LITERAL("hangout_services")));
301 #endif
302 }
303
AddHotwordAudioVerificationApp()304 void ComponentLoader::AddHotwordAudioVerificationApp() {
305 CommandLine* command_line = CommandLine::ForCurrentProcess();
306 if (command_line->HasSwitch(switches::kEnableExperimentalHotwording)) {
307 Add(IDR_HOTWORD_AUDIO_VERIFICATION_MANIFEST,
308 base::FilePath(FILE_PATH_LITERAL("hotword_audio_verification")));
309 }
310 }
311
AddHotwordHelperExtension()312 void ComponentLoader::AddHotwordHelperExtension() {
313 if (HotwordServiceFactory::IsHotwordAllowed(browser_context_)) {
314 CommandLine* command_line = CommandLine::ForCurrentProcess();
315 if (command_line->HasSwitch(switches::kEnableExperimentalHotwording)) {
316 Add(IDR_HOTWORD_MANIFEST,
317 base::FilePath(FILE_PATH_LITERAL("hotword")));
318 } else {
319 Add(IDR_HOTWORD_HELPER_MANIFEST,
320 base::FilePath(FILE_PATH_LITERAL("hotword_helper")));
321 }
322 }
323 }
324
AddImageLoaderExtension()325 void ComponentLoader::AddImageLoaderExtension() {
326 #if defined(IMAGE_LOADER_EXTENSION)
327 Add(IDR_IMAGE_LOADER_MANIFEST,
328 base::FilePath(FILE_PATH_LITERAL("image_loader")));
329 #endif // defined(IMAGE_LOADER_EXTENSION)
330 }
331
AddNetworkSpeechSynthesisExtension()332 void ComponentLoader::AddNetworkSpeechSynthesisExtension() {
333 Add(IDR_NETWORK_SPEECH_SYNTHESIS_MANIFEST,
334 base::FilePath(FILE_PATH_LITERAL("network_speech_synthesis")));
335 }
336
337 #if defined(OS_CHROMEOS)
AddChromeVoxExtension(const base::Closure & done_cb)338 void ComponentLoader::AddChromeVoxExtension(
339 const base::Closure& done_cb) {
340 DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
341 base::FilePath resources_path;
342 PathService::Get(chrome::DIR_RESOURCES, &resources_path);
343
344 base::FilePath chromevox_path =
345 resources_path.Append(extension_misc::kChromeVoxExtensionPath);
346
347 const CommandLine* command_line = CommandLine::ForCurrentProcess();
348 bool is_chromevox_next =
349 command_line->HasSwitch(chromeos::switches::kEnableChromeVoxNext);
350 bool is_guest = command_line->HasSwitch(chromeos::switches::kGuestSession);
351 const char* manifest_filename;
352 if (is_chromevox_next) {
353 manifest_filename =
354 is_guest ? extension_misc::kChromeVoxNextGuestManifestFilename
355 : extension_misc::kChromeVoxNextManifestFilename;
356 } else {
357 manifest_filename =
358 is_guest ? extension_misc::kChromeVoxGuestManifestFilename
359 : extension_misc::kChromeVoxManifestFilename;
360 }
361 BrowserThread::PostTaskAndReplyWithResult(
362 BrowserThread::FILE,
363 FROM_HERE,
364 base::Bind(&LoadManifestOnFileThread, chromevox_path, manifest_filename),
365 base::Bind(&ComponentLoader::AddChromeVoxExtensionWithManifest,
366 weak_factory_.GetWeakPtr(),
367 chromevox_path,
368 done_cb));
369 }
370
AddChromeVoxExtensionWithManifest(const base::FilePath & chromevox_path,const base::Closure & done_cb,scoped_ptr<base::DictionaryValue> manifest)371 void ComponentLoader::AddChromeVoxExtensionWithManifest(
372 const base::FilePath& chromevox_path,
373 const base::Closure& done_cb,
374 scoped_ptr<base::DictionaryValue> manifest) {
375 DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
376 std::string extension_id = Add(manifest.release(), chromevox_path);
377 CHECK_EQ(extension_misc::kChromeVoxExtensionId, extension_id);
378 if (!done_cb.is_null())
379 done_cb.Run();
380 }
381
AddChromeOsSpeechSynthesisExtension()382 std::string ComponentLoader::AddChromeOsSpeechSynthesisExtension() {
383 const CommandLine* command_line = CommandLine::ForCurrentProcess();
384 int idr = command_line->HasSwitch(chromeos::switches::kGuestSession) ?
385 IDR_SPEECH_SYNTHESIS_GUEST_MANIFEST : IDR_SPEECH_SYNTHESIS_MANIFEST;
386 std::string id = Add(idr,
387 base::FilePath(extension_misc::kSpeechSynthesisExtensionPath));
388 EnableFileSystemInGuestMode(id);
389 return id;
390 }
391 #endif
392
AddWithNameAndDescription(int manifest_resource_id,const base::FilePath & root_directory,int name_string_id,int description_string_id)393 void ComponentLoader::AddWithNameAndDescription(
394 int manifest_resource_id,
395 const base::FilePath& root_directory,
396 int name_string_id,
397 int description_string_id) {
398 std::string manifest_contents =
399 ResourceBundle::GetSharedInstance().GetRawDataResource(
400 manifest_resource_id).as_string();
401
402 // The Value is kept for the lifetime of the ComponentLoader. This is
403 // required in case LoadAll() is called again.
404 base::DictionaryValue* manifest = ParseManifest(manifest_contents);
405
406 if (manifest) {
407 manifest->SetString(manifest_keys::kName,
408 l10n_util::GetStringUTF8(name_string_id));
409 manifest->SetString(manifest_keys::kDescription,
410 l10n_util::GetStringUTF8(description_string_id));
411 Add(manifest, root_directory);
412 }
413 }
414
AddChromeApp()415 void ComponentLoader::AddChromeApp() {
416 #if defined(ENABLE_APP_LIST)
417 AddWithNameAndDescription(IDR_CHROME_APP_MANIFEST,
418 base::FilePath(FILE_PATH_LITERAL("chrome_app")),
419 IDS_SHORT_PRODUCT_NAME,
420 IDS_CHROME_SHORTCUT_DESCRIPTION);
421 #endif
422 }
423
AddKeyboardApp()424 void ComponentLoader::AddKeyboardApp() {
425 #if defined(OS_CHROMEOS)
426 Add(IDR_KEYBOARD_MANIFEST, base::FilePath(FILE_PATH_LITERAL("keyboard")));
427 #endif
428 }
429
AddWebStoreApp()430 void ComponentLoader::AddWebStoreApp() {
431 AddWithNameAndDescription(IDR_WEBSTORE_MANIFEST,
432 base::FilePath(FILE_PATH_LITERAL("web_store")),
433 IDS_WEBSTORE_NAME_STORE,
434 IDS_WEBSTORE_APP_DESCRIPTION);
435 }
436
437 // static
EnableBackgroundExtensionsForTesting()438 void ComponentLoader::EnableBackgroundExtensionsForTesting() {
439 enable_background_extensions_during_testing = true;
440 }
441
AddDefaultComponentExtensions(bool skip_session_components)442 void ComponentLoader::AddDefaultComponentExtensions(
443 bool skip_session_components) {
444 // Do not add component extensions that have background pages here -- add them
445 // to AddDefaultComponentExtensionsWithBackgroundPages.
446 #if defined(OS_CHROMEOS)
447 Add(IDR_MOBILE_MANIFEST,
448 base::FilePath(FILE_PATH_LITERAL("/usr/share/chromeos-assets/mobile")));
449
450 #if defined(GOOGLE_CHROME_BUILD)
451 if (browser_defaults::enable_help_app) {
452 Add(IDR_HELP_MANIFEST, base::FilePath(FILE_PATH_LITERAL(
453 "/usr/share/chromeos-assets/helpapp")));
454 }
455 #endif
456
457 // Skip all other extensions that require user session presence.
458 if (!skip_session_components) {
459 const CommandLine* command_line = CommandLine::ForCurrentProcess();
460 if (!command_line->HasSwitch(chromeos::switches::kGuestSession))
461 Add(IDR_BOOKMARKS_MANIFEST,
462 base::FilePath(FILE_PATH_LITERAL("bookmark_manager")));
463
464 Add(IDR_CROSH_BUILTIN_MANIFEST, base::FilePath(FILE_PATH_LITERAL(
465 "/usr/share/chromeos-assets/crosh_builtin")));
466 }
467 #else // !defined(OS_CHROMEOS)
468 DCHECK(!skip_session_components);
469 Add(IDR_BOOKMARKS_MANIFEST,
470 base::FilePath(FILE_PATH_LITERAL("bookmark_manager")));
471 // Cloud Print component app. Not required on Chrome OS.
472 Add(IDR_CLOUDPRINT_MANIFEST,
473 base::FilePath(FILE_PATH_LITERAL("cloud_print")));
474 #endif
475
476 if (!skip_session_components) {
477 AddWebStoreApp();
478 AddChromeApp();
479 }
480
481 AddKeyboardApp();
482
483 AddDefaultComponentExtensionsWithBackgroundPages(skip_session_components);
484 }
485
AddDefaultComponentExtensionsForKioskMode(bool skip_session_components)486 void ComponentLoader::AddDefaultComponentExtensionsForKioskMode(
487 bool skip_session_components) {
488 // No component extension for kiosk app launch splash screen.
489 if (skip_session_components)
490 return;
491
492 // Component extensions needed for kiosk apps.
493 AddFileManagerExtension();
494
495 // Add virtual keyboard.
496 AddKeyboardApp();
497 }
498
AddDefaultComponentExtensionsWithBackgroundPages(bool skip_session_components)499 void ComponentLoader::AddDefaultComponentExtensionsWithBackgroundPages(
500 bool skip_session_components) {
501 const CommandLine* command_line = CommandLine::ForCurrentProcess();
502
503 // Component extensions with background pages are not enabled during tests
504 // because they generate a lot of background behavior that can interfere.
505 if (!enable_background_extensions_during_testing &&
506 (command_line->HasSwitch(switches::kTestType) ||
507 command_line->HasSwitch(
508 switches::kDisableComponentExtensionsWithBackgroundPages))) {
509 return;
510 }
511
512 #if defined(OS_CHROMEOS) && defined(GOOGLE_CHROME_BUILD)
513 // Since this is a v2 app it has a background page.
514 AddWithNameAndDescription(IDR_GENIUS_APP_MANIFEST,
515 base::FilePath(FILE_PATH_LITERAL(
516 "/usr/share/chromeos-assets/genius_app")),
517 IDS_GENIUS_APP_NAME,
518 IDS_GENIUS_APP_DESCRIPTION);
519 #endif
520
521 if (!skip_session_components) {
522 AddVideoPlayerExtension();
523 AddFileManagerExtension();
524 AddGalleryExtension();
525
526 AddHangoutServicesExtension();
527 AddHotwordAudioVerificationApp();
528 AddHotwordHelperExtension();
529 AddImageLoaderExtension();
530
531 #if defined(ENABLE_SETTINGS_APP)
532 Add(IDR_SETTINGS_APP_MANIFEST,
533 base::FilePath(FILE_PATH_LITERAL("settings_app")));
534 #endif
535 }
536
537 // If (!enable_background_extensions_during_testing || this isn't a test)
538 // install_feedback = false;
539 bool install_feedback = enable_background_extensions_during_testing;
540 #if defined(GOOGLE_CHROME_BUILD)
541 install_feedback = true;
542 #endif // defined(GOOGLE_CHROME_BUILD)
543 if (install_feedback)
544 Add(IDR_FEEDBACK_MANIFEST, base::FilePath(FILE_PATH_LITERAL("feedback")));
545
546 #if defined(OS_CHROMEOS)
547 if (!skip_session_components) {
548 #if defined(GOOGLE_CHROME_BUILD)
549 if (!command_line->HasSwitch(
550 chromeos::switches::kDisableOfficeEditingComponentApp)) {
551 std::string id = Add(IDR_QUICKOFFICE_MANIFEST, base::FilePath(
552 FILE_PATH_LITERAL("/usr/share/chromeos-assets/quickoffice")));
553 EnableFileSystemInGuestMode(id);
554 }
555 #endif // defined(GOOGLE_CHROME_BUILD)
556
557 Add(IDR_ECHO_MANIFEST,
558 base::FilePath(FILE_PATH_LITERAL("/usr/share/chromeos-assets/echo")));
559
560 if (!command_line->HasSwitch(chromeos::switches::kGuestSession)) {
561 Add(IDR_WALLPAPERMANAGER_MANIFEST,
562 base::FilePath(FILE_PATH_LITERAL("chromeos/wallpaper_manager")));
563 }
564
565 Add(IDR_FIRST_RUN_DIALOG_MANIFEST,
566 base::FilePath(FILE_PATH_LITERAL("chromeos/first_run/app")));
567
568 Add(IDR_NETWORK_CONFIGURATION_MANIFEST,
569 base::FilePath(FILE_PATH_LITERAL("chromeos/network_configuration")));
570
571 Add(IDR_CONNECTIVITY_DIAGNOSTICS_MANIFEST,
572 base::FilePath(extension_misc::kConnectivityDiagnosticsPath));
573 Add(IDR_CONNECTIVITY_DIAGNOSTICS_LAUNCHER_MANIFEST,
574 base::FilePath(extension_misc::kConnectivityDiagnosticsLauncherPath));
575 }
576
577 // Load ChromeVox extension now if spoken feedback is enabled.
578 if (chromeos::AccessibilityManager::Get() &&
579 chromeos::AccessibilityManager::Get()->IsSpokenFeedbackEnabled()) {
580 AddChromeVoxExtension(base::Closure());
581 }
582 #endif // defined(OS_CHROMEOS)
583
584 #if defined(ENABLE_GOOGLE_NOW)
585 const char kEnablePrefix[] = "Enable";
586 const char kFieldTrialName[] = "GoogleNow";
587 std::string enable_prefix(kEnablePrefix);
588 std::string field_trial_result =
589 base::FieldTrialList::FindFullName(kFieldTrialName);
590
591 bool enabled_via_field_trial =
592 field_trial_result.compare(0, enable_prefix.length(), enable_prefix) == 0;
593
594 // Enable the feature on trybots and trunk builds.
595 bool enabled_via_trunk_build =
596 chrome::VersionInfo::GetChannel() == chrome::VersionInfo::CHANNEL_UNKNOWN;
597
598 bool enabled = enabled_via_field_trial || enabled_via_trunk_build;
599
600 if (!skip_session_components && enabled) {
601 Add(IDR_GOOGLE_NOW_MANIFEST,
602 base::FilePath(FILE_PATH_LITERAL("google_now")));
603 }
604 #endif
605
606 #if defined(GOOGLE_CHROME_BUILD)
607 #if !defined(OS_CHROMEOS) // http://crbug.com/314799
608 AddNetworkSpeechSynthesisExtension();
609 #endif
610
611 #endif // defined(GOOGLE_CHROME_BUILD)
612
613 #if defined(ENABLE_PLUGINS)
614 base::FilePath pdf_path;
615 content::PluginService* plugin_service =
616 content::PluginService::GetInstance();
617 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kOutOfProcessPdf) &&
618 PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_path) &&
619 plugin_service->GetRegisteredPpapiPluginInfo(pdf_path)) {
620 Add(IDR_PDF_MANIFEST, base::FilePath(FILE_PATH_LITERAL("pdf")));
621 }
622 #endif
623
624 Add(IDR_CRYPTOTOKEN_MANIFEST,
625 base::FilePath(FILE_PATH_LITERAL("cryptotoken")));
626 }
627
UnloadComponent(ComponentExtensionInfo * component)628 void ComponentLoader::UnloadComponent(ComponentExtensionInfo* component) {
629 delete component->manifest;
630 if (extension_service_->is_ready()) {
631 extension_service_->
632 RemoveComponentExtension(component->extension_id);
633 }
634 }
635
EnableFileSystemInGuestMode(const std::string & id)636 void ComponentLoader::EnableFileSystemInGuestMode(const std::string& id) {
637 #if defined(OS_CHROMEOS)
638 const CommandLine* command_line = CommandLine::ForCurrentProcess();
639 if (command_line->HasSwitch(chromeos::switches::kGuestSession)) {
640 // TODO(dpolukhin): Hack to enable HTML5 temporary file system for
641 // the extension. Some component extensions don't work without temporary
642 // file system access. Make sure temporary file system is enabled in the off
643 // the record browser context (as that is the one used in guest session).
644 content::BrowserContext* off_the_record_context =
645 ExtensionsBrowserClient::Get()->GetOffTheRecordContext(
646 browser_context_);
647 GURL site = content::SiteInstance::GetSiteForURL(
648 off_the_record_context, Extension::GetBaseURLFromExtensionId(id));
649 storage::FileSystemContext* file_system_context =
650 content::BrowserContext::GetStoragePartitionForSite(
651 off_the_record_context, site)->GetFileSystemContext();
652 file_system_context->EnableTemporaryFileSystemInIncognito();
653 }
654 #endif
655 }
656
657 } // namespace extensions
658