Makes the component installers return a Result instead of a bool.

components/component_updater/default_component_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 "components/component_updater/default_component_installer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/path_service.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "components/component_updater/component_updater_paths.h"
 // TODO(ddorwin): Find a better place for ReadManifest.
 #include "components/component_updater/component_updater_service.h"
 #include "components/update_client/component_unpacker.h"
+#include "components/update_client/update_client.h"
+#include "components/update_client/update_client_errors.h"
 #include "components/update_client/utils.h"
 
-using update_client::CrxComponent;
-
 namespace component_updater {
 
 namespace {
 
 // Version "0" corresponds to no installed version. By the server's conventions,
 // we represent it as a dotted quad.
 const char kNullVersion[] = "0.0.0.0";
 
+using Result = update_client::CrxInstaller::Result;
+using InstallError = update_client::InstallError;
+
 }  // namespace
 
 ComponentInstallerTraits::~ComponentInstallerTraits() {
 }
 
 DefaultComponentInstaller::DefaultComponentInstaller(
     std::unique_ptr<ComponentInstallerTraits> installer_traits)
     : current_version_(kNullVersion),
       main_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   installer_traits_ = std::move(installer_traits);
@@ skipping 18 matching lines @@
       base::Bind(&DefaultComponentInstaller::StartRegistration,
                  this, cus),
       base::Bind(&DefaultComponentInstaller::FinishRegistration,
                  this, cus, callback));
 }
 
 void DefaultComponentInstaller::OnUpdateError(int error) {
   LOG(ERROR) << "Component update error: " << error;
 }
 
-bool DefaultComponentInstaller::InstallHelper(
+Result DefaultComponentInstaller::InstallHelper(
     const base::DictionaryValue& manifest,
     const base::FilePath& unpack_path,
     const base::FilePath& install_path) {
   VLOG(1) << "InstallHelper: unpack_path=" << unpack_path.AsUTF8Unsafe()
           << " install_path=" << install_path.AsUTF8Unsafe();
 
   if (!base::Move(unpack_path, install_path)) {
     PLOG(ERROR) << "Move failed.";
-    return false;
+    return Result(InstallError::GENERIC_ERROR);
   }
-  if (!installer_traits_->OnCustomInstall(manifest, install_path)) {
+  const auto result =
+      installer_traits_->OnCustomInstall(manifest, install_path);
+  if (result.error) {
     PLOG(ERROR) << "CustomInstall failed.";
-    return false;
+    return result;
   }
   if (!installer_traits_->VerifyInstallation(manifest, install_path)) {
     PLOG(ERROR) << "VerifyInstallation failed.";
-    return false;
+    return Result(InstallError::GENERIC_ERROR);
   }
 
-  return true;
+  return Result(InstallError::NONE);
 }
 
-bool DefaultComponentInstaller::Install(const base::DictionaryValue& manifest,
-                                        const base::FilePath& unpack_path) {
+Result DefaultComponentInstaller::Install(const base::DictionaryValue& manifest,
+                                          const base::FilePath& unpack_path) {
   std::string manifest_version;
   manifest.GetStringASCII("version", &manifest_version);
   base::Version version(manifest_version);
 
   VLOG(1) << "Install: version=" << version.GetString()
           << " current version=" << current_version_.GetString();
 
   if (!version.IsValid())
-    return false;
+    return Result(InstallError::GENERIC_ERROR);
   if (current_version_.CompareTo(version) > 0)
-    return false;
+    return Result(InstallError::GENERIC_ERROR);
   base::FilePath install_path;
   if (!PathService::Get(DIR_COMPONENT_USER, &install_path))
-    return false;
+    return Result(InstallError::GENERIC_ERROR);
   install_path = install_path.Append(installer_traits_->GetRelativeInstallDir())
                      .AppendASCII(version.GetString());
   if (base::PathExists(install_path)) {
     if (!base::DeleteFile(install_path, true))
-      return false;
+      return Result(InstallError::GENERIC_ERROR);
   }
-  if (!InstallHelper(manifest, unpack_path, install_path)) {
+  const auto result = InstallHelper(manifest, unpack_path, install_path);
+  if (result.error) {
     base::DeleteFile(install_path, true);
-    return false;
+    return result;
   }
   current_version_ = version;
   current_install_dir_ = install_path;
   // TODO(ddorwin): Change parameter to std::unique_ptr<base::DictionaryValue>
   // so we can avoid this DeepCopy.
   current_manifest_.reset(manifest.DeepCopy());
   std::unique_ptr<base::DictionaryValue> manifest_copy(
       current_manifest_->DeepCopy());
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DefaultComponentInstaller::ComponentReady,
                  this, base::Passed(&manifest_copy)));
-  return true;
+  return result;
 }
 
 bool DefaultComponentInstaller::GetInstalledFile(
     const std::string& file,
     base::FilePath* installed_file) {
   if (current_version_ == base::Version(kNullVersion))
     return false;  // No component has been installed yet.
   *installed_file = current_install_dir_.AppendASCII(file);
   return true;
 }
@@ skipping 172 matching lines @@
       DLOG(ERROR) << "Couldn't delete " << base_dir.value();
   }
 }
 
 void DefaultComponentInstaller::FinishRegistration(
     ComponentUpdateService* cus,
     const base::Closure& callback) {
   VLOG(1) << __func__ << " for " << installer_traits_->GetName();
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  CrxComponent crx;
+  update_client::CrxComponent crx;
   installer_traits_->GetHash(&crx.pk_hash);
   crx.installer = this;
   crx.version = current_version_;
   crx.fingerprint = current_fingerprint_;
   crx.name = installer_traits_->GetName();
   crx.installer_attributes = installer_traits_->GetInstallerAttributes();
   crx.requires_network_encryption =
       installer_traits_->RequiresNetworkEncryption();
   crx.handled_mime_types = installer_traits_->GetMimeTypes();
   crx.supports_group_policy_enable_component_updates =
@@ skipping 20 matching lines @@
 
 void DefaultComponentInstaller::ComponentReady(
     std::unique_ptr<base::DictionaryValue> manifest) {
   VLOG(1) << "Component ready, version " << current_version_.GetString()
           << " in " << current_install_dir_.value();
   installer_traits_->ComponentReady(current_version_, current_install_dir_,
                                     std::move(manifest));
 }
 
 }  // namespace component_updater