Universial component install for chrome os.

chrome/browser/component_updater/cros_component_installer.cc

+// Copyright (c) 2013 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/cros_component_installer.h"
+#include "base/json/json_file_value_serializer.h"
+#include "components/component_updater/component_updater_paths.h"
+
+using content::BrowserThread;
+using content::PluginService;
+
+namespace component_updater {
+
+#if defined(OS_CHROMEOS)
+void LogRegistrationResult(chromeos::DBusMethodCallStatus call_status,
+                           bool result) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS) {
+    LOG(ERROR) << "Call to imageloader service failed.";
+    return;
+  }
+  if (!result) {
+    LOG(ERROR) << "Component registration failed";
+    return;
+  }
+}
+void ImageLoaderRegistration(const std::string& version,
+                             const base::FilePath& install_dir,
+                             const std::string& name) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  chromeos::ImageLoaderClient* loader =
+      chromeos::DBusThreadManager::Get()->GetImageLoaderClient();
+
+  if (loader) {
+    loader->RegisterComponent(name, version, install_dir.value(),
+                              base::Bind(&LogRegistrationResult));
+  } else {
+    LOG(ERROR) << "Failed to get ImageLoaderClient object.";
+  }
+}
+
+// Determine whether or not to skip registering this cros component updates.
+bool SkipCupsRegistration(ComponentUpdateService* cus) {
+  return false;
+}
+#endif  // defined(OS_CHROMEOS)
+
+CrOSComponentInstallerTraits::CrOSComponentInstallerTraits(
+    std::string dir_name,
+    std::string name,
+    std::string sha2HashStr)
+    : dir_name(dir_name), name(name) {
+  if (sha2HashStr.length() != 64)
+    return;
+  for (unsigned int i = 0; i < sizeof(kSha2Hash_); i++) {
+    kSha2Hash_[i] = stoul(sha2HashStr.substr(i * 2, 2), nullptr, 16);
+  }
+}
+
+bool CrOSComponentInstallerTraits::SupportsGroupPolicyEnabledComponentUpdates()
+    const {
+  return true;
+}
+
+bool CrOSComponentInstallerTraits::RequiresNetworkEncryption() const {
+  return false;
+}
+
+update_client::CrxInstaller::Result
+CrOSComponentInstallerTraits::OnCustomInstall(
+    const base::DictionaryValue& manifest,
+    const base::FilePath& install_dir) {
+  VLOG(0) << "[CrOSComponentInstallerTraits::OnCustomInstall]";
+#if defined(OS_CHROMEOS)
+  std::string version;
+  if (!manifest.GetString("version", &version)) {
+    return ToInstallerResult(update_client::InstallError::GENERIC_ERROR);
+  }
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&ImageLoaderRegistration, version, install_dir, name));
+  return update_client::CrxInstaller::Result(update_client::InstallError::NONE);
+#else
+  return ToInstallerResult(update_client::InstallError::GENERIC_ERROR);
+#endif  // defined(OS_CHROMEOS)
+}
+
+void CrOSComponentInstallerTraits::ComponentReady(
+    const base::Version& version,
+    const base::FilePath& path,
+    std::unique_ptr<base::DictionaryValue> manifest) {}
+
+bool CrOSComponentInstallerTraits::VerifyInstallation(
+    const base::DictionaryValue& manifest,
+    const base::FilePath& install_dir) const {
+  return true;
+}
+
+base::FilePath CrOSComponentInstallerTraits::GetRelativeInstallDir() const {
+  return base::FilePath(FILE_PATH_LITERAL(dir_name));
+}
+
+void CrOSComponentInstallerTraits::GetHash(std::vector<uint8_t>* hash) const {
+  hash->assign(kSha2Hash_, kSha2Hash_ + arraysize(kSha2Hash_));
+}
+
+std::string CrOSComponentInstallerTraits::GetName() const {
+  return name;
+}
+
+update_client::InstallerAttributes
+CrOSComponentInstallerTraits::GetInstallerAttributes() const {
+  return update_client::InstallerAttributes();
+}
+
+std::vector<std::string> CrOSComponentInstallerTraits::GetMimeTypes() const {
+  std::vector<std::string> mime_types;
+  return mime_types;
+}
+
+void RegisterCrOSComponent(ComponentUpdateService* cus,
+                           ComponentConfig& config) {
+  std::unique_ptr<ComponentInstallerTraits> traits(
+      new CrOSComponentInstallerTraits(config.dir, config.name,
+                                       config.sha2hashstr));
+  // |cus| will take ownership of |installer| during
+  // installer->Register(cus).
+  DefaultComponentInstaller* installer =
+      new DefaultComponentInstaller(std::move(traits));
+  installer->Register(cus, base::Closure());
+}
+
+// an example config file content:
+// {
+// "components":
+// [

