Report text output and exit code for command-line operations.

chrome/browser/ui/startup/startup_browser_creator.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/ui/startup/startup_browser_creator.h"
 
 #include <algorithm>   // For max().
 #include <set>
 
 #include "base/bind.h"
@@ skipping 18 matching lines @@
 #include "chrome/browser/automation/automation_provider_list.h"
 #include "chrome/browser/automation/testing_automation_provider.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/extensions/startup_helper.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
+#include "chrome/browser/operation_output.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
 #include "chrome/browser/printing/print_dialog_cloud.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
@@ skipping 184 matching lines @@
 // static
 bool StartupBrowserCreator::was_restarted_read_ = false;
 
 // static
 bool StartupBrowserCreator::in_synchronous_profile_launch_ = false;
 
 void StartupBrowserCreator::AddFirstRunTab(const GURL& url) {
   first_run_tabs_.push_back(url);
 }
 
+bool StartupBrowserCreator::Start(
+    const CommandLine& cmd_line,
+    const base::FilePath& cur_dir,
+    Profile* last_used_profile,
+    const Profiles& last_opened_profiles,
+    scoped_ptr<OperationOutput> operation_output)  {
+  return ProcessCmdLineImpl(cmd_line, cur_dir, true, last_used_profile,
+                            last_opened_profiles, this,
+                            operation_output.Pass());
+}
+
 // static
 bool StartupBrowserCreator::InSynchronousProfileLaunch() {
   return in_synchronous_profile_launch_;
 }
 
 bool StartupBrowserCreator::LaunchBrowser(
     const CommandLine& command_line,
     Profile* profile,
     const base::FilePath& cur_dir,
     chrome::startup::IsProcessStartup process_startup,
@@ skipping 170 matching lines @@
   return urls;
 }
 
 // static
 bool StartupBrowserCreator::ProcessCmdLineImpl(
     const CommandLine& command_line,
     const base::FilePath& cur_dir,
     bool process_startup,
     Profile* last_used_profile,
     const Profiles& last_opened_profiles,
-    int* return_code,
-    StartupBrowserCreator* browser_creator) {
+    StartupBrowserCreator* browser_creator,
+    scoped_ptr<OperationOutput> operation_output) {
   DCHECK(last_used_profile);
   if (process_startup) {
     if (command_line.HasSwitch(switches::kDisablePromptOnRepost))
       content::NavigationController::DisablePromptOnRepost();
   }
 
+  // TODO(erikwright): Remove before committing.
+  if (command_line.HasSwitch("greetings")) {
+    if (operation_output) {
+      std::string hello_world("hello world!");
+      operation_output->Write(hello_world.c_str(), hello_world.length());
+      OperationOutput::Complete(operation_output.Pass(), 42);
+    }
+
+    return false;
+  }
+
   bool silent_launch = false;
 
 #if defined(ENABLE_AUTOMATION)
   // Look for the testing channel ID ONLY during process startup
   if (process_startup &&
       command_line.HasSwitch(switches::kTestingChannelID)) {
     std::string testing_channel_id = command_line.GetSwitchValueASCII(
         switches::kTestingChannelID);
     // TODO(sanjeevr) Check if we need to make this a singleton for
     // compatibility with the old testing code
@@ skipping 169 matching lines @@
       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
   // |last_opened_profiles| will be empty in the following circumstances:
   // - This is the first launch. |last_used_profile| is the initial profile.
   // - The user exited the browser by closing all windows for all
   // profiles. |last_used_profile| is the profile which owned the last open
   // window.
   // - Only incognito windows were open when the browser exited.
   // |last_used_profile| is the last used incognito profile. Restoring it will
   // create a browser window for the corresponding original profile.
   if (last_opened_profiles.empty()) {
+    int return_code = 0;
     if (!browser_creator->LaunchBrowser(command_line, last_used_profile,
                                         cur_dir, is_process_startup,
-                                        is_first_run, return_code)) {
+                                        is_first_run, &return_code)) {
+      if (operation_output)
+        OperationOutput::Complete(operation_output.Pass(), return_code);
       return false;
     }
   } else {
     // Launch the last used profile with the full command line, and the other
     // opened profiles without the URLs to launch.
     CommandLine command_line_without_urls(command_line.GetProgram());
     const CommandLine::SwitchMap& switches = command_line.GetSwitches();
     for (CommandLine::SwitchMap::const_iterator switch_it = switches.begin();
          switch_it != switches.end(); ++switch_it) {
       command_line_without_urls.AppendSwitchNative(switch_it->first,
                                                    switch_it->second);
     }
     // Launch the profiles in the order they became active.
     for (Profiles::const_iterator it = last_opened_profiles.begin();
          it != last_opened_profiles.end(); ++it) {
       // Don't launch additional profiles which would only open a new tab
       // page. When restarting after an update, all profiles will reopen last
       // open pages.
       SessionStartupPref startup_pref =
           GetSessionStartupPref(command_line, *it);
       if (*it != last_used_profile &&
           startup_pref.type == SessionStartupPref::DEFAULT &&
           !HasPendingUncleanExit(*it))
         continue;
+      int return_code = 0;
       if (!browser_creator->LaunchBrowser((*it == last_used_profile) ?
           command_line : command_line_without_urls, *it, cur_dir,
-          is_process_startup, is_first_run, return_code))
+          is_process_startup, is_first_run, &return_code)) {
+        if (operation_output)
+          OperationOutput::Complete(operation_output.Pass(), return_code);
         return false;
+      }
       // We've launched at least one browser.
       is_process_startup = chrome::startup::IS_NOT_PROCESS_STARTUP;
     }
     // This must be done after all profiles have been launched so the observer
     // knows about all profiles to wait for before activating this one.
     profile_launch_observer.Get().set_profile_to_activate(last_used_profile);
   }
