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

components/update_client/action_update.cc

 // Copyright 2015 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/update_client/action_update.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 17 matching lines @@
 namespace update_client {
 
 namespace {
 
 void AppendDownloadMetrics(
     const std::vector<CrxDownloader::DownloadMetrics>& source,
     std::vector<CrxDownloader::DownloadMetrics>* destination) {
   destination->insert(destination->end(), source.begin(), source.end());
 }
 
-ErrorCategory UnpackerErrorToErrorCategory(UnpackerError error) {
-  ErrorCategory error_category = ErrorCategory::kErrorNone;
-  switch (error) {
-    case UnpackerError::kNone:
-      break;
-    case UnpackerError::kInstallerError:
-      error_category = ErrorCategory::kInstallError;
-      break;
-    default:
-      error_category = ErrorCategory::kUnpackError;
-      break;
-  }
-  return error_category;
-}
-
 }  // namespace
 
 ActionUpdate::ActionUpdate() {
 }
 
 ActionUpdate::~ActionUpdate() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void ActionUpdate::Run(UpdateContext* update_context, Callback callback) {
@@ skipping 99 matching lines @@
 
   if (result.error == UnpackerError::kNone) {
     update_context_->blocking_task_runner->PostTask(
         FROM_HERE,
         base::Bind(&ActionUpdate::StartInstallOnBlockingTaskRunner,
                    base::Unretained(this), item, crx_path, result.unpack_path));
   } else {
     update_context_->blocking_task_runner->PostTask(
         FROM_HERE,
         base::Bind(&ActionUpdate::InstallCompleteOnBlockingTaskRunner,
-                   base::Unretained(this), item, crx_path, result.error,
+                   base::Unretained(this), item, crx_path,
+                   ErrorCategory::kUnpackError, static_cast<int>(result.error),
                    result.extended_error));
   }
 }
 
 void ActionUpdate::StartInstallOnBlockingTaskRunner(
     CrxUpdateItem* item,
     const base::FilePath& crx_path,
     const base::FilePath& unpack_path) {
   DCHECK(update_context_->blocking_task_runner->RunsTasksOnCurrentThread());
   DCHECK(!unpack_path.empty());
 
-  const auto error = DoInstall(item, crx_path, unpack_path);
+  const auto result = DoInstall(item, crx_path, unpack_path);
+  const ErrorCategory error_category =
+      result.error ? ErrorCategory::kInstallError : ErrorCategory::kErrorNone;
   update_context_->blocking_task_runner->PostTask(
-      FROM_HERE, base::Bind(&ActionUpdate::InstallCompleteOnBlockingTaskRunner,
-                            base::Unretained(this), item, crx_path, error, 0));
+      FROM_HERE,
+      base::Bind(&ActionUpdate::InstallCompleteOnBlockingTaskRunner,
+                 base::Unretained(this), item, crx_path, error_category,
+                 result.error, result.extended_error));
 }
 
 void ActionUpdate::InstallCompleteOnBlockingTaskRunner(
     CrxUpdateItem* item,
     const base::FilePath& crx_path,
-    UnpackerError error,
+    ErrorCategory error_category,
+    int error,
     int extended_error) {
   update_client::DeleteFileAndEmptyParentDirectory(crx_path);
   update_context_->main_task_runner->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ActionUpdate::InstallComplete, base::Unretained(this),
-                 item->id, error, extended_error),
+                 item->id, error_category, error, extended_error),
       base::TimeDelta::FromMilliseconds(update_context_->config->StepDelay()));
 }
 