[waffles, 2017/02/23 17:13:20]

If you always are using the name as a key, do you want to make this an object
rather than an array?

e.g.

"components": {
  "escpr": {
    "dir": "epson-inkjet-printer-escpr"
    "sha2hashstr":"1913a5e0a6cad30b6f03..."
  }
}

[xiaochu, 2017/02/23 20:54:56]

Done.

+// {
+// "name":"escpr",
+// "dir":"epson-inkjet-printer-escpr",
+// "sha2hashstr":"1913a5e0a6cad30b6f03e176177e0d7ed62c5d6700a9c66da556d7c3f5d6a47e"
+// }
+// ]
+// }

[waffles, 2017/02/23 17:13:20]

Adding indentation could make this clearer.

[xiaochu, 2017/02/23 20:54:56]

Done.

+bool RegisterCrOSComponent(ComponentUpdateService* cus, std::string name) {
+  base::FilePath configFilePath(filepathstr);

[waffles, 2017/02/23 17:13:20]

Can we remember the contents of this file instead of repeatedly reading it? This
may require you to make a factory object.

[xiaochu, 2017/02/23 20:54:56]

Done.

+  JSONFileValueDeserializer deserializer(configFilePath);

[waffles, 2017/02/23 17:13:20]

What thread do you intend this function to be run on? Any file I/O should be
done using the TaskScheduler (not on the UI thread), but installer->Register
must be called on the UI thread.

[xiaochu, 2017/02/23 20:54:56]

I added some more options for developers:

1) UI threads can call RegisterCrOSCompnent, if config is not loaded yet, it
won't register.

2) RegisterCrOSComponentIO will call LoadCrOSConfig and then
RegisterCrOSComponent. So we can either call this or schedule LoadCrOSConfig
somewhere at startup. 

And we won't do incorrect things here by calling either of them. Please advise.

[xiaochu, 2017/02/25 23:39:22]

I just documented my idea in .h file in details. Basically, we allow developers
to do an asynchronous call from a taskrunner (they owned) to do registration. 

+  std::string error;
+  std::unique_ptr<base::Value> root = deserializer.Deserialize(NULL, &error);
+  if (!root.get()) {
+    VLOG(0) << "[RegisterCrOSComponents] configuration not exist or in wrong "

[waffles, 2017/02/23 17:13:20]

Can we use DVLOG(1)? Also elsewhere in this file, for every VLOG or LOG.

[xiaochu, 2017/02/23 20:54:56]

Done.

+               "format.";
+    return false;
+  }
+  if (!root->IsType(base::Value::Type::DICTIONARY)) {
+    VLOG(0)
+        << "[RegisterCrOSComponents] top level has to be a dictionary type.";
+    return false;
+  }
+  auto components = std::unique_ptr<base::DictionaryValue>(
+      static_cast<base::DictionaryValue*>(root.release()));
+  base::ListValue* component_list = nullptr;
+  if (!components->GetList("components", &component_list)) {
+    VLOG(0) << "[RegisterCrOSComponents] component list not exist.";
+    return false;
+  }
+  for (size_t i = 0; i < component_list->GetSize(); i++) {
+    base::DictionaryValue* component = nullptr;
+    if (component_list->GetDictionary(i, &component)) {
+      std::string name_, dir, sha2hashstr;
+      if (component->GetString("name", &name_) &&
+          component->GetString("dir", &dir) &&
+          component->GetString("sha2hashstr", &sha2hashstr) &&
+          name.compare(name_) == 0 && name.length() > 0 && dir.length() > 0 &&
+          sha2hashstr.length() == 64) {
+        ComponentConfig config;
+        config.name = name_;
+        config.dir = dir;
+        config.sha2hashstr = sha2hashstr;
+        VLOG(1) << "[RegisterCrOSComponents] register component:" << name_;
+        RegisterCrOSComponent(cus, config);
+        return true;
+      }
+    }
+  }
+  VLOG(0) << "[RegisterCrOSComponents] "
+             "component name is not in configuration file.";
+  return false;
+}
+
+}  // namespace component_updater