add flags to recovery executable.

chrome/browser/component_updater/recovery_component_installer.cc

 // Copyright (c) 2012 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/browser/component_updater/recovery_component_installer.h"
 
 #include <stdint.h>
 #include <string>
 
 #include "base/base_paths.h"
@@ skipping 70 matching lines @@
 
 #if !defined(OS_CHROMEOS)
 // Checks if elevated recovery simulation switch was present on the command
 // line. This is for testing purpose.
 bool SimulatingElevatedRecovery() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kSimulateElevatedRecovery);
 }
 #endif  // !defined(OS_CHROMEOS)
 
+base::CommandLine GetRecoveryInstallCommandLine(
+    const base::FilePath& command,
+    const base::DictionaryValue& manifest,
+    bool is_deferred_run,
+    const Version& version) {
+  base::CommandLine command_line(command);
+
+  // Add a flag to for re-attempted install with elevated privilege so that the
+  // recovery executable can report back accordingly.
+  if (is_deferred_run)
+    command_line.AppendArg("/deferredrun");
+
+  std::string arguments;
+  if (manifest.GetStringASCII("x-recovery-args", &arguments))
+    command_line.AppendArg(arguments);
+  std::string add_version;
+  if (manifest.GetStringASCII("x-recovery-add-version", &add_version) &&
+      add_version == "yes") {
+    std::string version_string = "/version ";
+    version_string += version.GetString();
+    command_line.AppendArg(version_string);
+  }
+
+  return command_line;
+}
+
 #if defined(OS_WIN)
 scoped_ptr<base::DictionaryValue> ReadManifest(const base::FilePath& manifest) {
   JSONFileValueDeserializer deserializer(manifest);
   std::string error;
   scoped_ptr<base::Value> root(deserializer.Deserialize(NULL, &error));
   if (root.get() && root->IsType(base::Value::TYPE_DICTIONARY)) {
     return scoped_ptr<base::DictionaryValue>(
         static_cast<base::DictionaryValue*>(root.release()));
   }
   return scoped_ptr<base::DictionaryValue>();
@@ skipping 24 matching lines @@
   std::string name;
   manifest->GetStringASCII("name", &name);
   if (name != kRecoveryManifestName)
     return;
   std::string proposed_version;
   manifest->GetStringASCII("version", &proposed_version);
   const Version version(proposed_version.c_str());
   if (!version.IsValid())
     return;
 
-  base::CommandLine cmdline(main_file);
-  std::string arguments;
-  if (manifest->GetStringASCII("x-recovery-args", &arguments))
-    cmdline.AppendArg(arguments);
-  std::string add_version;
-  if (manifest->GetStringASCII("x-recovery-add-version", &add_version) &&
-      add_version == "yes") {
-    cmdline.AppendSwitchASCII("version", version.GetString());
-  }
+  const bool is_deferred_run = true;
+  const auto cmdline = GetRecoveryInstallCommandLine(
+      main_file, *manifest, is_deferred_run, version);
 
   RecordRecoveryComponentUMAEvent(RCE_RUNNING_ELEVATED);
 
   base::LaunchOptions options;
   options.start_hidden = true;
   base::Process process = base::LaunchElevatedProcess(cmdline, options);
 
   base::WorkerPool::PostTask(
       FROM_HERE,
       base::Bind(&WaitForElevatedInstallToComplete, base::Passed(&process)),
@@ skipping 170 matching lines @@
   if (base::PathExists(path) && !base::DeleteFile(path, true))
     return false;
   if (!base::Move(unpack_path, path)) {
     DVLOG(1) << "Recovery component move failed.";
     return false;
   }
 
   base::FilePath main_file = path.Append(kRecoveryFileName);
   if (!base::PathExists(main_file))
     return false;
+
   // Run the recovery component.
-  base::CommandLine cmdline(main_file);
-  std::string arguments;
-  if (manifest.GetStringASCII("x-recovery-args", &arguments))
-    cmdline.AppendArg(arguments);
-  std::string add_version;
-  if (manifest.GetStringASCII("x-recovery-add-version", &add_version) &&
-      add_version == "yes") {
-    cmdline.AppendSwitchASCII("version", current_version_.GetString());
-  }
+  const bool is_deferred_run = false;
+  const auto cmdline = GetRecoveryInstallCommandLine(
+      main_file, manifest, is_deferred_run, current_version_);
 
   if (!RunInstallCommand(cmdline, path)) {
     return false;
   }
 
   current_version_ = version;
   if (prefs_) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
@@ skipping 48 matching lines @@
 #endif  // OS_WIN
   prefs->SetBoolean(prefs::kRecoveryComponentNeedsElevation, false);
 }
 
 void DeclinedElevatedRecoveryInstall(PrefService* prefs) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   prefs->SetBoolean(prefs::kRecoveryComponentNeedsElevation, false);
 }
 
 }  // namespace component_updater