Differential updates for components.

chrome/installer/setup/setup_main.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 <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
+#include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/win/registry.h"
@@ skipping 457 matching lines @@
 }
 
 // Checks app host pre-install conditions, specifically that this is a
 // user-level multi-install.  When the pre-install conditions are not
 // satisfied, the result is written to the registry (via WriteInstallerResult),
 // |status| is set appropriately, and false is returned.
 bool CheckAppHostPreconditions(const InstallationState& original_state,
                                InstallerState* installer_state,
                                installer::InstallStatus* status) {
   if (installer_state->FindProduct(BrowserDistribution::CHROME_APP_HOST)) {
-
     if (!installer_state->is_multi_install()) {
       LOG(DFATAL) << "App Launcher requires multi install";
       *status = installer::APP_HOST_REQUIRES_MULTI_INSTALL;
       // No message string since there is nothing a user can do.
       installer_state->WriteInstallerResult(*status, 0, NULL);
       return false;
     }
 
     if (installer_state->system_install()) {
       LOG(DFATAL) << "App Launcher may only be installed at user-level.";
       *status = installer::APP_HOST_REQUIRES_USER_LEVEL;
       // No message string since there is nothing a user can do.
       installer_state->WriteInstallerResult(*status, 0, NULL);
       return false;
     }
-
   }
 
   return true;
 }
 
 // Checks for compatibility between the current state of the system and the
 // desired operation.  Also applies policy that mutates the desired operation;
 // specifically, the |installer_state| object.
 // Also blocks simultaneous user-level and system-level installs.  In the case
 // of trying to install user-level Chrome when system-level exists, the
@@ skipping 949 matching lines @@
         installer::ChromeFrameReadyModeTempOptOut(original_state,
                                                   *installer_state));
   } else if (cmd_line.HasSwitch(
                  installer::switches::kChromeFrameReadyModeEndTempOptOut)) {
     *exit_code = InstallUtil::GetInstallReturnCode(
         installer::ChromeFrameReadyModeEndTempOptOut(original_state,
                                                      *installer_state));
   } else if (cmd_line.HasSwitch(installer::switches::kChromeFrameQuickEnable)) {
     *exit_code = installer::ChromeFrameQuickEnable(original_state,
                                                    installer_state);
+  } else if (cmd_line.HasSwitch(installer::switches::kPatch)) {
+    const std::string patch_type_str(
+        cmd_line.GetSwitchValueASCII(installer::switches::kPatch));
+    const base::FilePath input_file(
+        cmd_line.GetSwitchValuePath(installer::switches::kInputFile));
+    const base::FilePath patch_file(
+        cmd_line.GetSwitchValuePath(installer::switches::kPatchFile));
+    const base::FilePath output_file(
+        cmd_line.GetSwitchValuePath(installer::switches::kOutputFile));
+
+    if (patch_type_str == installer::kCourgette) {
+      *exit_code = installer::CourgettePatchFiles(input_file,
+                                                  patch_file,
+                                                  output_file);
+    } else if (patch_type_str == installer::kBsdiff) {
+      *exit_code = installer::BsdiffPatchFiles(input_file,
+                                               patch_file,
+                                               output_file);
+    } else {
+      *exit_code = installer::PATCH_INVALID_ARGUMENTS;
+    }
   } else {
     handled = false;
   }
 
   return handled;
 }
 
 bool ShowRebootDialog() {
   // Get a token for this process.
   HANDLE token;
@@ skipping 242 matching lines @@
   if (!(installer_state.is_msi() && is_uninstall))
     // Note that we allow the status installer::UNINSTALL_REQUIRES_REBOOT
     // to pass through, since this is only returned on uninstall which is
     // never invoked directly by Google Update.
     return_code = InstallUtil::GetInstallReturnCode(install_status);
 
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }