AU: Start an UpdateAttempter unit test suite.

update_attempter.cc

 // Copyright (c) 2010 The Chromium OS 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 "update_engine/update_attempter.h"
 
 // From 'man clock_gettime': feature test macro: _POSIX_C_SOURCE >= 199309L
 #ifndef _POSIX_C_SOURCE
 #define _POSIX_C_SOURCE 199309L
 #endif  // _POSIX_C_SOURCE
@@ skipping 69 matching lines @@
   if (type == PostinstallRunnerAction::StaticType())
     return kActionCodePostinstallRunnerError;
   if (type == SetBootableFlagAction::StaticType())
     return kActionCodeSetBootableFlagError;
 
   return code;
 }
 
 UpdateAttempter::UpdateAttempter(PrefsInterface* prefs,
                                  MetricsLibraryInterface* metrics_lib)
-    : dbus_service_(NULL),
+    : processor_(new ActionProcessor()),
+      dbus_service_(NULL),
       prefs_(prefs),
       metrics_lib_(metrics_lib),
       update_check_scheduler_(NULL),
       http_response_code_(0),
       priority_(utils::kProcessPriorityNormal),
       manage_priority_source_(NULL),
       download_active_(false),
       status_(UPDATE_STATUS_IDLE),
       download_progress_(0.0),
       last_checked_time_(0),
@@ skipping 16 matching lines @@
   }
   if (status_ != UPDATE_STATUS_IDLE) {
     // Update in progress. Do nothing
     return;
   }
   http_response_code_ = 0;
   if (!omaha_request_params_.Init(app_version, omaha_url)) {
     LOG(ERROR) << "Unable to initialize Omaha request device params.";
     return;
   }
-  CHECK(!processor_.IsRunning());
-  processor_.set_delegate(this);
+  CHECK(!processor_->IsRunning());
+  processor_->set_delegate(this);
 
   // Actions:
   shared_ptr<OmahaRequestAction> update_check_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              NULL,
                              new LibcurlHttpFetcher));
   shared_ptr<OmahaResponseHandlerAction> response_handler_action(
       new OmahaResponseHandlerAction);
   shared_ptr<FilesystemCopierAction> filesystem_copier_action(
@@ skipping 40 matching lines @@
   actions_.push_back(shared_ptr<AbstractAction>(
       postinstall_runner_action_precommit));
   actions_.push_back(shared_ptr<AbstractAction>(set_bootable_flag_action));
   actions_.push_back(shared_ptr<AbstractAction>(
       postinstall_runner_action_postcommit));
   actions_.push_back(shared_ptr<AbstractAction>(update_complete_action));
 
   // Enqueue the actions
   for (vector<shared_ptr<AbstractAction> >::iterator it = actions_.begin();
        it != actions_.end(); ++it) {
-    processor_.EnqueueAction(it->get());
+    processor_->EnqueueAction(it->get());
   }
 
   // Bond them together. We have to use the leaf-types when calling
   // BondActions().
   BondActions(update_check_action.get(),
               response_handler_action.get());
   BondActions(response_handler_action.get(),
               filesystem_copier_action.get());
   BondActions(filesystem_copier_action.get(),
               kernel_filesystem_copier_action.get());
   BondActions(kernel_filesystem_copier_action.get(),
               download_action.get());
   BondActions(download_action.get(),
               postinstall_runner_action_precommit.get());
   BondActions(postinstall_runner_action_precommit.get(),
               set_bootable_flag_action.get());
   BondActions(set_bootable_flag_action.get(),
               postinstall_runner_action_postcommit.get());
 
   SetStatusAndNotify(UPDATE_STATUS_CHECKING_FOR_UPDATE);
-  processor_.StartProcessing();
+  processor_->StartProcessing();
 }
 
 void UpdateAttempter::CheckForUpdate(const std::string& app_version,
                                      const std::string& omaha_url) {
   if (status_ != UPDATE_STATUS_IDLE) {
     LOG(INFO) << "Check for update requested, but status is "
               << UpdateStatusToString(status_) << ", so not checking.";
     return;
   }
   Update(app_version, omaha_url);
@@ skipping 198 matching lines @@
   if (error_event_.get() == NULL)
     return false;
 
   LOG(INFO) << "Update failed -- reporting the error event.";
   shared_ptr<OmahaRequestAction> error_event_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              error_event_.release(),  // Pass ownership.
                              new LibcurlHttpFetcher));
   actions_.push_back(shared_ptr<AbstractAction>(error_event_action));
-  processor_.EnqueueAction(error_event_action.get());
+  processor_->EnqueueAction(error_event_action.get());
   SetStatusAndNotify(UPDATE_STATUS_REPORTING_ERROR_EVENT);
-  processor_.StartProcessing();
+  processor_->StartProcessing();
   return true;
 }
 
 void UpdateAttempter::SetPriority(utils::ProcessPriority priority) {
   if (priority_ == priority) {
     return;
   }
   if (utils::SetProcessPriority(priority)) {
     priority_ = priority;
     LOG(INFO) << "Process priority = " << priority_;
@@ skipping 34 matching lines @@
     SetPriority(utils::kProcessPriorityNormal);
     return true;
   }
   // Set the priority to high and let GLib destroy the timeout source.
   SetPriority(utils::kProcessPriorityHigh);
   manage_priority_source_ = NULL;
   return false;
 }
 
 }  // namespace chromeos_update_engine