AU: Remove obsolete SetBootableFlagAction.

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
 #include <time.h>
 
 #include <string>
 #include <tr1/memory>
 #include <vector>
 
 #include <glib.h>
 #include <metrics/metrics_library.h>
 
 #include "update_engine/dbus_service.h"
 #include "update_engine/download_action.h"
 #include "update_engine/filesystem_copier_action.h"
 #include "update_engine/libcurl_http_fetcher.h"
 #include "update_engine/multi_http_fetcher.h"
 #include "update_engine/omaha_request_action.h"
 #include "update_engine/omaha_request_params.h"
 #include "update_engine/omaha_response_handler_action.h"
 #include "update_engine/postinstall_runner_action.h"
 #include "update_engine/prefs_interface.h"
-#include "update_engine/set_bootable_flag_action.h"
 #include "update_engine/update_check_scheduler.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using std::make_pair;
 using std::tr1::shared_ptr;
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
@@ skipping 37 matching lines @@
 
   const string type = action->Type();
   if (type == OmahaRequestAction::StaticType())
     return kActionCodeOmahaRequestError;
   if (type == OmahaResponseHandlerAction::StaticType())
     return kActionCodeOmahaResponseHandlerError;
   if (type == FilesystemCopierAction::StaticType())
     return kActionCodeFilesystemCopierError;
   if (type == PostinstallRunnerAction::StaticType())
     return kActionCodePostinstallRunnerError;
-  if (type == SetBootableFlagAction::StaticType())
-    return kActionCodeSetBootableFlagError;
 
   return code;
 }
 
 UpdateAttempter::UpdateAttempter(PrefsInterface* prefs,
                                  MetricsLibraryInterface* metrics_lib)
     : processor_(new ActionProcessor()),
       dbus_service_(NULL),
       prefs_(prefs),
       metrics_lib_(metrics_lib),
@@ skipping 57 matching lines @@
   shared_ptr<DownloadAction> download_action(
       new DownloadAction(prefs_, new MultiHttpFetcher<LibcurlHttpFetcher>));
   shared_ptr<OmahaRequestAction> download_finished_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              new OmahaEvent(
                                  OmahaEvent::kTypeUpdateDownloadFinished),
                              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(

[adlr, 2010/11/08 22:54:07]

you may want to delete this now? or is this in a separate CL?

[petkov, 2010/11/08 22:56:53]

I thought it's going to be cleaner in a separate CL.

       new PostinstallRunnerAction(false));
   shared_ptr<OmahaRequestAction> update_complete_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              new OmahaEvent(OmahaEvent::kTypeUpdateComplete),
                              new LibcurlHttpFetcher));
 
   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));
   actions_.push_back(shared_ptr<AbstractAction>(download_started_action));
   actions_.push_back(shared_ptr<AbstractAction>(download_action));
   actions_.push_back(shared_ptr<AbstractAction>(download_finished_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>(update_complete_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(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();
 }
 
 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 "
@@ skipping 315 matching lines @@
     if (resume_offset < response_handler_action_->install_plan().size) {
       ranges.push_back(make_pair(resume_offset, -1));
     }
   } else {
     ranges.push_back(make_pair(0, -1));
   }
   fetcher->set_ranges(ranges);
 }
 
 }  // namespace chromeos_update_engine