Set OEM apps folder name from customization manifest

chrome/browser/chromeos/customization_document.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/chromeos/customization_document.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/net/delay_network_call.h"
 #include "chrome/browser/extensions/external_loader.h"
 #include "chrome/browser/extensions/external_provider_impl.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/app_list/app_list_syncable_service.h"
+#include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/system/statistics_provider.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 
 using content::BrowserThread;
 
 // Manifest attributes names.
 
 namespace {
 
 const char kVersionAttr[] = "version";
 const char kDefaultAttr[] = "default";
 const char kInitialLocaleAttr[] = "initial_locale";
 const char kInitialTimezoneAttr[] = "initial_timezone";
 const char kKeyboardLayoutAttr[] = "keyboard_layout";
 const char kHwidMapAttr[] = "hwid_map";
 const char kHwidMaskAttr[] = "hwid_mask";
 const char kSetupContentAttr[] = "setup_content";
 const char kEulaPageAttr[] = "eula_page";
 const char kDefaultWallpaperAttr[] = "default_wallpaper";
 const char kDefaultAppsAttr[] = "default_apps";
+const char kLocalizedContent[] = "localized_content";
+const char kDefaultAppsFolderName[] = "default_apps_folder_name";
 
 const char kAcceptedManifestVersion[] = "1.0";
 
 // Path to OEM partner startup customization manifest.
 const char kStartupCustomizationManifestPath[] =
     "/opt/oem/etc/startup_manifest.json";
 
 // Name of local state option that tracks if services customization has been
 // applied.
 const char kServicesCustomizationAppliedPref[] = "ServicesCustomizationApplied";
@@ skipping 20 matching lines @@
   HISTOGRAM_LOAD_RESULT_RETRIES_FAIL = 3,
   HISTOGRAM_LOAD_RESULT_MAX_VALUE = 4
 };
 
 void LogManifestLoadResult(HistogramServicesCustomizationLoadResult result) {
   UMA_HISTOGRAM_ENUMERATION("ServicesCustomization.LoadResult",
                             result,
                             HISTOGRAM_LOAD_RESULT_MAX_VALUE);
 }
 
+std::string GetLocaleSpecificStringImpl(
+    const base::DictionaryValue* root,
+    const std::string& locale,
+    const std::string& dictionary_name,
+    const std::string& entry_name) {
+  const base::DictionaryValue* dictionary_content = NULL;
+  if (!root || !root->GetDictionary(dictionary_name, &dictionary_content))
+    return std::string();
+
+  const base::DictionaryValue* locale_dictionary = NULL;
+  if (dictionary_content->GetDictionary(locale, &locale_dictionary)) {
+    std::string result;
+    if (locale_dictionary->GetString(entry_name, &result))
+      return result;
+  }
+
+  const base::DictionaryValue* default_dictionary = NULL;
+  if (dictionary_content->GetDictionary(kDefaultAttr, &default_dictionary)) {
+    std::string result;
+    if (default_dictionary->GetString(entry_name, &result))
+      return result;
+  }
+
+  return std::string();
+}
+
 }  // anonymous namespace
 
 namespace chromeos {
 
 // Template URL where to fetch OEM services customization manifest from.
 const char ServicesCustomizationDocument::kManifestUrl[] =
     "https://ssl.gstatic.com/chrome/chromeos-customization/%s.json";
 
 // A custom extensions::ExternalLoader that the ServicesCustomizationDocument
 // creates and uses to publish OEM default apps to the extensions system.
@@ skipping 78 matching lines @@
     LOG(ERROR) << "Wrong customization manifest version";
     root_.reset(NULL);
   }
   return false;
 }
 
 std::string CustomizationDocument::GetLocaleSpecificString(
     const std::string& locale,
     const std::string& dictionary_name,
     const std::string& entry_name) const {
-  base::DictionaryValue* dictionary_content = NULL;
-  if (!root_.get() ||
-      !root_->GetDictionary(dictionary_name, &dictionary_content))
-    return std::string();
-
-  base::DictionaryValue* locale_dictionary = NULL;
-  if (dictionary_content->GetDictionary(locale, &locale_dictionary)) {
-    std::string result;
-    if (locale_dictionary->GetString(entry_name, &result))
-      return result;
-  }
-
-  base::DictionaryValue* default_dictionary = NULL;
-  if (dictionary_content->GetDictionary(kDefaultAttr, &default_dictionary)) {
-    std::string result;
-    if (default_dictionary->GetString(entry_name, &result))
-      return result;
-  }
-
-  return std::string();
+  return GetLocaleSpecificStringImpl(
+      root_.get(), locale, dictionary_name, entry_name);
 }
 
 // StartupCustomizationDocument implementation. --------------------------------
 
 StartupCustomizationDocument::StartupCustomizationDocument()
     : CustomizationDocument(kAcceptedManifestVersion) {
   {
     // Loading manifest causes us to do blocking IO on UI thread.
     // Temporarily allow it until we fix http://crosbug.com/11103
     base::ThreadRestrictions::ScopedAllowIO allow_io;
@@ skipping 233 matching lines @@
     ApplyOOBECustomization();
 
   scoped_ptr<base::DictionaryValue> prefs =
       GetDefaultAppsInProviderFormat(*root_);
   for (ExternalLoaders::iterator it = external_loaders_.begin();
        it != external_loaders_.end(); ++it) {
     if (*it) {
       UpdateCachedManifest((*it)->profile());
       (*it)->SetCurrentApps(
           scoped_ptr<base::DictionaryValue>(prefs->DeepCopy()));
+      SetOemFolderName((*it)->profile(), *root_);
     }
   }
 }
 
 void ServicesCustomizationDocument::OnURLFetchComplete(
     const net::URLFetcher* source) {
   std::string mime_type;
   std::string data;
   if (source->GetStatus().is_success() &&
       source->GetResponseCode() == net::HTTP_OK &&
@@ skipping 57 matching lines @@
       ids->push_back(app_id);
     } else {
       LOG(ERROR) << "Wrong format of default application list";
       return false;
     }
   }
 
   return true;
 }
 
