Install from disk image: eject original disk image volume and trash disk image file

chrome/browser/mac/relauncher.cc

 // Copyright (c) 2011 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/mac/relauncher.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <AvailabilityMacros.h>
 #include <dlfcn.h>
 #include <string.h>
 #include <sys/event.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/stringprintf.h"
 #include "base/sys_string_conversions.h"
+#include "chrome/browser/mac/install_from_dmg.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/common/content_paths.h"
 #include "content/common/content_switches.h"
 #include "content/common/main_function_params.h"
 
 // RTLD_MAIN_ONLY is supported as of Mac OS X 10.5, but <dlfcn.h> does not
 // define it in the 10.5 SDK. It is present in the 10.6 SDK and is documented
 // as working on 10.5 and later. The source code for the version of dyld that
 // shipped in 10.5, dyld-95.3/src/dyldAPIs.cpp, confirms that this feature is
 // supported. Provide a fallback definition here.
 #if MAC_OS_X_VERSION_MAX_ALLOWED == MAC_OS_X_VERSION_10_5  // 10.5 SDK
 #define RTLD_MAIN_ONLY ((void*)-5)  // Search main executable only.
 #endif
 
 namespace mac_relauncher {
 
+const char* const kRelauncherDMGDeviceArg = "--dmg-device=";
+
 namespace {
 
 // The "magic" file descriptor that the relauncher process' write side of the
 // pipe shows up on. Chosen to avoid conflicting with stdin, stdout, and
 // stderr.
 const int kRelauncherSyncFD = STDERR_FILENO + 1;
 
 // The argument separating arguments intended for the relauncher process from
 // those intended for the relaunched process. "---" is chosen instead of "--"
 // because CommandLine interprets "--" as meaning "end of switches", but
@@ skipping 29 matching lines @@
   // so this is safe even if the relaunch is the result of an update having
   // been applied. In fact, it's safer than using the updated version of the
   // helper process, because there's no guarantee that the updated version's
   // relauncher implementation will be compatible with the running version's.
   FilePath child_path;
   if (!PathService::Get(content::CHILD_PROCESS_EXE, &child_path)) {
     LOG(ERROR) << "No CHILD_PROCESS_EXE";
     return false;
   }
 
-  return RelaunchAppWithHelper(child_path.value(), args);
+  std::vector<std::string> relauncher_args;
+  return RelaunchAppWithHelper(child_path.value(), relauncher_args, args);
 }
 
 bool RelaunchAppWithHelper(const std::string& helper,
+                           const std::vector<std::string>& relauncher_args,
                            const std::vector<std::string>& args) {
   std::vector<std::string> relaunch_args;
   relaunch_args.push_back(helper);
   relaunch_args.push_back(RelauncherTypeArg());
 
   // If this application isn't in the foreground, the relaunched one shouldn't
   // be either.
   if (!base::mac::AmIForeground()) {
     relaunch_args.push_back(kRelauncherBackgroundArg);
   }
 
+  relaunch_args.insert(relaunch_args.end(),
+                       relauncher_args.begin(), relauncher_args.end());
+
   relaunch_args.push_back(kRelauncherArgSeparator);
 
   // When using the CommandLine interface, -psn_ may have been rewritten as
   // --psn_. Look for both.
   const char alt_psn_arg[] = "--psn_";
   for (size_t index = 0; index < args.size(); ++index) {
     // Strip any -psn_ arguments, as they apply to a specific process.
     if (args[index].compare(0, strlen(kPSNArg), kPSNArg) != 0 &&
         args[index].compare(0, strlen(alt_psn_arg), alt_psn_arg) != 0) {
       relaunch_args.push_back(args[index]);
@@ skipping 169 matching lines @@
       CFArrayCreateMutable(NULL, argc - 4, &kCFTypeArrayCallBacks));
   if (!relaunch_args) {
     LOG(ERROR) << "CFArrayCreateMutable";
     return 1;
   }
 
   // Figure out what to execute, what arguments to pass it, and whether to
   // start it in the background.
   bool background = false;
   bool in_relaunch_args = false;
+  std::string dmg_bsd_device_name;
   bool seen_relaunch_executable = false;
   std::string relaunch_executable;
   const std::string relauncher_arg_separator(kRelauncherArgSeparator);
   for (int argv_index = 2; argv_index < argc; ++argv_index) {
     const std::string arg(argv[argv_index]);
 
     // Strip any -psn_ arguments, as they apply to a specific process.
     if (arg.compare(0, strlen(kPSNArg), kPSNArg) == 0) {
       continue;
     }
 
     if (!in_relaunch_args) {
       if (arg == relauncher_arg_separator) {
         in_relaunch_args = true;
       } else if (arg == kRelauncherBackgroundArg) {
         background = true;
+      } else if (arg.compare(0, strlen(kRelauncherDMGDeviceArg),
+                             kRelauncherDMGDeviceArg) == 0) {
+        dmg_bsd_device_name.assign(arg.substr(strlen(kRelauncherDMGDeviceArg)));
       }
     } else {
       if (!seen_relaunch_executable) {
         // The first argument after kRelauncherBackgroundArg is the path to
         // the executable file or .app bundle directory. The Launch Services
         // interface wants this separate from the rest of the arguments. In
         // the relaunched process, this path will still be visible at argv[0].
         relaunch_executable.assign(arg);
         seen_relaunch_executable = true;
       } else {
@@ skipping 29 matching lines @@
     relaunch_args,
     NULL   // initialEvent
   };
 
   OSStatus err = LSOpenApplication(&ls_parameters, NULL);
   if (err != noErr) {
     LOG(ERROR) << "LSOpenApplication: " << err;
     return 1;
   }
 
+  // The application should have relaunched (or is in the process of
+  // relaunching). From this point on, only clean-up tasks should occur, and
+  // failures are tolerable.
+
+  if (!dmg_bsd_device_name.empty()) {
+    EjectAndTrashDiskImage(dmg_bsd_device_name);
+  }
+
   return 0;
 }
 
 }  // namespace internal
 
 }  // namespace mac_relauncher