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

chrome/installer/util/work_item_list.h

 // 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.
 
 #ifndef CHROME_INSTALLER_UTIL_WORK_ITEM_LIST_H_
 #define CHROME_INSTALLER_UTIL_WORK_ITEM_LIST_H_
 
 #include <windows.h>
 #include <stdint.h>
 
 #include <list>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "chrome/installer/util/work_item.h"
 
 namespace base {
 class FilePath;
 }
 
 // A WorkItem subclass that recursively contains a list of WorkItems. Thus it
 // provides functionalities to carry out or roll back the sequence of actions
 // defined by the list of WorkItems it contains.
 // The WorkItems are executed in the same order as they are added to the list.
-// The "best-effort" flag of the WorkItemList is propagated to the WorkItems
-// when it's true. Likewise, the "rollback enabled" flag of the WorkItemList is
-// propagated to the WorkItems when it's false.
 class WorkItemList : public WorkItem {
  public:
   ~WorkItemList() override;
 
+  // Execute the WorkItems in the same order as they are added to the list.
+  // It aborts as soon as one WorkItem fails.
+  bool Do() override;
+
+  // Rollback the WorkItems in the reverse order as they are executed.
+  void Rollback() override;
+
   // Add a WorkItem to the list.
   // A WorkItem can only be added to the list before the list's DO() is called.
   // Once a WorkItem is added to the list. The list owns the WorkItem.
   virtual void AddWorkItem(WorkItem* work_item);
 
   // Add a CallbackWorkItem that invokes a callback.
   virtual WorkItem* AddCallbackWorkItem(
       base::Callback<bool(const CallbackWorkItem&)> callback);
 
   // Add a CopyTreeWorkItem to the list of work items.
@@ skipping 21 matching lines @@
                                             const std::wstring& path,
                                             REGSAM wow64_access);
 
   // Add a DeleteRegValueWorkItem that deletes registry value of type REG_SZ
   // or REG_DWORD.
   virtual WorkItem* AddDeleteRegValueWorkItem(HKEY predefined_root,
                                               const std::wstring& key_path,
                                               REGSAM wow64_access,
                                               const std::wstring& value_name);
 
-  // Add a DeleteTreeWorkItem that recursively deletes a file system hierarchy
-  // at the given root path.
+  // Add a DeleteTreeWorkItem that recursively deletes a file system
+  // hierarchy at the given root path. A key file can be optionally specified
+  // by key_path.
+  virtual WorkItem* AddDeleteTreeWorkItem(
+      const base::FilePath& root_path,
+      const base::FilePath& temp_path,
+      const std::vector<base::FilePath>& key_paths);
+
+  // Same as above but without support for key files.
   virtual WorkItem* AddDeleteTreeWorkItem(const base::FilePath& root_path,
                                           const base::FilePath& temp_path);
 
   // Add a MoveTreeWorkItem to the list of work items.
   virtual WorkItem* AddMoveTreeWorkItem(const std::wstring& source_path,
                                         const std::wstring& dest_path,
                                         const std::wstring& temp_dir,
                                         MoveTreeOption duplicate_option);
 
   // Add a SetRegValueWorkItem that sets a registry value with REG_SZ type
@@ skipping 39 matching lines @@
   virtual WorkItem* AddSelfRegWorkItem(const std::wstring& dll_path,
                                        bool do_register,
                                        bool user_level_registration);
 
  protected:
   friend class WorkItem;
 
   typedef std::list<WorkItem*> WorkItems;
   typedef WorkItems::iterator WorkItemIterator;
 
+  enum ListStatus {
+    // List has not been executed. Ok to add new WorkItem.
+    ADD_ITEM,
+    // List has been executed. Can not add new WorkItem.
+    LIST_EXECUTED,
+    // List has been executed and rolled back. No further action is acceptable.
+    LIST_ROLLED_BACK
+  };
+
   WorkItemList();
 
-  // WorkItem:
-
-  // Execute the WorkItems in the same order as they are added to the list. It
-  // aborts as soon as one WorkItem fails, unless the best-effort flag is true.
-  bool DoImpl() override;
-
-  // Rollback the WorkItems in the reverse order as they are executed.
-  void RollbackImpl() override;
+  ListStatus status_;
 
   // The list of WorkItems, in the order of them being added.
   WorkItems list_;
 
   // The list of executed WorkItems, in the reverse order of them being
   // executed.
   WorkItems executed_list_;
 };
 
+// A specialization of WorkItemList that executes items in the list on a
+// best-effort basis.  Failure of individual items to execute does not prevent
+// subsequent items from being executed.
+// Also, as the class name suggests, Rollback is not possible.
+class NoRollbackWorkItemList : public WorkItemList {
+ public:
+  ~NoRollbackWorkItemList() override;
+
+  // Execute the WorkItems in the same order as they are added to the list.
+  // If a WorkItem fails, the function will return failure but all other
+  // WorkItems will still be executed.
+  bool Do() override;
+
+  // No-op.
+  void Rollback() override;
+};
+
 #endif  // CHROME_INSTALLER_UTIL_WORK_ITEM_LIST_H_