Check env-version upon component load

chrome/browser/component_updater/cros_component_installer.cc

 // Copyright 2017 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/task_scheduler/post_task.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/component_updater/component_installer_errors.h"
 #include "components/component_updater/component_updater_paths.h"
 #include "components/crx_file/id_util.h"
 #include "content/public/browser/browser_thread.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/dbus/dbus_method_call_status.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/image_loader_client.h"
 #endif  // defined(OS_CHROMEOS)
 
+#define CONFIG_MAP_CONTENT        \
+  {{"epson-inkjet-printer-escpr", \
+    {{"env_version", "2.1"},      \
+     {"sha2hashstr",              \
+      "1913a5e0a6cad30b6f03e176177e0d7ed62c5d6700a9c66da556d7c3f5d6a47e"}}}};
+
 using content::BrowserThread;
 
 namespace component_updater {
 
 #if defined(OS_CHROMEOS)
 void LogRegistrationResult(const std::string& name,
                            chromeos::DBusMethodCallStatus call_status,
                            bool result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS) {
@@ skipping 45 matching lines @@
 }
 
 bool CrOSComponentInstallerTraits::RequiresNetworkEncryption() const {
   return true;
 }
 
 update_client::CrxInstaller::Result
 CrOSComponentInstallerTraits::OnCustomInstall(
     const base::DictionaryValue& manifest,
     const base::FilePath& install_dir) {
-  DVLOG(1) << "[CrOSComponentInstallerTraits::OnCustomInstall]";
   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);
 }
 
 void CrOSComponentInstallerTraits::ComponentReady(
     const base::Version& version,
     const base::FilePath& path,
     std::unique_ptr<base::DictionaryValue> manifest) {
-  g_browser_process->platform_part()->AddCompatibleCrOSComponent(GetName());
+  std::string min_env_version;
+  if (manifest && manifest->GetString("min_env_version", &min_env_version)) {
+    if (IsCompatible(env_version, min_env_version)) {
+      g_browser_process->platform_part()->AddCompatibleCrOSComponent(GetName());
+    }
+  }
 }
 
 bool CrOSComponentInstallerTraits::VerifyInstallation(
     const base::DictionaryValue& manifest,
     const base::FilePath& install_dir) const {
   return true;
 }
 
 base::FilePath CrOSComponentInstallerTraits::GetRelativeInstallDir() const {
   return base::FilePath(name);
@@ skipping 12 matching lines @@
   update_client::InstallerAttributes attrs;
   attrs["_env_version"] = env_version;
   return attrs;
 }
 
 std::vector<std::string> CrOSComponentInstallerTraits::GetMimeTypes() const {
   std::vector<std::string> mime_types;
   return mime_types;
 }
 
