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.
5 #include "chrome/browser/chromeos/customization_document.h"
10 #include "base/bind_helpers.h"
11 #include "base/file_util.h"
12 #include "base/files/file_path.h"
13 #include "base/json/json_reader.h"
14 #include "base/logging.h"
15 #include "base/memory/weak_ptr.h"
16 #include "base/metrics/histogram.h"
17 #include "base/path_service.h"
18 #include "base/prefs/pref_registry_simple.h"
19 #include "base/prefs/pref_service.h"
20 #include "base/strings/string_split.h"
21 #include "base/strings/string_util.h"
22 #include "base/strings/stringprintf.h"
23 #include "base/strings/utf_string_conversions.h"
24 #include "base/time/time.h"
25 #include "chrome/browser/browser_process.h"
26 #include "chrome/browser/chromeos/customization_wallpaper_downloader.h"
27 #include "chrome/browser/chromeos/extensions/default_app_order.h"
28 #include "chrome/browser/chromeos/login/wallpaper_manager.h"
29 #include "chrome/browser/chromeos/login/wizard_controller.h"
30 #include "chrome/browser/chromeos/net/delay_network_call.h"
31 #include "chrome/browser/extensions/external_loader.h"
32 #include "chrome/browser/extensions/external_provider_impl.h"
33 #include "chrome/browser/profiles/profile.h"
34 #include "chrome/browser/ui/app_list/app_list_syncable_service.h"
35 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
36 #include "chrome/common/chrome_paths.h"
37 #include "chrome/common/extensions/extension_constants.h"
38 #include "chrome/common/pref_names.h"
39 #include "chromeos/network/network_state.h"
40 #include "chromeos/network/network_state_handler.h"
41 #include "chromeos/system/statistics_provider.h"
42 #include "components/user_prefs/pref_registry_syncable.h"
43 #include "content/public/browser/browser_thread.h"
44 #include "net/base/load_flags.h"
45 #include "net/http/http_response_headers.h"
46 #include "net/http/http_status_code.h"
47 #include "net/url_request/url_fetcher.h"
48 #include "ui/base/l10n/l10n_util.h"
50 using content::BrowserThread;
55 // Manifest attributes names.
56 const char kVersionAttr[] = "version";
57 const char kDefaultAttr[] = "default";
58 const char kInitialLocaleAttr[] = "initial_locale";
59 const char kInitialTimezoneAttr[] = "initial_timezone";
60 const char kKeyboardLayoutAttr[] = "keyboard_layout";
61 const char kHwidMapAttr[] = "hwid_map";
62 const char kHwidMaskAttr[] = "hwid_mask";
63 const char kSetupContentAttr[] = "setup_content";
64 const char kEulaPageAttr[] = "eula_page";
65 const char kDefaultWallpaperAttr[] = "default_wallpaper";
66 const char kDefaultAppsAttr[] = "default_apps";
67 const char kLocalizedContent[] = "localized_content";
68 const char kDefaultAppsFolderName[] = "default_apps_folder_name";
70 const char kAcceptedManifestVersion[] = "1.0";
72 // Path to OEM partner startup customization manifest.
73 const char kStartupCustomizationManifestPath[] =
74 "/opt/oem/etc/startup_manifest.json";
76 // This is subdirectory relative to PathService(DIR_CHROMEOS_CUSTOM_WALLPAPERS),
77 // where downloaded (and resized) wallpaper is stored.
78 const char kCustomizationDefaultWallpaperDir[] = "customization";
80 // The original downloaded image file is stored under this name.
81 const char kCustomizationDefaultWallpaperDownloadedFile[] =
82 "default_downloaded_wallpaper.bin";
84 // Name of local state option that tracks if services customization has been
86 const char kServicesCustomizationAppliedPref[] = "ServicesCustomizationApplied";
88 // Maximum number of retries to fetch file if network is not available.
89 const int kMaxFetchRetries = 3;
91 // Delay between file fetch retries if network is not available.
92 const int kRetriesDelayInSec = 2;
94 // Name of profile option that tracks cached version of service customization.
95 const char kServicesCustomizationKey[] = "customization.manifest_cache";
97 // Empty customization document that doesn't customize anything.
98 const char kEmptyServicesCustomizationManifest[] = "{ \"version\": \"1.0\" }";
100 // Global overrider for ServicesCustomizationDocument for tests.
101 ServicesCustomizationDocument* g_test_services_customization_document = NULL;
103 // Services customization document load results reported via the
104 // "ServicesCustomization.LoadResult" histogram.
105 // It is append-only enum due to use in a histogram!
106 enum HistogramServicesCustomizationLoadResult {
107 HISTOGRAM_LOAD_RESULT_SUCCESS = 0,
108 HISTOGRAM_LOAD_RESULT_FILE_NOT_FOUND = 1,
109 HISTOGRAM_LOAD_RESULT_PARSING_ERROR = 2,
110 HISTOGRAM_LOAD_RESULT_RETRIES_FAIL = 3,
111 HISTOGRAM_LOAD_RESULT_MAX_VALUE = 4
114 void LogManifestLoadResult(HistogramServicesCustomizationLoadResult result) {
115 UMA_HISTOGRAM_ENUMERATION("ServicesCustomization.LoadResult",
117 HISTOGRAM_LOAD_RESULT_MAX_VALUE);
120 std::string GetLocaleSpecificStringImpl(
121 const base::DictionaryValue* root,
122 const std::string& locale,
123 const std::string& dictionary_name,
124 const std::string& entry_name) {
125 const base::DictionaryValue* dictionary_content = NULL;
126 if (!root || !root->GetDictionary(dictionary_name, &dictionary_content))
127 return std::string();
129 const base::DictionaryValue* locale_dictionary = NULL;
130 if (dictionary_content->GetDictionary(locale, &locale_dictionary)) {
132 if (locale_dictionary->GetString(entry_name, &result))
136 const base::DictionaryValue* default_dictionary = NULL;
137 if (dictionary_content->GetDictionary(kDefaultAttr, &default_dictionary)) {
139 if (default_dictionary->GetString(entry_name, &result))
143 return std::string();
146 void CheckWallpaperCacheExists(const base::FilePath& path, bool* exists) {
147 DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
149 *exists = base::PathExists(path);
152 } // anonymous namespace
154 // Template URL where to fetch OEM services customization manifest from.
155 const char ServicesCustomizationDocument::kManifestUrl[] =
156 "https://ssl.gstatic.com/chrome/chromeos-customization/%s.json";
158 // A custom extensions::ExternalLoader that the ServicesCustomizationDocument
159 // creates and uses to publish OEM default apps to the extensions system.
160 class ServicesCustomizationExternalLoader
161 : public extensions::ExternalLoader,
162 public base::SupportsWeakPtr<ServicesCustomizationExternalLoader> {
164 explicit ServicesCustomizationExternalLoader(Profile* profile)
165 : is_apps_set_(false), profile_(profile) {}
167 Profile* profile() { return profile_; }
169 // Used by the ServicesCustomizationDocument to update the current apps.
170 void SetCurrentApps(scoped_ptr<base::DictionaryValue> prefs) {
171 apps_.Swap(prefs.get());
176 // Implementation of extensions::ExternalLoader:
177 virtual void StartLoading() OVERRIDE {
179 ServicesCustomizationDocument::GetInstance()->StartFetching();
180 // In case of missing customization ID, SetCurrentApps will be called
181 // synchronously from StartFetching and this function will be called
182 // recursively so we need to return to avoid calling LoadFinished twice.
183 // In case of async load it is safe to return empty list because this
184 // provider didn't install any app yet so no app can be removed due to
185 // returning empty list.
190 prefs_.reset(apps_.DeepCopy());
191 VLOG(1) << "ServicesCustomization extension loader publishing "
192 << apps_.size() << " apps.";
197 virtual ~ServicesCustomizationExternalLoader() {}
201 base::DictionaryValue apps_;
204 DISALLOW_COPY_AND_ASSIGN(ServicesCustomizationExternalLoader);
207 // CustomizationDocument implementation. ---------------------------------------
209 CustomizationDocument::CustomizationDocument(
210 const std::string& accepted_version)
211 : accepted_version_(accepted_version) {}
213 CustomizationDocument::~CustomizationDocument() {}
215 bool CustomizationDocument::LoadManifestFromFile(
216 const base::FilePath& manifest_path) {
217 std::string manifest;
218 if (!base::ReadFileToString(manifest_path, &manifest))
220 return LoadManifestFromString(manifest);
223 bool CustomizationDocument::LoadManifestFromString(
224 const std::string& manifest) {
227 scoped_ptr<base::Value> root(base::JSONReader::ReadAndReturnError(manifest,
228 base::JSON_ALLOW_TRAILING_COMMAS, &error_code, &error));
229 if (error_code != base::JSONReader::JSON_NO_ERROR)
231 DCHECK(root.get() != NULL);
232 if (root.get() == NULL)
234 DCHECK(root->GetType() == base::Value::TYPE_DICTIONARY);
235 if (root->GetType() == base::Value::TYPE_DICTIONARY) {
236 root_.reset(static_cast<base::DictionaryValue*>(root.release()));
238 if (root_->GetString(kVersionAttr, &result) &&
239 result == accepted_version_)
242 LOG(ERROR) << "Wrong customization manifest version";
248 std::string CustomizationDocument::GetLocaleSpecificString(
249 const std::string& locale,
250 const std::string& dictionary_name,
251 const std::string& entry_name) const {
252 return GetLocaleSpecificStringImpl(
253 root_.get(), locale, dictionary_name, entry_name);
256 // StartupCustomizationDocument implementation. --------------------------------
258 StartupCustomizationDocument::StartupCustomizationDocument()
259 : CustomizationDocument(kAcceptedManifestVersion) {
261 // Loading manifest causes us to do blocking IO on UI thread.
262 // Temporarily allow it until we fix http://crosbug.com/11103
263 base::ThreadRestrictions::ScopedAllowIO allow_io;
264 LoadManifestFromFile(base::FilePath(kStartupCustomizationManifestPath));
266 Init(system::StatisticsProvider::GetInstance());
269 StartupCustomizationDocument::StartupCustomizationDocument(
270 system::StatisticsProvider* statistics_provider,
271 const std::string& manifest)
272 : CustomizationDocument(kAcceptedManifestVersion) {
273 LoadManifestFromString(manifest);
274 Init(statistics_provider);
277 StartupCustomizationDocument::~StartupCustomizationDocument() {}
279 StartupCustomizationDocument* StartupCustomizationDocument::GetInstance() {
280 return Singleton<StartupCustomizationDocument,
281 DefaultSingletonTraits<StartupCustomizationDocument> >::get();
284 void StartupCustomizationDocument::Init(
285 system::StatisticsProvider* statistics_provider) {
287 root_->GetString(kInitialLocaleAttr, &initial_locale_);
288 root_->GetString(kInitialTimezoneAttr, &initial_timezone_);
289 root_->GetString(kKeyboardLayoutAttr, &keyboard_layout_);
292 if (statistics_provider->GetMachineStatistic(
293 system::kHardwareClassKey, &hwid)) {
294 base::ListValue* hwid_list = NULL;
295 if (root_->GetList(kHwidMapAttr, &hwid_list)) {
296 for (size_t i = 0; i < hwid_list->GetSize(); ++i) {
297 base::DictionaryValue* hwid_dictionary = NULL;
298 std::string hwid_mask;
299 if (hwid_list->GetDictionary(i, &hwid_dictionary) &&
300 hwid_dictionary->GetString(kHwidMaskAttr, &hwid_mask)) {
301 if (MatchPattern(hwid, hwid_mask)) {
302 // If HWID for this machine matches some mask, use HWID specific
305 if (hwid_dictionary->GetString(kInitialLocaleAttr, &result))
306 initial_locale_ = result;
308 if (hwid_dictionary->GetString(kInitialTimezoneAttr, &result))
309 initial_timezone_ = result;
311 if (hwid_dictionary->GetString(kKeyboardLayoutAttr, &result))
312 keyboard_layout_ = result;
314 // Don't break here to allow other entires to be applied if match.
316 LOG(ERROR) << "Syntax error in customization manifest";
321 LOG(ERROR) << "HWID is missing in machine statistics";
325 // If manifest doesn't exist still apply values from VPD.
326 statistics_provider->GetMachineStatistic(kInitialLocaleAttr,
328 statistics_provider->GetMachineStatistic(kInitialTimezoneAttr,
330 statistics_provider->GetMachineStatistic(kKeyboardLayoutAttr,
332 configured_locales_.resize(0);
333 base::SplitString(initial_locale_, ',', &configured_locales_);
335 // Convert ICU locale to chrome ("en_US" to "en-US", etc.).
336 std::for_each(configured_locales_.begin(),
337 configured_locales_.end(),
338 l10n_util::GetCanonicalLocale);
340 // Let's always have configured_locales_.front() a valid entry.
341 if (configured_locales_.size() == 0)
342 configured_locales_.push_back(std::string());
345 const std::vector<std::string>&
346 StartupCustomizationDocument::configured_locales() const {
347 return configured_locales_;
350 const std::string& StartupCustomizationDocument::initial_locale_default()
352 DCHECK(configured_locales_.size() > 0);
353 return configured_locales_.front();
356 std::string StartupCustomizationDocument::GetEULAPage(
357 const std::string& locale) const {
358 return GetLocaleSpecificString(locale, kSetupContentAttr, kEulaPageAttr);
361 // ServicesCustomizationDocument implementation. -------------------------------
363 class ServicesCustomizationDocument::ApplyingTask {
365 // Registers in ServicesCustomizationDocument;
366 explicit ApplyingTask(ServicesCustomizationDocument* document);
368 // Do not automatically deregister as we might be called on invalid thread.
371 // Mark task finished and check for customization applied.
372 void Finished(bool success);
375 ServicesCustomizationDocument* document_;
377 // This is error-checking flag to prevent destroying unfinished task
382 ServicesCustomizationDocument::ApplyingTask::ApplyingTask(
383 ServicesCustomizationDocument* document)
384 : document_(document), engaged_(true) {
385 document->ApplyingTaskStarted();
388 ServicesCustomizationDocument::ApplyingTask::~ApplyingTask() {
392 void ServicesCustomizationDocument::ApplyingTask::Finished(bool success) {
396 document_->ApplyingTaskFinished(success);
400 ServicesCustomizationDocument::ServicesCustomizationDocument()
401 : CustomizationDocument(kAcceptedManifestVersion),
403 fetch_started_(false),
405 base::TimeDelta::FromMilliseconds(kDefaultNetworkRetryDelayMS)),
406 apply_tasks_started_(0),
407 apply_tasks_finished_(0),
408 apply_tasks_success_(0),
409 weak_ptr_factory_(this) {
412 ServicesCustomizationDocument::ServicesCustomizationDocument(
413 const std::string& manifest)
414 : CustomizationDocument(kAcceptedManifestVersion),
416 base::TimeDelta::FromMilliseconds(kDefaultNetworkRetryDelayMS)),
417 apply_tasks_started_(0),
418 apply_tasks_finished_(0),
419 apply_tasks_success_(0),
420 weak_ptr_factory_(this) {
421 LoadManifestFromString(manifest);
424 ServicesCustomizationDocument::~ServicesCustomizationDocument() {}
427 ServicesCustomizationDocument* ServicesCustomizationDocument::GetInstance() {
428 if (g_test_services_customization_document)
429 return g_test_services_customization_document;
431 return Singleton<ServicesCustomizationDocument,
432 DefaultSingletonTraits<ServicesCustomizationDocument> >::get();
436 void ServicesCustomizationDocument::RegisterPrefs(
437 PrefRegistrySimple* registry) {
438 registry->RegisterBooleanPref(kServicesCustomizationAppliedPref, false);
439 registry->RegisterStringPref(prefs::kCustomizationDefaultWallpaperURL,
444 void ServicesCustomizationDocument::RegisterProfilePrefs(
445 user_prefs::PrefRegistrySyncable* registry) {
446 registry->RegisterDictionaryPref(
447 kServicesCustomizationKey,
448 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
452 bool ServicesCustomizationDocument::WasOOBECustomizationApplied() {
453 PrefService* prefs = g_browser_process->local_state();
454 // prefs can be NULL in some tests.
456 return prefs->GetBoolean(kServicesCustomizationAppliedPref);
462 void ServicesCustomizationDocument::SetApplied(bool val) {
463 PrefService* prefs = g_browser_process->local_state();
464 // prefs can be NULL in some tests.
466 prefs->SetBoolean(kServicesCustomizationAppliedPref, val);
470 base::FilePath ServicesCustomizationDocument::GetCustomizedWallpaperCacheDir() {
471 base::FilePath custom_wallpaper_dir;
472 if (!PathService::Get(chrome::DIR_CHROMEOS_CUSTOM_WALLPAPERS,
473 &custom_wallpaper_dir)) {
474 LOG(DFATAL) << "Unable to get custom wallpaper dir.";
475 return base::FilePath();
477 return custom_wallpaper_dir.Append(kCustomizationDefaultWallpaperDir);
482 ServicesCustomizationDocument::GetCustomizedWallpaperDownloadedFileName() {
483 const base::FilePath dir = GetCustomizedWallpaperCacheDir();
488 return dir.Append(kCustomizationDefaultWallpaperDownloadedFile);
491 void ServicesCustomizationDocument::EnsureCustomizationApplied() {
492 if (WasOOBECustomizationApplied())
495 // When customization manifest is fetched, applying will start automatically.
503 ServicesCustomizationDocument::EnsureCustomizationAppliedClosure() {
504 return base::Bind(&ServicesCustomizationDocument::EnsureCustomizationApplied,
505 weak_ptr_factory_.GetWeakPtr());
508 void ServicesCustomizationDocument::StartFetching() {
509 if (IsReady() || fetch_started_)
512 if (!url_.is_valid()) {
513 std::string customization_id;
514 chromeos::system::StatisticsProvider* provider =
515 chromeos::system::StatisticsProvider::GetInstance();
516 if (provider->GetMachineStatistic(system::kCustomizationIdKey,
517 &customization_id) &&
518 !customization_id.empty()) {
519 url_ = GURL(base::StringPrintf(
520 kManifestUrl, StringToLowerASCII(customization_id).c_str()));
522 // Remember that there is no customization ID in VPD.
523 OnCustomizationNotFound();
528 if (url_.is_valid()) {
529 fetch_started_ = true;
530 if (url_.SchemeIsFile()) {
531 BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
532 base::Bind(&ServicesCustomizationDocument::ReadFileInBackground,
533 weak_ptr_factory_.GetWeakPtr(),
534 base::FilePath(url_.path())));
542 void ServicesCustomizationDocument::ReadFileInBackground(
543 base::WeakPtr<ServicesCustomizationDocument> self,
544 const base::FilePath& file) {
545 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
547 std::string manifest;
548 if (!base::ReadFileToString(file, &manifest)) {
550 LOG(ERROR) << "Failed to load services customization manifest from: "
554 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
555 base::Bind(&ServicesCustomizationDocument::OnManifesteRead,
560 void ServicesCustomizationDocument::OnManifesteRead(
561 const std::string& manifest) {
562 if (!manifest.empty())
563 LoadManifestFromString(manifest);
565 fetch_started_ = false;
568 void ServicesCustomizationDocument::StartFileFetch() {
569 DelayNetworkCall(base::Bind(&ServicesCustomizationDocument::DoStartFileFetch,
570 weak_ptr_factory_.GetWeakPtr()),
574 void ServicesCustomizationDocument::DoStartFileFetch() {
575 url_fetcher_.reset(net::URLFetcher::Create(
576 url_, net::URLFetcher::GET, this));
577 url_fetcher_->SetRequestContext(g_browser_process->system_request_context());
578 url_fetcher_->AddExtraRequestHeader("Accept: application/json");
579 url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
580 net::LOAD_DO_NOT_SAVE_COOKIES |
581 net::LOAD_DISABLE_CACHE |
582 net::LOAD_DO_NOT_SEND_AUTH_DATA);
583 url_fetcher_->Start();
586 bool ServicesCustomizationDocument::LoadManifestFromString(
587 const std::string& manifest) {
588 if (CustomizationDocument::LoadManifestFromString(manifest)) {
589 LogManifestLoadResult(HISTOGRAM_LOAD_RESULT_SUCCESS);
594 LogManifestLoadResult(HISTOGRAM_LOAD_RESULT_PARSING_ERROR);
598 void ServicesCustomizationDocument::OnManifestLoaded() {
599 if (!WasOOBECustomizationApplied())
600 ApplyOOBECustomization();
602 scoped_ptr<base::DictionaryValue> prefs =
603 GetDefaultAppsInProviderFormat(*root_);
604 for (ExternalLoaders::iterator it = external_loaders_.begin();
605 it != external_loaders_.end(); ++it) {
607 UpdateCachedManifest((*it)->profile());
608 (*it)->SetCurrentApps(
609 scoped_ptr<base::DictionaryValue>(prefs->DeepCopy()));
610 SetOemFolderName((*it)->profile(), *root_);
615 void ServicesCustomizationDocument::OnURLFetchComplete(
616 const net::URLFetcher* source) {
617 std::string mime_type;
619 if (source->GetStatus().is_success() &&
620 source->GetResponseCode() == net::HTTP_OK &&
621 source->GetResponseHeaders()->GetMimeType(&mime_type) &&
622 mime_type == "application/json" &&
623 source->GetResponseAsString(&data)) {
624 LoadManifestFromString(data);
625 } else if (source->GetResponseCode() == net::HTTP_NOT_FOUND) {
626 LOG(ERROR) << "Customization manifest is missing on server: "
627 << source->GetURL().spec();
628 OnCustomizationNotFound();
630 if (num_retries_ < kMaxFetchRetries) {
632 content::BrowserThread::PostDelayedTask(
633 content::BrowserThread::UI,
635 base::Bind(&ServicesCustomizationDocument::StartFileFetch,
636 weak_ptr_factory_.GetWeakPtr()),
637 base::TimeDelta::FromSeconds(kRetriesDelayInSec));
640 // This doesn't stop fetching manifest on next restart.
641 LOG(ERROR) << "URL fetch for services customization failed:"
642 << " response code = " << source->GetResponseCode()
643 << " URL = " << source->GetURL().spec();
645 LogManifestLoadResult(HISTOGRAM_LOAD_RESULT_RETRIES_FAIL);
647 fetch_started_ = false;
650 bool ServicesCustomizationDocument::ApplyOOBECustomization() {
651 if (apply_tasks_started_)
654 CheckAndApplyWallpaper();
658 bool ServicesCustomizationDocument::GetDefaultWallpaperUrl(
659 GURL* out_url) const {
664 if (!root_->GetString(kDefaultWallpaperAttr, &url))
667 *out_url = GURL(url);
671 bool ServicesCustomizationDocument::GetDefaultApps(
672 std::vector<std::string>* ids) const {
677 base::ListValue* apps_list = NULL;
678 if (!root_->GetList(kDefaultAppsAttr, &apps_list))
681 for (size_t i = 0; i < apps_list->GetSize(); ++i) {
683 if (apps_list->GetString(i, &app_id)) {
684 ids->push_back(app_id);
686 LOG(ERROR) << "Wrong format of default application list";
694 std::string ServicesCustomizationDocument::GetOemAppsFolderName(
695 const std::string& locale) const {
697 return std::string();
699 return GetOemAppsFolderNameImpl(locale, *root_);
702 scoped_ptr<base::DictionaryValue>
703 ServicesCustomizationDocument::GetDefaultAppsInProviderFormat(
704 const base::DictionaryValue& root) {
705 scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
706 const base::ListValue* apps_list = NULL;
707 if (root.GetList(kDefaultAppsAttr, &apps_list)) {
708 for (size_t i = 0; i < apps_list->GetSize(); ++i) {
710 if (apps_list->GetString(i, &app_id)) {
711 base::DictionaryValue* entry = new base::DictionaryValue;
712 entry->SetString(extensions::ExternalProviderImpl::kExternalUpdateUrl,
713 extension_urls::GetWebstoreUpdateUrl().spec());
714 prefs->Set(app_id, entry);
716 LOG(ERROR) << "Wrong format of default application list";
726 void ServicesCustomizationDocument::UpdateCachedManifest(Profile* profile) {
727 profile->GetPrefs()->Set(kServicesCustomizationKey, *root_);
730 extensions::ExternalLoader* ServicesCustomizationDocument::CreateExternalLoader(
732 ServicesCustomizationExternalLoader* loader =
733 new ServicesCustomizationExternalLoader(profile);
734 external_loaders_.push_back(loader->AsWeakPtr());
737 UpdateCachedManifest(profile);
738 loader->SetCurrentApps(GetDefaultAppsInProviderFormat(*root_));
739 SetOemFolderName(profile, *root_);
741 const base::DictionaryValue* root =
742 profile->GetPrefs()->GetDictionary(kServicesCustomizationKey);
744 if (root && root->GetString(kVersionAttr, &version)) {
745 // If version exists, profile has cached version of customization.
746 loader->SetCurrentApps(GetDefaultAppsInProviderFormat(*root));
747 SetOemFolderName(profile, *root);
749 // StartFetching will be called from ServicesCustomizationExternalLoader
750 // when StartLoading is called. We can't initiate manifest fetch here
751 // because caller may never call StartLoading for the provider.
758 void ServicesCustomizationDocument::OnCustomizationNotFound() {
759 LogManifestLoadResult(HISTOGRAM_LOAD_RESULT_FILE_NOT_FOUND);
760 LoadManifestFromString(kEmptyServicesCustomizationManifest);
763 void ServicesCustomizationDocument::SetOemFolderName(
765 const base::DictionaryValue& root) {
766 std::string locale = g_browser_process->GetApplicationLocale();
767 std::string name = GetOemAppsFolderNameImpl(locale, root);
769 name = default_app_order::GetOemAppsFolderName();
771 app_list::AppListSyncableService* service =
772 app_list::AppListSyncableServiceFactory::GetForProfile(profile);
774 LOG(WARNING) << "AppListSyncableService is not ready for setting OEM "
778 service->SetOemFolderName(name);
782 std::string ServicesCustomizationDocument::GetOemAppsFolderNameImpl(
783 const std::string& locale,
784 const base::DictionaryValue& root) const {
785 return GetLocaleSpecificStringImpl(
786 &root, locale, kLocalizedContent, kDefaultAppsFolderName);
790 void ServicesCustomizationDocument::InitializeForTesting() {
791 g_test_services_customization_document = new ServicesCustomizationDocument;
792 g_test_services_customization_document->network_delay_ = base::TimeDelta();
796 void ServicesCustomizationDocument::ShutdownForTesting() {
797 delete g_test_services_customization_document;
798 g_test_services_customization_document = NULL;
801 void ServicesCustomizationDocument::StartOEMWallpaperDownload(
802 const GURL& wallpaper_url,
803 scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying) {
804 DCHECK(wallpaper_url.is_valid());
806 const base::FilePath dir = GetCustomizedWallpaperCacheDir();
807 const base::FilePath file = GetCustomizedWallpaperDownloadedFileName();
808 if (dir.empty() || file.empty()) {
810 applying->Finished(false);
814 wallpaper_downloader_.reset(new CustomizationWallpaperDownloader(
815 g_browser_process->system_request_context(),
819 base::Bind(&ServicesCustomizationDocument::OnOEMWallpaperDownloaded,
820 weak_ptr_factory_.GetWeakPtr(),
821 base::Passed(applying.Pass()))));
823 wallpaper_downloader_->Start();
826 void ServicesCustomizationDocument::CheckAndApplyWallpaper() {
827 if (wallpaper_downloader_.get()) {
828 VLOG(1) << "CheckAndApplyWallpaper(): download has already started.";
831 scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying(
832 new ServicesCustomizationDocument::ApplyingTask(this));
835 if (!GetDefaultWallpaperUrl(&wallpaper_url)) {
836 PrefService* pref_service = g_browser_process->local_state();
837 std::string current_url =
838 pref_service->GetString(prefs::kCustomizationDefaultWallpaperURL);
839 if (!current_url.empty()) {
840 VLOG(1) << "ServicesCustomizationDocument::CheckAndApplyWallpaper() : "
841 << "No wallpaper URL attribute in customization document, "
842 << "but current value is non-empty: '" << current_url
845 applying->Finished(true);
849 // Should fail if this ever happens in tests.
850 DCHECK(wallpaper_url.is_valid());
851 if (!wallpaper_url.is_valid()) {
852 if (!wallpaper_url.is_empty()) {
853 LOG(WARNING) << "Invalid Customized Wallpaper URL '"
854 << wallpaper_url.spec() << "'.";
856 applying->Finished(false);
860 scoped_ptr<bool> exists(new bool(false));
862 base::Closure check_file_exists =
863 base::Bind(&CheckWallpaperCacheExists,
864 GetCustomizedWallpaperDownloadedFileName(),
865 base::Unretained(exists.get()));
866 base::Closure on_checked_closure =
867 base::Bind(&ServicesCustomizationDocument::OnCheckedWallpaperCacheExists,
868 weak_ptr_factory_.GetWeakPtr(),
869 base::Passed(exists.Pass()),
870 base::Passed(applying.Pass()));
871 if (!content::BrowserThread::PostBlockingPoolTaskAndReply(
872 FROM_HERE, check_file_exists, on_checked_closure)) {
873 LOG(WARNING) << "Failed to start check Wallpaper cache exists.";
877 void ServicesCustomizationDocument::OnCheckedWallpaperCacheExists(
878 scoped_ptr<bool> exists,
879 scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying) {
880 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
884 ApplyWallpaper(*exists, applying.Pass());
887 void ServicesCustomizationDocument::ApplyWallpaper(
888 bool default_wallpaper_file_exists,
889 scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying) {
891 const bool wallpaper_url_present = GetDefaultWallpaperUrl(&wallpaper_url);
893 PrefService* pref_service = g_browser_process->local_state();
895 std::string current_url =
896 pref_service->GetString(prefs::kCustomizationDefaultWallpaperURL);
897 if (current_url != wallpaper_url.spec()) {
898 if (wallpaper_url_present) {
899 VLOG(1) << "ServicesCustomizationDocument::ApplyWallpaper() : "
900 << "Wallpaper URL in customization document '"
901 << wallpaper_url.spec() << "' differs from current '"
902 << current_url << "'."
903 << (GURL(current_url).is_valid() && default_wallpaper_file_exists
907 VLOG(1) << "ServicesCustomizationDocument::ApplyWallpaper() : "
908 << "No wallpaper URL attribute in customization document, "
909 << "but current value is non-empty: '" << current_url
913 if (!wallpaper_url_present) {
914 applying->Finished(true);
918 DCHECK(wallpaper_url.is_valid());
920 // Never update system-wide wallpaper (i.e. do not check
921 // current_url == wallpaper_url.spec() )
922 if (GURL(current_url).is_valid() && default_wallpaper_file_exists) {
924 << "ServicesCustomizationDocument::ApplyWallpaper() : reuse existing";
925 OnOEMWallpaperDownloaded(applying.Pass(), true, GURL(current_url));
928 << "ServicesCustomizationDocument::ApplyWallpaper() : start download";
929 StartOEMWallpaperDownload(wallpaper_url, applying.Pass());
933 void ServicesCustomizationDocument::OnOEMWallpaperDownloaded(
934 scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying,
936 const GURL& wallpaper_url) {
938 DCHECK(wallpaper_url.is_valid());
940 VLOG(1) << "Setting default wallpaper to '"
941 << GetCustomizedWallpaperDownloadedFileName().value() << "' ('"
942 << wallpaper_url.spec() << "')";
943 WallpaperManager::Get()->SetCustomizedDefaultWallpaper(
945 GetCustomizedWallpaperDownloadedFileName(),
946 GetCustomizedWallpaperCacheDir());
948 wallpaper_downloader_.reset();
949 applying->Finished(success);
952 void ServicesCustomizationDocument::ApplyingTaskStarted() {
953 ++apply_tasks_started_;
956 void ServicesCustomizationDocument::ApplyingTaskFinished(bool success) {
957 DCHECK_GT(apply_tasks_started_, apply_tasks_finished_);
958 ++apply_tasks_finished_;
960 apply_tasks_success_ += success;
962 if (apply_tasks_started_ != apply_tasks_finished_)
965 if (apply_tasks_success_ == apply_tasks_finished_)
969 } // namespace chromeos