Initial implementation of sending an install success even to Omaha.

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 82 matching lines @@
   }
   if (status_ != UPDATE_STATUS_IDLE) {
     // Update in progress. Do nothing
     return;
   }
   full_update_ = force_full_update;
   CHECK(!processor_.IsRunning());
   processor_.set_delegate(this);
 
   // Actions:
-  shared_ptr<OmahaRequestPrepAction> request_prep_action(
+  shared_ptr<OmahaRequestPrepAction> update_check_prep_action(
       new OmahaRequestPrepAction(force_full_update));
   shared_ptr<OmahaRequestAction> update_check_action(
-      new OmahaRequestAction(new LibcurlHttpFetcher));
+      new OmahaRequestAction(NULL, new LibcurlHttpFetcher));
   shared_ptr<OmahaResponseHandlerAction> response_handler_action(
       new OmahaResponseHandlerAction);
   shared_ptr<FilesystemCopierAction> filesystem_copier_action(
       new FilesystemCopierAction(false));
   shared_ptr<FilesystemCopierAction> kernel_filesystem_copier_action(
       new FilesystemCopierAction(true));
   shared_ptr<DownloadAction> download_action(
       new DownloadAction(new LibcurlHttpFetcher));
   shared_ptr<PostinstallRunnerAction> postinstall_runner_action_precommit(
       new PostinstallRunnerAction(true));
   shared_ptr<SetBootableFlagAction> set_bootable_flag_action(
       new SetBootableFlagAction);
   shared_ptr<PostinstallRunnerAction> postinstall_runner_action_postcommit(
       new PostinstallRunnerAction(false));
+  shared_ptr<OmahaRequestPrepAction> install_success_prep_action(
+      new OmahaRequestPrepAction(false));
+  shared_ptr<OmahaRequestAction> install_success_action(
+      new OmahaRequestAction(new OmahaEvent(OmahaEvent::kTypeInstallComplete,
+                                            OmahaEvent::kResultSuccess,
+                                            0),
+                             new LibcurlHttpFetcher));
 
   download_action->set_delegate(this);
   response_handler_action_ = response_handler_action;
 
-  actions_.push_back(shared_ptr<AbstractAction>(request_prep_action));
+  actions_.push_back(shared_ptr<AbstractAction>(update_check_prep_action));
   actions_.push_back(shared_ptr<AbstractAction>(update_check_action));
   actions_.push_back(shared_ptr<AbstractAction>(response_handler_action));
   actions_.push_back(shared_ptr<AbstractAction>(filesystem_copier_action));
   actions_.push_back(shared_ptr<AbstractAction>(
       kernel_filesystem_copier_action));
   actions_.push_back(shared_ptr<AbstractAction>(download_action));
   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>(install_success_prep_action));
+  actions_.push_back(shared_ptr<AbstractAction>(install_success_action));
 
   // Enqueue the actions
   for (vector<shared_ptr<AbstractAction> >::iterator it = actions_.begin();
        it != actions_.end(); ++it) {
     processor_.EnqueueAction(it->get());
   }
 
   // Bond them together. We have to use the leaf-types when calling
   // BondActions().
-  BondActions(request_prep_action.get(),
+  BondActions(update_check_prep_action.get(),
               update_check_action.get());
   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());
+  BondActions(install_success_prep_action.get(),
+              install_success_action.get());
 
   SetStatusAndNotify(UPDATE_STATUS_CHECKING_FOR_UPDATE);
   processor_.StartProcessing();
 }
 
 void UpdateAttempter::CheckForUpdate() {
   if (status_ != UPDATE_STATUS_IDLE) {
     LOG(INFO) << "Check for update requested, but status is "
               << UpdateStatusToString(status_) << ", so not checking.";
     return;
@@ skipping 102 matching lines @@
   update_engine_service_emit_status_update(
       dbus_service_,
       last_checked_time_,
       download_progress_,
       UpdateStatusToString(status_),
       new_version_.c_str(),
       new_size_);
 }
 
 }  // namespace chromeos_update_engine