Add support to update_engine to poke Omaha after an update has been applied

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 110 matching lines @@
 
 UpdateAttempter::~UpdateAttempter() {
   CleanupPriorityManagement();
 }
 
 void UpdateAttempter::Update(const std::string& app_version,
                              const std::string& omaha_url,
                              bool obey_proxies) {
   chrome_proxy_resolver_.Init();
   if (status_ == UPDATE_STATUS_UPDATED_NEED_REBOOT) {
+    // Although we have applied an update, we still want to ping Omaha
+    // to ensure the number of active statistics is accurate.
     LOG(INFO) << "Not updating b/c we already updated and we're waiting for "
-              << "reboot";
+              << "reboot, we'll ping Omaha instead";
+    PingOmaha();
     return;
   }
   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;
@@ skipping 23 matching lines @@
   // Actions:
   LibcurlHttpFetcher* update_check_fetcher =
       new LibcurlHttpFetcher(GetProxyResolver());
   // Try harder to connect to the network. See comment in
   // libcurl_http_fetcher.cc.
   update_check_fetcher->set_no_network_max_retries(3);
   shared_ptr<OmahaRequestAction> update_check_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              NULL,
-                             update_check_fetcher));  // passes ownership
+                             update_check_fetcher,  // passes ownership
+                             false));
   shared_ptr<OmahaResponseHandlerAction> response_handler_action(
       new OmahaResponseHandlerAction(prefs_));
   shared_ptr<FilesystemCopierAction> filesystem_copier_action(
       new FilesystemCopierAction(false, false));
   shared_ptr<FilesystemCopierAction> kernel_filesystem_copier_action(
       new FilesystemCopierAction(true, false));
   shared_ptr<OmahaRequestAction> download_started_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              new OmahaEvent(
                                  OmahaEvent::kTypeUpdateDownloadStarted),
-                             new LibcurlHttpFetcher(GetProxyResolver())));
+                             new LibcurlHttpFetcher(GetProxyResolver()),
+                             false));
   shared_ptr<DownloadAction> download_action(
       new DownloadAction(prefs_, new MultiRangeHTTPFetcher(
           new LibcurlHttpFetcher(GetProxyResolver()))));
   // This action is always initially in place to warn OS vendor of a
   // signature failure.  If it's not needed, it will be told to skip.
   shared_ptr<OmahaRequestAction> download_signature_warning(
       new OmahaRequestAction(
           prefs_,
           omaha_request_params_,
           new OmahaEvent(
               OmahaEvent::kTypeUpdateDownloadFinished,
               OmahaEvent::kResultError,
               kActionCodeDownloadPayloadPubKeyVerificationError),
-          new LibcurlHttpFetcher(GetProxyResolver())));
+          new LibcurlHttpFetcher(GetProxyResolver()),
+          false));
   download_action->set_skip_reporting_signature_fail(
       NewPermanentCallback(download_signature_warning.get(),
                            &OmahaRequestAction::set_should_skip,
                            true));
   shared_ptr<OmahaRequestAction> download_finished_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              new OmahaEvent(
                                  OmahaEvent::kTypeUpdateDownloadFinished),
-                             new LibcurlHttpFetcher(GetProxyResolver())));
+                             new LibcurlHttpFetcher(GetProxyResolver()),
+                             false));
   shared_ptr<FilesystemCopierAction> filesystem_verifier_action(
       new FilesystemCopierAction(false, true));
   shared_ptr<FilesystemCopierAction> kernel_filesystem_verifier_action(
       new FilesystemCopierAction(true, true));
   shared_ptr<PostinstallRunnerAction> postinstall_runner_action(
       new PostinstallRunnerAction);
   shared_ptr<OmahaRequestAction> update_complete_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              new OmahaEvent(OmahaEvent::kTypeUpdateComplete),
-                             new LibcurlHttpFetcher(GetProxyResolver())));
+                             new LibcurlHttpFetcher(GetProxyResolver()),
+                             false));
 
   download_action->set_delegate(this);
   response_handler_action_ = response_handler_action;
   download_action_ = download_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));
@@ skipping 260 matching lines @@
 
 bool UpdateAttempter::ScheduleErrorEventAction() {
   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(GetProxyResolver())));
+                             new LibcurlHttpFetcher(GetProxyResolver()),
+                             false));
   actions_.push_back(shared_ptr<AbstractAction>(error_event_action));
   processor_->EnqueueAction(error_event_action.get());
   SetStatusAndNotify(UPDATE_STATUS_REPORTING_ERROR_EVENT);
   processor_->StartProcessing();
   return true;
 }
 
 void UpdateAttempter::SetPriority(utils::ProcessPriority priority) {
   if (priority_ == priority) {
     return;
@@ skipping 80 matching lines @@
     prefs_->GetInt64(kPrefsUpdateStateNextDataOffset, &next_data_offset);
     uint64_t resume_offset = manifest_metadata_size + next_data_offset;
     if (resume_offset < response_handler_action_->install_plan().size) {
       fetcher->AddRange(resume_offset, -1);
     }
   } else {
     fetcher->AddRange(0, -1);
   }
 }
 
+void UpdateAttempter::PingOmaha() {
+  shared_ptr<OmahaRequestAction> ping_action(
+      new OmahaRequestAction(prefs_,
+                             omaha_request_params_,
+                             NULL,
+                             new LibcurlHttpFetcher(GetProxyResolver()),
+                             true));
+  actions_.push_back(shared_ptr<OmahaRequestAction>(ping_action));
+  CHECK(!processor_->IsRunning());
+  processor_->set_delegate(NULL);
+  processor_->EnqueueAction(ping_action.get());
+  g_idle_add(&StaticStartProcessing, this);
+  SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT);
+}
+
 }  // namespace chromeos_update_engine