Supervised User whitelists: update to json format v2

chrome/browser/component_updater/supervised_user_whitelist_installer.cc

 // Copyright 2014 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/component_updater/supervised_user_whitelist_installer.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
@@ skipping 15 matching lines @@
 #include "chrome/browser/profiles/profile_info_cache_observer.h"
 #include "chrome/browser/supervised_user/supervised_user_whitelist_service.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "components/component_updater/component_updater_paths.h"
 #include "components/component_updater/component_updater_service.h"
 #include "components/component_updater/default_component_installer.h"
 #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 {
 
 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,
+    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);
   return base_dir.empty()
              ? base::FilePath()
              : base_dir.AppendASCII(crx_id + kSanitizedWhitelistExtension);
 }
 
 void RecordUncleanUninstall() {
   content::BrowserThread::PostTask(
@@ skipping 111 matching lines @@
     }
   }
 }
 
 class SupervisedUserWhitelistComponentInstallerTraits
     : public ComponentInstallerTraits {
  public:
   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 {}
 
  private:
   // ComponentInstallerTraits overrides:
   bool VerifyInstallation(const base::DictionaryValue& manifest,
                           const base::FilePath& install_dir) const override;
   bool CanAutoUpdate() const override;
   bool OnCustomInstall(const base::DictionaryValue& manifest,
                        const base::FilePath& install_dir) override;
   void ComponentReady(const base::Version& version,
                       const base::FilePath& install_dir,
                       scoped_ptr<base::DictionaryValue> manifest) override;
   base::FilePath GetBaseDirectory() const override;
   void GetHash(std::vector<uint8_t>* hash) const override;
   std::string GetName() const override;
 
   std::string crx_id_;
   std::string name_;
-  base::Callback<void(const base::FilePath&)> callback_;
+  RawWhitelistReadyCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SupervisedUserWhitelistComponentInstallerTraits);
 };
 
 bool SupervisedUserWhitelistComponentInstallerTraits::VerifyInstallation(
     const base::DictionaryValue& manifest,
     const base::FilePath& install_dir) const {
   // Check whether the whitelist exists at the path specified by the manifest.
   // This does not check whether the whitelist is wellformed.
   return base::PathExists(GetRawWhitelistPath(manifest, install_dir));
 }
 
 bool SupervisedUserWhitelistComponentInstallerTraits::CanAutoUpdate() const {
   return true;
 }
 
 bool SupervisedUserWhitelistComponentInstallerTraits::OnCustomInstall(
     const base::DictionaryValue& manifest,
     const base::FilePath& install_dir) {
   // Delete the existing sanitized whitelist.
   return base::DeleteFile(GetSanitizedWhitelistPath(crx_id_), false);
 }
 
 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::Owned(manifest.release())));

[Bernhard Bauer, 2015/11/18 12:10:40]

base::Passed(&manifest)?

[Marc Treib, 2015/11/18 12:44:18]

Done.

 }
 
 base::FilePath
 SupervisedUserWhitelistComponentInstallerTraits::GetBaseDirectory() const {
   base::FilePath whitelist_directory;
   PathService::Get(DIR_SUPERVISED_USER_WHITELISTS, &whitelist_directory);
   return whitelist_directory.AppendASCII(crx_id_);
 }
 
 void SupervisedUserWhitelistComponentInstallerTraits::GetHash(
@@ skipping 17 matching lines @@
  private:
   void RegisterComponent(const std::string& crx_id,
                          const std::string& name,
                          const base::Closure& callback);
   void RegisterNewComponent(const std::string& crx_id, const std::string& name);
   bool UnregisterWhitelistInternal(base::DictionaryValue* pref_dict,
                                    const std::string& client_id,
                                    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;
   void Subscribe(const WhitelistReadyCallback& callback) override;
   void RegisterWhitelist(const std::string& client_id,
                          const std::string& crx_id,
                          const std::string& name) override;
   void UnregisterWhitelist(const std::string& client_id,
                            const std::string& crx_id) override;
 
@@ skipping 71 matching lines @@
   DCHECK(result);
 
   result = base::DeleteFile(GetSanitizedWhitelistPath(crx_id), false);
   DCHECK(result);
 
   return removed;
 }
 
 void SupervisedUserWhitelistInstallerImpl::OnRawWhitelistReady(
     const std::string& crx_id,
+    const base::string16& title,
     const base::FilePath& whitelist_path) {
   cus_->GetSequencedTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &CheckForSanitizedWhitelistOnTaskRunner, crx_id, whitelist_path,
           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() {
   const std::map<std::string, std::string> command_line_whitelists =
       SupervisedUserWhitelistService::GetWhitelistsFromCommandLine();
 
   std::set<std::string> registered_whitelists;
   std::set<std::string> stale_whitelists;
   DictionaryPrefUpdate update(local_state_,
                               prefs::kRegisteredSupervisedUserWhitelists);
@@ skipping 148 matching lines @@
 
 // static
 void SupervisedUserWhitelistInstaller::TriggerComponentUpdate(
     OnDemandUpdater* updater,
     const std::string& crx_id) {
   const bool result = updater->OnDemandUpdate(crx_id);
   DCHECK(result);
 }
 
 }  // namespace component_updater