-UnpackerError ActionUpdate::DoInstall(CrxUpdateItem* item,
-                                      const base::FilePath& crx_path,
-                                      const base::FilePath& unpack_path) {
+CrxInstaller::Result ActionUpdate::DoInstall(
+    CrxUpdateItem* item,
+    const base::FilePath& crx_path,
+    const base::FilePath& unpack_path) {
   const auto& fingerprint = item->next_fp;
   if (static_cast<int>(fingerprint.size()) !=
       base::WriteFile(
           unpack_path.Append(FILE_PATH_LITERAL("manifest.fingerprint")),
           fingerprint.c_str(), base::checked_cast<int>(fingerprint.size()))) {
-    return UnpackerError::kFingerprintWriteFailed;
+    return CrxInstaller::Result(InstallError::FINGERPRINT_WRITE_FAILED);
   }
 
   std::unique_ptr<base::DictionaryValue> manifest = ReadManifest(unpack_path);
   if (!manifest.get())
-    return UnpackerError::kBadManifest;
+    return CrxInstaller::Result(InstallError::BAD_MANIFEST);
 
-  return item->component.installer->Install(*manifest, unpack_path)
-             ? UnpackerError::kNone
-             : UnpackerError::kInstallerError;
+  return item->component.installer->Install(*manifest, unpack_path);
 }
 
 void ActionUpdate::InstallComplete(const std::string& id,
-                                   UnpackerError error,
+                                   ErrorCategory error_category,
+                                   int error,
                                    int extended_error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(id == update_context_->queue.front());
 
   CrxUpdateItem* item = FindUpdateItemById(id);
   DCHECK(item);
 
-  if (error == UnpackerError::kNone)
+  if (error == 0) {
+    DCHECK_EQ(ErrorCategory::kErrorNone, error_category);
+    DCHECK_EQ(0, extended_error);
     OnInstallSuccess(item);
-  else
-    OnInstallError(item, error, extended_error);
+  } else {
+    OnInstallError(item, error_category, error, extended_error);
+  }
 }
 
 ActionUpdateDiff::ActionUpdateDiff() {
 }
 
 ActionUpdateDiff::~ActionUpdateDiff() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 std::unique_ptr<Action> ActionUpdateDiff::Create() {
@@ skipping 68 matching lines @@
   DCHECK(item->state == CrxUpdateItem::State::kUpdatingDiff);
 
   item->component.version = item->next_version;
   item->component.fingerprint = item->next_fp;
   ChangeItemState(item, CrxUpdateItem::State::kUpdated);
 
   UpdateCrxComplete(item);
 }
 
 void ActionUpdateDiff::OnInstallError(CrxUpdateItem* item,
-                                      UnpackerError error,
+                                      ErrorCategory error_category,
+                                      int error,
                                       int extended_error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  item->diff_error_category =
-      static_cast<int>(UnpackerErrorToErrorCategory(error));
-  item->diff_error_code = static_cast<int>(error);
+  item->diff_error_category = static_cast<int>(error_category);
+  item->diff_error_code = error;
   item->diff_extra_code1 = extended_error;
   item->diff_update_failed = true;
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&ActionUpdateDiff::TryUpdateFull, base::Unretained(this)));
 }
 
 ActionUpdateFull::ActionUpdateFull() {
 }
@@ skipping 66 matching lines @@
   DCHECK(item->state == CrxUpdateItem::State::kUpdating);
 
   item->component.version = item->next_version;
   item->component.fingerprint = item->next_fp;
   ChangeItemState(item, CrxUpdateItem::State::kUpdated);
 
   UpdateCrxComplete(item);
 }
 
 void ActionUpdateFull::OnInstallError(CrxUpdateItem* item,
-                                      UnpackerError error,
+                                      ErrorCategory error_category,
+                                      int error,
                                       int extended_error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(item->state == CrxUpdateItem::State::kUpdating);
 
-  item->error_category = static_cast<int>(UnpackerErrorToErrorCategory(error));
-  item->error_code = static_cast<int>(error);
+  item->error_category = static_cast<int>(error_category);
+  item->error_code = error;
   item->extra_code1 = extended_error;
   ChangeItemState(item, CrxUpdateItem::State::kNoUpdate);
 
   UpdateCrxComplete(item);
 }
 
 }  // namespace update_client