Revert of 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,
-                   ErrorCategory::kUnpackError, static_cast<int>(result.error),
+                   base::Unretained(this), item, crx_path, 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 result = DoInstall(item, crx_path, unpack_path);
-  const ErrorCategory error_category =
-      result.error ? ErrorCategory::kInstallError : ErrorCategory::kErrorNone;
+  const auto error = DoInstall(item, crx_path, unpack_path);
   update_context_->blocking_task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(&ActionUpdate::InstallCompleteOnBlockingTaskRunner,
-                 base::Unretained(this), item, crx_path, error_category,
-                 result.error, result.extended_error));
+      FROM_HERE, base::Bind(&ActionUpdate::InstallCompleteOnBlockingTaskRunner,
+                            base::Unretained(this), item, crx_path, error, 0));
 }
 
 void ActionUpdate::InstallCompleteOnBlockingTaskRunner(
     CrxUpdateItem* item,
     const base::FilePath& crx_path,
-    ErrorCategory error_category,
-    int error,
+    UnpackerError 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_category, error, extended_error),
+                 item->id, error, extended_error),
       base::TimeDelta::FromMilliseconds(update_context_->config->StepDelay()));
 }
 
-CrxInstaller::Result ActionUpdate::DoInstall(
-    CrxUpdateItem* item,
-    const base::FilePath& crx_path,
-    const base::FilePath& unpack_path) {
+UnpackerError 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 CrxInstaller::Result(InstallError::FINGERPRINT_WRITE_FAILED);
+    return UnpackerError::kFingerprintWriteFailed;
   }
 
   std::unique_ptr<base::DictionaryValue> manifest = ReadManifest(unpack_path);
   if (!manifest.get())
-    return CrxInstaller::Result(InstallError::BAD_MANIFEST);
+    return UnpackerError::kBadManifest;
 
-  return item->component.installer->Install(*manifest, unpack_path);
+  return item->component.installer->Install(*manifest, unpack_path)
+             ? UnpackerError::kNone
+             : UnpackerError::kInstallerError;
 }
 
 void ActionUpdate::InstallComplete(const std::string& id,
-                                   ErrorCategory error_category,
-                                   int error,
+                                   UnpackerError error,
                                    int extended_error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(id == update_context_->queue.front());
 
   CrxUpdateItem* item = FindUpdateItemById(id);
   DCHECK(item);
 
-  if (error == 0) {
-    DCHECK_EQ(ErrorCategory::kErrorNone, error_category);
-    DCHECK_EQ(0, extended_error);
+  if (error == UnpackerError::kNone)
     OnInstallSuccess(item);
-  } else {
-    OnInstallError(item, error_category, error, extended_error);
-  }
+  else
+    OnInstallError(item, 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,
-                                      ErrorCategory error_category,
-                                      int error,
+                                      UnpackerError error,
                                       int extended_error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  item->diff_error_category = static_cast<int>(error_category);
-  item->diff_error_code = error;
+  item->diff_error_category =
+      static_cast<int>(UnpackerErrorToErrorCategory(error));
+  item->diff_error_code = static_cast<int>(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,
-                                      ErrorCategory error_category,
-                                      int error,
+                                      UnpackerError error,
                                       int extended_error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(item->state == CrxUpdateItem::State::kUpdating);
 
-  item->error_category = static_cast<int>(error_category);
-  item->error_code = error;
+  item->error_category = static_cast<int>(UnpackerErrorToErrorCategory(error));
+  item->error_code = static_cast<int>(error);
   item->extra_code1 = extended_error;
   ChangeItemState(item, CrxUpdateItem::State::kNoUpdate);
 
   UpdateCrxComplete(item);
 }
 
 }  // namespace update_client