Add support to update_engine_client for -app_version and -omaha_url.

update_engine_client.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 <string>
+
 #include <gflags/gflags.h>
 #include <glib.h>
 
 #include "update_engine/marshal.glibmarshal.h"
 #include "update_engine/dbus_constants.h"
 #include "update_engine/subprocess.h"
 #include "update_engine/utils.h"
 
 extern "C" {
 #include "update_engine/update_engine.dbusclient.h"
 }
 
 using chromeos_update_engine::kUpdateEngineServiceName;
 using chromeos_update_engine::kUpdateEngineServicePath;
 using chromeos_update_engine::kUpdateEngineServiceInterface;
 using chromeos_update_engine::utils::GetGErrorMessage;
+using std::string;
 
-DEFINE_bool(status, false, "Print the status to stdout.");
+DEFINE_string(app_version, "",
+              "Force the current app version.");
+DEFINE_bool(check_for_update, false,
+            "Initiate check for updates.");
 DEFINE_bool(force_update, false,
             "Force an update, even over an expensive network.");
-DEFINE_bool(check_for_update, false,
-            "Initiate check for updates.");
+DEFINE_string(omaha_url, "",
+              "The URL of the Omaha update server.");
+DEFINE_bool(status, false, "Print the status to stdout.");
 DEFINE_bool(watch_for_updates, false,
             "Listen for status updates and print them to the screen.");
 
 namespace {
 
 bool GetProxy(DBusGProxy** out_proxy) {
   DBusGConnection* bus;
   DBusGProxy* proxy;
   GError* error = NULL;
 
@@ skipping 90 matching lines @@
   GMainLoop* loop = g_main_loop_new (NULL, TRUE);
   dbus_g_proxy_connect_signal(proxy,
                               kStatusUpdate,
                               G_CALLBACK(StatusUpdateSignalHandler),
                               NULL,
                               NULL);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
 }
 
-bool CheckForUpdates(bool force) {
+bool CheckForUpdates(bool force, const string& app_version,
+                     const string& omaha_url) {
   DBusGProxy* proxy;
   GError* error = NULL;
 
   CHECK(GetProxy(&proxy));
 
   gboolean rc =
-      org_chromium_UpdateEngineInterface_check_for_update(proxy, &error);
+      org_chromium_UpdateEngineInterface_attempt_update(proxy,
+                                                        app_version.c_str(),
+                                                        omaha_url.c_str(),
+                                                        &error);
   CHECK_EQ(rc, TRUE) << "Error checking for update: "
                      << GetGErrorMessage(error);
   return true;
 }
 
 }  // namespace {}
 
 int main(int argc, char** argv) {
   // Boilerplate init commands.
   g_type_init();
   g_thread_init(NULL);
   dbus_g_thread_init();
   chromeos_update_engine::Subprocess::Init();
   google::ParseCommandLineFlags(&argc, &argv, true);
 
   if (FLAGS_status) {
     LOG(INFO) << "Querying Update Engine status...";
     if (!GetStatus()) {
       LOG(FATAL) << "GetStatus() failed.";
     }
     return 0;
   }
-  if (FLAGS_force_update || FLAGS_check_for_update) {
+  if (FLAGS_force_update || FLAGS_check_for_update ||
+      !FLAGS_app_version.empty() || !FLAGS_omaha_url.empty()) {
     LOG(INFO) << "Initiating update check and install.";
     if (FLAGS_force_update) {
       LOG(INFO) << "Will not abort due to being on expensive network.";
     }
-    CHECK(CheckForUpdates(FLAGS_force_update))
+    CHECK(CheckForUpdates(FLAGS_force_update, FLAGS_app_version,
+                          FLAGS_omaha_url))
         << "Update check/initiate update failed.";
     return 0;
   }
   if (FLAGS_watch_for_updates) {
     LOG(INFO) << "Watching for status updates.";
     WatchForUpdates();  // Should never return.
     return 1;
   }
 
   LOG(INFO) << "No flags specified. Exiting.";
   return 0;
 }