+std::string ServicesCustomizationDocument::GetOemAppsFolderName(
+    const std::string& locale) const {
+  if (!IsReady())
+    return std::string();
+
+  return GetOemAppsFolderNameImpl(locale, *root_);
+}
+
 scoped_ptr<base::DictionaryValue>
 ServicesCustomizationDocument::GetDefaultAppsInProviderFormat(
     const base::DictionaryValue& root) {
   scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
   const base::ListValue* apps_list = NULL;
   if (root.GetList(kDefaultAppsAttr, &apps_list)) {
     for (size_t i = 0; i < apps_list->GetSize(); ++i) {
       std::string app_id;
       if (apps_list->GetString(i, &app_id)) {
         base::DictionaryValue* entry = new base::DictionaryValue;
@@ skipping 17 matching lines @@
 
 extensions::ExternalLoader* ServicesCustomizationDocument::CreateExternalLoader(
     Profile* profile) {
   ServicesCustomizationExternalLoader* loader =
       new ServicesCustomizationExternalLoader(profile);
   external_loaders_.push_back(loader->AsWeakPtr());
 
   if (IsReady()) {
     UpdateCachedManifest(profile);
     loader->SetCurrentApps(GetDefaultAppsInProviderFormat(*root_));
+    SetOemFolderName(profile, *root_);
   } else {
     const base::DictionaryValue* root =
         profile->GetPrefs()->GetDictionary(kServicesCustomizationKey);
     std::string version;
     if (root && root->GetString(kVersionAttr, &version)) {
       // If version exists, profile has cached version of customization.
       loader->SetCurrentApps(GetDefaultAppsInProviderFormat(*root));
+      SetOemFolderName(profile, *root);
     } else {
       // StartFetching will be called from ServicesCustomizationExternalLoader
       // when StartLoading is called. We can't initiate manifest fetch here
       // because caller may never call StartLoading for the provider.
     }
   }
 
   return loader;
 }
 
 void ServicesCustomizationDocument::OnCustomizationNotFound() {
   LogManifestLoadResult(HISTOGRAM_LOAD_RESULT_FILE_NOT_FOUND);
   LoadManifestFromString(kEmptyServicesCustomizationManifest);
 }
 
+void ServicesCustomizationDocument::SetOemFolderName(
+    Profile* profile,
+    const base::DictionaryValue& root) {
+  app_list::AppListSyncableService* service =
+      app_list::AppListSyncableServiceFactory::GetForProfile(profile);
+  if (!service) {
+    LOG(WARNING) << "AppListSyncableService is not ready for setting OEM "
+                    "folder name";
+    return;
+  }
+
+  std::string locale = g_browser_process->GetApplicationLocale();
+  std::string name = GetOemAppsFolderNameImpl(locale, root);
+  if (!name.empty())
+    service->SetOemFolderName(name);
+}
+
+std::string ServicesCustomizationDocument::GetOemAppsFolderNameImpl(
+    const std::string& locale,
+    const base::DictionaryValue& root) const {
+  return GetLocaleSpecificStringImpl(
+      &root, locale, kLocalizedContent, kDefaultAppsFolderName);
+}
+
 }  // namespace chromeos