-void CrOSComponent::RegisterCrOSComponentInternal(
-    ComponentUpdateService* cus,
-    const ComponentConfig& config,
-    const base::Closure& installcallback) {
-  std::unique_ptr<ComponentInstallerTraits> traits(
-      new CrOSComponentInstallerTraits(config));
-  // |cus| will take ownership of |installer| during
-  // installer->Register(cus).
-  DefaultComponentInstaller* installer =
-      new DefaultComponentInstaller(std::move(traits));
-  installer->Register(cus, installcallback);
+bool CrOSComponentInstallerTraits::IsCompatible(
+    const std::string& env_version_str,
+    const std::string& min_env_version_str) {
+  // env_version format: [0-9]+.[0-9]+
+  base::Version env_version(env_version_str);
+  base::Version min_env_version(min_env_version_str);
+  if (env_version.components().size() == 2 &&
+      min_env_version.components().size() == 2 &&
+      env_version.components()[0] == min_env_version.components()[0] &&
+      env_version.components()[1] >= min_env_version.components()[1]) {

[waffles, 2017/05/30 22:12:17]

You can replace the == 2 check with .IsValid and the env[1] >= min_env[1] check
with env > min_env.

[xiaochu, 2017/05/31 15:40:11]

Done.

+    return true;
+  }
+  return false;

[waffles, 2017/05/30 22:12:17]

IMHO it's better to just return the value of the expression, even though it's a
multi-line expression.

[xiaochu, 2017/05/31 15:40:11]

Done.

 }
 
-void CrOSComponent::InstallChromeOSComponent(
-    ComponentUpdateService* cus,
-    const std::string& id,
-    const update_client::Callback& install_callback) {
-  cus->GetOnDemandUpdater().OnDemandUpdate(id, install_callback);
-}
-
-bool CrOSComponent::InstallCrOSComponent(
+void CrOSComponent::InstallCrOSComponent(
     const std::string& name,
     const update_client::Callback& install_callback) {
   auto* const cus = g_browser_process->component_updater();
-  const ConfigMap components = {
-      {"epson-inkjet-printer-escpr",
-       {{"env_version", "0.0"},
-        {"sha2hashstr",
-         "1913a5e0a6cad30b6f03e176177e0d7ed62c5d6700a9c66da556d7c3f5d6a47e"}}}};
-  if (name.empty()) {
+  InstallCrOSComponent(cus, name, install_callback);
+}
+
+void CrOSComponent::InstallCrOSComponent(
+    ComponentUpdateService* cus,
+    const std::string& name,
+    const update_client::Callback& install_callback) {
+  const ConfigMap components = CONFIG_MAP_CONTENT;
+  const auto it = components.find(name);
+  if (name.empty() || it == components.end()) {
     base::PostTask(
         FROM_HERE,
         base::Bind(install_callback, update_client::Error::INVALID_ARGUMENT));
-    return false;
-  }
-  const auto it = components.find(name);
-  if (it == components.end()) {
-    DVLOG(1) << "[RegisterCrOSComponents] component " << name
-             << " is not in configuration.";
-    base::PostTask(
-        FROM_HERE,
-        base::Bind(install_callback, update_client::Error::INVALID_ARGUMENT));
-    return false;
+    return;
   }
   ComponentConfig config(it->first, it->second.find("env_version")->second,
                          it->second.find("sha2hashstr")->second);
   RegisterCrOSComponentInternal(
       cus, config,
       base::Bind(InstallChromeOSComponent, cus,
                  crx_file::id_util::GenerateIdFromHex(
                      it->second.find("sha2hashstr")->second)
                      .substr(0, 32),
                  install_callback));
-  return true;
 }
 
-void MountResult(const base::Callback<void(const std::string&)>& mount_callback,
-                 chromeos::DBusMethodCallStatus call_status,
-                 const std::string& result) {
-  if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS) {
-    DVLOG(1) << "Call to imageloader service failed.";
-    base::PostTask(FROM_HERE, base::Bind(mount_callback, ""));
-    return;
-  }
-  if (result.empty()) {
-    DVLOG(1) << "Component load failed";
-    base::PostTask(FROM_HERE, base::Bind(mount_callback, ""));
-    return;
-  }
-  base::PostTask(FROM_HERE, base::Bind(mount_callback, result));
+void CrOSComponent::RegisterCrOSComponentInternal(
+    ComponentUpdateService* cus,
+    const ComponentConfig& config,
+    const base::Closure& installcallback) {
+  std::unique_ptr<ComponentInstallerTraits> traits(
+      new CrOSComponentInstallerTraits(config));
+  // |cus| will take ownership of |installer| during
+  // installer->Register(cus).
+  DefaultComponentInstaller* installer =
+      new DefaultComponentInstaller(std::move(traits));
+  installer->Register(cus, installcallback);
+}
+
+void CrOSComponent::InstallChromeOSComponent(
+    ComponentUpdateService* cus,
+    const std::string& id,
+    const update_client::Callback& install_callback) {
+  cus->GetOnDemandUpdater().OnDemandUpdate(id, install_callback);
+}
+
+void LoadResult(const base::Callback<void(const std::string&)>& load_callback,
+                chromeos::DBusMethodCallStatus call_status,
+                const std::string& result) {
+  PostTask(
+      FROM_HERE,
+      base::Bind(
+          load_callback,
+          call_status != chromeos::DBUS_METHOD_CALL_SUCCESS ? "" : result));
 }
 
 void CrOSComponent::LoadCrOSComponent(
     const std::string& name,
-    const base::Callback<void(const std::string&)>& mount_callback) {
+    const base::Callback<void(const std::string&)>& load_callback) {
+  if (!g_browser_process->platform_part()->IsCompatibleCrOSComponent(name))
+    return;
   chromeos::ImageLoaderClient* loader =
       chromeos::DBusThreadManager::Get()->GetImageLoaderClient();
   if (loader) {
-    loader->LoadComponent(name, base::Bind(&MountResult, mount_callback));
-  } else {
-    DVLOG(1) << "Failed to get ImageLoaderClient object.";
+    loader->LoadComponent(name, base::Bind(&LoadResult, load_callback));
+    return;
   }
+  base::PostTask(FROM_HERE, base::Bind(load_callback, ""));
 }
+
 #endif  // defined(OS_CHROMEOS
 
 }  // namespace component_updater