Include the Chrome Frame binary in Chrome installers. Note that it will only ...

chrome/installer/setup/setup_main.cc

 // Copyright (c) 2009 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 <string>
 #include <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
@@ skipping 46 matching lines @@
                     const std::wstring& temp_path, const std::wstring& path,
                     bool& incremental_install) {
   // First uncompress the payload. This could be a differential
   // update (patch.7z) or full archive (chrome.7z). If this uncompress fails
   // return with error.
   std::wstring unpacked_file;
   int32 ret = LzmaUtil::UnPackArchive(archive, temp_path, &unpacked_file);
   if (ret != NO_ERROR)
     return ret;
 
-  std::wstring archive_name;
-  if (InstallUtil::IsChromeFrameProcess()) {
-    archive_name = installer::kChromeFrameArchive;
-  } else {
-    archive_name = installer::kChromeArchive;
-  }
-
   std::wstring uncompressed_archive(temp_path);
-  file_util::AppendToPath(&uncompressed_archive, archive_name);
+  file_util::AppendToPath(&uncompressed_archive, installer::kChromeArchive);
 
   // Check if this is differential update and if it is, patch it to the
   // installer archive that should already be on the machine. We assume
   // it is a differential installer if chrome.7z is not found.
   if (!file_util::PathExists(FilePath::FromWStringHack(uncompressed_archive))) {
     incremental_install = true;
     LOG(INFO) << "Differential patch found. Applying to existing archive.";
     if (!installed_version) {
       LOG(ERROR) << "Can not use differential update when Chrome is not "
                  << "installed on the system.";
       return installer_util::CHROME_NOT_INSTALLED;
     }
     std::wstring existing_archive =
         installer::GetChromeInstallPath(system_install);
     file_util::AppendToPath(&existing_archive,
                             installed_version->GetString());
     file_util::AppendToPath(&existing_archive, installer_util::kInstallerDir);
-    file_util::AppendToPath(&existing_archive, archive_name);
+    file_util::AppendToPath(&existing_archive, installer::kChromeArchive);
     if (int i = setup_util::ApplyDiffPatch(existing_archive, unpacked_file,
                                            uncompressed_archive)) {
       LOG(ERROR) << "Binary patching failed with error " << i;
       return i;
     }
   }
 
   // Unpack the uncompressed archive.
   return LzmaUtil::UnPackArchive(uncompressed_archive, path, &unpacked_file);
 }
@@ skipping 121 matching lines @@
   installer_util::GetDistroBooleanPreference(prefs,
       installer_util::master_preferences::kSystemLevel, &system_level);
   installer_util::InstallStatus install_status = installer_util::UNKNOWN_STATUS;
   if (!CheckPreInstallConditions(installed_version,
                                  system_level, install_status))
     return install_status;
 
   // For install the default location for chrome.packed.7z is in current
   // folder, so get that value first.
   std::wstring archive = file_util::GetDirectoryFromPath(cmd_line.program());
-  if (InstallUtil::IsChromeFrameProcess()) {
-    file_util::AppendToPath(&archive,
-        std::wstring(installer::kChromeFrameCompressedArchive));
-  } else {
-    file_util::AppendToPath(&archive,
-                            std::wstring(installer::kChromeCompressedArchive));
-  }
+  file_util::AppendToPath(&archive,
+                          std::wstring(installer::kChromeCompressedArchive));
+
   // If --install-archive is given, get the user specified value
   if (cmd_line.HasSwitch(installer_util::switches::kInstallArchive)) {
     archive = cmd_line.GetSwitchValue(
         installer_util::switches::kInstallArchive);
   }
   LOG(INFO) << "Archive found to install Chrome " << archive;
 
   // Create a temp folder where we will unpack Chrome archive. If it fails,
   // then we are doomed, so return immediately and no cleanup is required.
   FilePath temp_path;
@@ skipping 37 matching lines @@
           installed_version->IsHigherThan(installer_version.get())) {
         LOG(ERROR) << "Higher version is already installed.";
         install_status = installer_util::HIGHER_VERSION_EXISTS;
         InstallUtil::WriteInstallerResult(system_level, install_status,
                                           IDS_INSTALL_HIGHER_VERSION_BASE,
                                           NULL);
       } else {
         // We want to keep uncompressed archive (chrome.7z) that we get after
         // uncompressing and binary patching. Get the location for this file.
         std::wstring archive_to_copy(temp_path.ToWStringHack());
-        std::wstring archive_name;
-        if (InstallUtil::IsChromeFrameProcess()) {
-          archive_name = installer::kChromeFrameArchive;
-        } else {
-          archive_name = installer::kChromeArchive;
-        }
-        file_util::AppendToPath(&archive_to_copy, archive_name);
+        file_util::AppendToPath(&archive_to_copy, installer::kChromeArchive);
         std::wstring prefs_source_path = cmd_line.GetSwitchValue(
             installer_util::switches::kInstallerData);
         install_status = installer::InstallOrUpdateChrome(
             cmd_line.program(), archive_to_copy, temp_path.ToWStringHack(),
             prefs_source_path, prefs, *installer_version, installed_version);
 
         int install_msg_base = IDS_INSTALL_FAILED_BASE;
         std::wstring chrome_exe;
         if (install_status == installer_util::SAME_VERSION_REPAIR_FAILED) {
             install_msg_base = IDS_SAME_VERSION_REPAIR_FAILED_BASE;
@@ skipping 293 matching lines @@
   bool initialized_;
 };
 
 }  // namespace
 
 int WINAPI wWinMain(HINSTANCE instance, HINSTANCE prev_instance,
                     wchar_t* command_line, int show_command) {
   // The exit manager is in charge of calling the dtors of singletons.
   base::AtExitManager exit_manager;
   CommandLine::Init(0, NULL);
+  CommandLine* mutable_command_line = CommandLine::ForCurrentProcess();
+
+  if (mutable_command_line->HasSwitch(installer_util::switches::kChromeFrame)) {
+    mutable_command_line->AppendSwitch(
+        WideToASCII(installer_util::switches::kDoNotCreateShortcuts));
+    mutable_command_line->AppendSwitch(
+        WideToASCII(installer_util::switches::kDoNotLaunchChrome));
+    mutable_command_line->AppendSwitch(
+        WideToASCII(installer_util::switches::kDoNotRegisterForUpdateLaunch));
+  }
+
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
+
   installer::InitInstallerLogging(parsed_command_line);
   scoped_ptr<DictionaryValue> prefs(installer_util::GetInstallPreferences(
       parsed_command_line));
   bool value = false;
   if (installer_util::GetDistroBooleanPreference(prefs.get(),
           installer_util::master_preferences::kVerboseLogging, &value) &&
       value)
     logging::SetMinLogLevel(logging::LOG_INFO);
 
   LOG(INFO) << "Command Line: " << parsed_command_line.command_line_string();
@@ skipping 111 matching lines @@
         parsed_command_line.HasSwitch(installer_util::switches::kUninstall))) {
     // Note that we allow the status installer_util::UNINSTALL_REQUIRES_REBOOT
     // to pass through, since this is only returned on uninstall which is never
     // invoked directly by Google Update.
     return_code = dist->GetInstallReturnCode(install_status);
   }
 
   LOG(INFO) << "Installation complete, returning: " << return_code;
   return return_code;
 }