Supervised User whitelists: update to json format v2

chrome/browser/component_updater/supervised_user_whitelist_installer.cc

Index: chrome/browser/component_updater/supervised_user_whitelist_installer.cc
diff --git a/chrome/browser/component_updater/supervised_user_whitelist_installer.cc b/chrome/browser/component_updater/supervised_user_whitelist_installer.cc
index a266eecc310c72e0440bb0d889101a9803ba5a1c..bd21f9269a8311538a295ed07a334bfcc6bed462 100644
--- a/chrome/browser/component_updater/supervised_user_whitelist_installer.cc
+++ b/chrome/browser/component_updater/supervised_user_whitelist_installer.cc
@@ -33,6 +33,8 @@
 #include "components/crx_file/id_util.h"
 #include "components/safe_json/json_sanitizer.h"
 #include "content/public/browser/browser_thread.h"
+#include "extensions/common/extension_l10n_util.h"
+#include "extensions/common/manifest_constants.h"
 
 namespace component_updater {
 
@@ -40,25 +42,50 @@ namespace {
 
 const char kSanitizedWhitelistExtension[] = ".json";
 
-const char kWhitelist[] = "whitelist";
-const char kFile[] = "file";
+const char kWhitelistedContent[] = "whitelisted_content";
+const char kSites[] = "sites";
 
 const char kClients[] = "clients";
 const char kName[] = "name";
 
+using RawWhitelistReadyCallback =
+    base::Callback<void(const base::string16&, const base::FilePath&)>;
+
+base::string16 GetWhitelistTitle(const base::DictionaryValue& manifest) {
+  base::string16 title;
+  if (!manifest.GetString(extensions::manifest_keys::kShortName, &title))
+    manifest.GetString(extensions::manifest_keys::kName, &title);
+  return title;
+}
+
 base::FilePath GetRawWhitelistPath(const base::DictionaryValue& manifest,
                                    const base::FilePath& install_dir) {
   const base::DictionaryValue* whitelist_dict = nullptr;
-  if (!manifest.GetDictionary(kWhitelist, &whitelist_dict))
+  if (!manifest.GetDictionary(kWhitelistedContent, &whitelist_dict))
     return base::FilePath();
 
   base::FilePath::StringType whitelist_file;
-  if (!whitelist_dict->GetString(kFile, &whitelist_file))
+  if (!whitelist_dict->GetString(kSites, &whitelist_file))
     return base::FilePath();
 
   return install_dir.Append(whitelist_file);
 }
 
+void LocalizeManifestOnBlockingPool(base::DictionaryValue* manifest,
+                                    const base::FilePath& install_dir) {
+  std::string error;
+  if (!extension_l10n_util::LocalizeExtension(install_dir, manifest, &error))
+    LOG(WARNING) << "Localizing whitelist failed: " << error;
+}
+
+void OnManifestLocalized(
+    const RawWhitelistReadyCallback& callback,
+    const base::FilePath& install_dir,
+    scoped_ptr<const base::DictionaryValue> manifest) {
+  callback.Run(GetWhitelistTitle(*manifest),
+               GetRawWhitelistPath(*manifest, install_dir));
+}
+
 base::FilePath GetSanitizedWhitelistPath(const std::string& crx_id) {
   base::FilePath base_dir;
   PathService::Get(chrome::DIR_SUPERVISED_USER_INSTALLED_WHITELISTS, &base_dir);
@@ -190,7 +217,7 @@ class SupervisedUserWhitelistComponentInstallerTraits
   SupervisedUserWhitelistComponentInstallerTraits(
       const std::string& crx_id,
       const std::string& name,
-      const base::Callback<void(const base::FilePath&)>& callback)
+      const RawWhitelistReadyCallback& callback)
       : crx_id_(crx_id), name_(name), callback_(callback) {}
   ~SupervisedUserWhitelistComponentInstallerTraits() override {}
 
@@ -210,7 +237,7 @@ class SupervisedUserWhitelistComponentInstallerTraits
 
   std::string crx_id_;
   std::string name_;
-  base::Callback<void(const base::FilePath&)> callback_;
+  RawWhitelistReadyCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SupervisedUserWhitelistComponentInstallerTraits);
 };
@@ -238,7 +265,12 @@ void SupervisedUserWhitelistComponentInstallerTraits::ComponentReady(
     const base::Version& version,
     const base::FilePath& install_dir,
     scoped_ptr<base::DictionaryValue> manifest) {
-  callback_.Run(GetRawWhitelistPath(*manifest, install_dir));
+  base::DictionaryValue* manifest_raw = manifest.get();
+  content::BrowserThread::PostBlockingPoolTaskAndReply(
+      FROM_HERE,
+      base::Bind(&LocalizeManifestOnBlockingPool, manifest_raw, install_dir),
+      base::Bind(&OnManifestLocalized, callback_, install_dir,
+                 base::Passed(&manifest)));
 }
 
 base::FilePath
@@ -276,8 +308,10 @@ class SupervisedUserWhitelistInstallerImpl
                                    const std::string& crx_id);
 
   void OnRawWhitelistReady(const std::string& crx_id,
+                           const base::string16& title,
                            const base::FilePath& whitelist_path);
-  void OnSanitizedWhitelistReady(const std::string& crx_id);
+  void OnSanitizedWhitelistReady(const std::string& crx_id,
+                                 const base::string16& title);
 
   // SupervisedUserWhitelistInstaller overrides:
   void RegisterComponents() override;
@@ -369,6 +403,7 @@ bool SupervisedUserWhitelistInstallerImpl::UnregisterWhitelistInternal(
 
 void SupervisedUserWhitelistInstallerImpl::OnRawWhitelistReady(
     const std::string& crx_id,
+    const base::string16& title,
     const base::FilePath& whitelist_path) {
   cus_->GetSequencedTaskRunner()->PostTask(
       FROM_HERE,
@@ -377,13 +412,14 @@ void SupervisedUserWhitelistInstallerImpl::OnRawWhitelistReady(
           base::ThreadTaskRunnerHandle::Get(),
           base::Bind(
               &SupervisedUserWhitelistInstallerImpl::OnSanitizedWhitelistReady,
-              weak_ptr_factory_.GetWeakPtr(), crx_id)));
+              weak_ptr_factory_.GetWeakPtr(), crx_id, title)));
 }
 
 void SupervisedUserWhitelistInstallerImpl::OnSanitizedWhitelistReady(
-    const std::string& crx_id) {
+    const std::string& crx_id,
+    const base::string16& title) {
   for (const WhitelistReadyCallback& callback : callbacks_)
-    callback.Run(crx_id, GetSanitizedWhitelistPath(crx_id));
+    callback.Run(crx_id, title, GetSanitizedWhitelistPath(crx_id));
 }
 
 void SupervisedUserWhitelistInstallerImpl::RegisterComponents() {