Add best-effort/allow rollback flags on WorkItem.

chrome/installer/util/set_reg_value_work_item.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/set_reg_value_work_item.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/win/registry.h"
 #include "chrome/installer/util/logging_installer.h"
@@ skipping 111 matching lines @@
       wow64_access_(wow64_access),
       type_(REG_SZ),
       previous_type_(0),
       status_(SET_VALUE) {
   DCHECK(wow64_access == 0 ||
          wow64_access == KEY_WOW64_32KEY ||
          wow64_access == KEY_WOW64_64KEY);
   // Nothing to do, |get_value_callback| will fill |value_| later.
 }
 
-bool SetRegValueWorkItem::Do() {
-  LONG result = ERROR_SUCCESS;
-  base::win::RegKey key;
-  if (status_ != SET_VALUE) {
-    // we already did something.
-    VLOG(1) << "multiple calls to Do()";
-    result = ERROR_CANTWRITE;
-    return ignore_failure_;
-  }
+bool SetRegValueWorkItem::DoImpl() {
+  DCHECK_EQ(SET_VALUE, status_);
 
   status_ = VALUE_UNCHANGED;
-  result = key.Open(predefined_root_,
-                    key_path_.c_str(),
-                    KEY_READ | KEY_SET_VALUE | wow64_access_);
+
+  base::win::RegKey key;
+  LONG result = key.Open(predefined_root_, key_path_.c_str(),
+                         KEY_READ | KEY_SET_VALUE | wow64_access_);
   if (result != ERROR_SUCCESS) {
     VLOG(1) << "can not open " << key_path_ << " error: " << result;
-    return ignore_failure_;
+    return false;
   }
 
   DWORD type = 0;
   DWORD size = 0;
   result = key.ReadValue(value_name_.c_str(), NULL, &size, &type);
   // If the value exists but we don't want to overwrite then there's
   // nothing more to do.
   if ((result != ERROR_FILE_NOT_FOUND) && !overwrite_) {
     return true;
   }
@@ skipping 25 matching lines @@
     if (previous_type_ == REG_SZ)
       BinaryDataToString(previous_value_, &previous_value_str);
 
     StringToBinaryData(get_value_callback_.Run(previous_value_str), &value_);
   }
 
   result = key.WriteValue(value_name_.c_str(), &value_[0],
                           static_cast<DWORD>(value_.size()), type_);
   if (result != ERROR_SUCCESS) {
     VLOG(1) << "Failed to write value " << key_path_ << " error: " << result;
-    return ignore_failure_;
+    return false;
   }
 
   status_ = previous_type_ ? VALUE_OVERWRITTEN : NEW_VALUE_CREATED;
   return true;
 }
 
-void SetRegValueWorkItem::Rollback() {
-  if (ignore_failure_)
-    return;
-
-  if (status_ == SET_VALUE || status_ == VALUE_ROLL_BACK)
-    return;
+void SetRegValueWorkItem::RollbackImpl() {
+  DCHECK_NE(SET_VALUE, status_);
+  DCHECK_NE(VALUE_ROLL_BACK, status_);
 
   if (status_ == VALUE_UNCHANGED) {
     status_ = VALUE_ROLL_BACK;
     VLOG(1) << "rollback: setting unchanged, nothing to do";
     return;
   }
 
   base::win::RegKey key;
   LONG result = key.Open(
       predefined_root_, key_path_.c_str(), KEY_SET_VALUE | wow64_access_);
@@ skipping 11 matching lines @@
     result = key.WriteValue(value_name_.c_str(), previous_value,
                             static_cast<DWORD>(previous_value_.size()),
                             previous_type_);
     VLOG(1) << "rollback: restoring " << value_name_ << " error: " << result;
   } else {
     NOTREACHED();
   }
 
   status_ = VALUE_ROLL_BACK;
 }