+  if (operation_output) {
+    OperationOutput::Complete(operation_output.Pass(),
+                              content::RESULT_CODE_NORMAL_EXIT);
+  }
   return true;
 }
 
 template <class AutomationProviderClass>
 bool StartupBrowserCreator::CreateAutomationProvider(
     const std::string& channel_id,
     Profile* profile,
     size_t expected_tabs) {
 #if defined(ENABLE_AUTOMATION)
   scoped_refptr<AutomationProviderClass> automation =
       new AutomationProviderClass(profile);
   if (!automation->InitializeChannel(channel_id))
     return false;
   automation->SetExpectedTabCount(expected_tabs);
 
   AutomationProviderList* list = g_browser_process->GetAutomationProviderList();
   DCHECK(list);
   list->AddProvider(automation);
 #endif  // defined(ENABLE_AUTOMATION)
 
   return true;
 }
 
 // static
 void StartupBrowserCreator::ProcessCommandLineOnProfileCreated(
     const CommandLine& command_line,
     const base::FilePath& cur_dir,
+    scoped_ptr<OperationOutput> operation_output,
     Profile* profile,
     Profile::CreateStatus status) {
-  if (status == Profile::CREATE_STATUS_INITIALIZED)
+  if (status == Profile::CREATE_STATUS_INITIALIZED) {
     ProcessCmdLineImpl(command_line, cur_dir, false, profile, Profiles(), NULL,
-                       NULL);
+                       operation_output.Pass());
+  } else {
+    // Signal failure on operation_output?
+  }
 }
 
 // static
 void StartupBrowserCreator::ProcessCommandLineAlreadyRunning(
     const CommandLine& command_line,
     const base::FilePath& cur_dir,
-    const base::FilePath& profile_path) {
+    const base::FilePath& profile_path,
+    scoped_ptr<OperationOutput> operation_output) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   Profile* profile = profile_manager->GetProfileByPath(profile_path);
 
   // The profile isn't loaded yet and so needs to be loaded asynchronously.
   if (!profile) {
-    profile_manager->CreateProfileAsync(profile_path,
-        base::Bind(&StartupBrowserCreator::ProcessCommandLineOnProfileCreated,
-                   command_line, cur_dir), string16(), string16(), false);
+    profile_manager->CreateProfileAsync(
+        profile_path,
+        base::Bind(
+            &StartupBrowserCreator::ProcessCommandLineOnProfileCreated,
+            command_line, cur_dir, base::Passed(operation_output.Pass())),
+        string16(), string16(), false);
     return;
   }
 
   ProcessCmdLineImpl(command_line, cur_dir, false, profile, Profiles(), NULL,
-                     NULL);
+                     operation_output.Pass());
 }
 
 // static
 bool StartupBrowserCreator::ActivatedProfile() {
   return profile_launch_observer.Get().activated_profile();
 }
 
 bool HasPendingUncleanExit(Profile* profile) {
   return profile->GetLastSessionExitType() == Profile::EXIT_CRASHED &&
       !profile_launch_observer.Get().HasBeenLaunched(profile);
 }