Revert of Add best-effort/allow rollback flags on WorkItem.

chrome/installer/util/work_item_list.cc

 // Copyright (c) 2011 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/installer/util/work_item_list.h"
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "chrome/installer/util/callback_work_item.h"
 #include "chrome/installer/util/copy_tree_work_item.h"
@@ skipping 10 matching lines @@
 WorkItemList::~WorkItemList() {
   for (WorkItemIterator itr = list_.begin(); itr != list_.end(); ++itr) {
     delete (*itr);
   }
   for (WorkItemIterator itr = executed_list_.begin();
        itr != executed_list_.end(); ++itr) {
     delete (*itr);
   }
 }
 
-WorkItemList::WorkItemList() = default;
+WorkItemList::WorkItemList()
+    : status_(ADD_ITEM) {
+}
 
-bool WorkItemList::DoImpl() {
-  VLOG(1) << "Beginning execution of work item list " << log_message();
+bool WorkItemList::Do() {
+  if (status_ != ADD_ITEM)
+    return false;
 
   bool result = true;
   while (!list_.empty()) {
     WorkItem* work_item = list_.front();
     list_.pop_front();
     executed_list_.push_front(work_item);
-
-    if (best_effort())
-      work_item->set_best_effort(true);
-    if (!rollback_enabled())
-      work_item->set_rollback_enabled(false);
-
     if (!work_item->Do()) {
       LOG(ERROR) << "item execution failed " << work_item->log_message();
       result = false;
       break;
     }
   }
 
   if (result)
-    VLOG(1) << "Successful execution of work item list " << log_message();
-  else
-    LOG(ERROR) << "Failed execution of work item list " << log_message();
+    VLOG(1) << "list execution succeeded";
 
+  status_ = LIST_EXECUTED;
   return result;
 }
 
-void WorkItemList::RollbackImpl() {
+void WorkItemList::Rollback() {
+  if (status_ != LIST_EXECUTED)
+    return;
+
   for (WorkItemIterator itr = executed_list_.begin();
        itr != executed_list_.end(); ++itr) {
     (*itr)->Rollback();
   }
+
+  status_ = LIST_ROLLED_BACK;
+  return;
 }
 
 void WorkItemList::AddWorkItem(WorkItem* work_item) {
-  DCHECK_EQ(BEFORE_DO, state());
+  DCHECK(status_ == ADD_ITEM);
   list_.push_back(work_item);
 }
 
 WorkItem* WorkItemList::AddCallbackWorkItem(
     base::Callback<bool(const CallbackWorkItem&)> callback) {
   WorkItem* item = WorkItem::CreateCallbackWorkItem(callback);
   AddWorkItem(item);
   return item;
 }
 
@@ skipping 41 matching lines @@
     HKEY predefined_root,
     const std::wstring& key_path,
     REGSAM wow64_access,
     const std::wstring& value_name) {
   WorkItem* item = WorkItem::CreateDeleteRegValueWorkItem(
       predefined_root, key_path, wow64_access, value_name);
   AddWorkItem(item);
   return item;
 }
 
+WorkItem* WorkItemList::AddDeleteTreeWorkItem(
+    const base::FilePath& root_path,
+    const base::FilePath& temp_path,
+    const std::vector<base::FilePath>& key_paths) {
+  WorkItem* item = WorkItem::CreateDeleteTreeWorkItem(root_path, temp_path,
+                                                      key_paths);
+  AddWorkItem(item);
+  return item;
+}
+
 WorkItem* WorkItemList::AddDeleteTreeWorkItem(const base::FilePath& root_path,
                                               const base::FilePath& temp_path) {
-  WorkItem* item = WorkItem::CreateDeleteTreeWorkItem(root_path, temp_path);
-  AddWorkItem(item);
-  return item;
+  std::vector<base::FilePath> no_key_files;
+  return AddDeleteTreeWorkItem(root_path, temp_path, no_key_files);
 }
 
 WorkItem* WorkItemList::AddMoveTreeWorkItem(const std::wstring& source_path,
                                             const std::wstring& dest_path,
                                             const std::wstring& temp_dir,
                                             MoveTreeOption duplicate_option) {
   WorkItem* item = WorkItem::CreateMoveTreeWorkItem(base::FilePath(source_path),
                                                     base::FilePath(dest_path),
                                                     base::FilePath(temp_dir),
                                                     duplicate_option);
@@ skipping 66 matching lines @@
 }
 
 WorkItem* WorkItemList::AddSelfRegWorkItem(const std::wstring& dll_path,
                                            bool do_register,
                                            bool user_level_registration) {
   WorkItem* item = WorkItem::CreateSelfRegWorkItem(dll_path, do_register,
                                                    user_level_registration);
   AddWorkItem(item);
   return item;
 }
+
+////////////////////////////////////////////////////////////////////////////////
+NoRollbackWorkItemList::~NoRollbackWorkItemList() {
+}
+
+bool NoRollbackWorkItemList::Do() {
+  if (status_ != ADD_ITEM)
+    return false;
+
+  bool result = true;
+  while (!list_.empty()) {
+    WorkItem* work_item = list_.front();
+    list_.pop_front();
+    executed_list_.push_front(work_item);
+    work_item->set_ignore_failure(true);
+    if (!work_item->Do()) {
+      LOG(ERROR) << "NoRollbackWorkItemList: item execution failed "
+                 << work_item->log_message();
+      result = false;
+    }
+  }
+
+  if (result)
+    VLOG(1) << "NoRollbackWorkItemList: list execution succeeded";
+
+  status_ = LIST_EXECUTED;
+  return result;
+}
+
+void NoRollbackWorkItemList::Rollback() {
+  // Ignore rollback.
+}