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

chrome/browser/chrome_browser_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 "chrome/browser/chrome_browser_main.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #endif
 
+#include <limits.h>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
+#include "base/memory/ref_counted.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/prefs/json_pref_store.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/pref_value_store.h"
 #include "base/process_info.h"
 #include "base/process_util.h"
 #include "base/run_loop.h"
@@ skipping 34 matching lines @@
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/metrics/thread_watcher.h"
 #include "chrome/browser/metrics/tracking_synchronizer.h"
 #include "chrome/browser/metrics/variations/variations_service.h"
 #include "chrome/browser/nacl_host/nacl_process_host.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/crl_set_fetcher.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
+#include "chrome/browser/operation_output.h"
 #include "chrome/browser/page_cycler/page_cycler.h"
 #include "chrome/browser/performance_monitor/performance_monitor.h"
 #include "chrome/browser/performance_monitor/startup_timer.h"
 #include "chrome/browser/plugins/plugin_prefs.h"
 #include "chrome/browser/policy/policy_service.h"
 #include "chrome/browser/prefs/chrome_pref_service_factory.h"
 #include "chrome/browser/prefs/command_line_pref_store.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
@@ skipping 324 matching lines @@
   if (!command_line.HasSwitch(switches::kDisableCRLSets))
     g_browser_process->crl_set_fetcher()->StartInitialLoad(cus);
 #endif
 
   g_browser_process->pnacl_component_installer()->RegisterPnaclComponent(
       cus, command_line);
 
   cus->Start();
 }
 
-bool ProcessSingletonNotificationCallback(
+bool ProcessSingletonOperationCallback(
     const CommandLine& command_line,
-    const base::FilePath& current_directory) {
+    const base::FilePath& current_directory,
+    scoped_ptr<OperationOutput> operation_output) {
   // Drop the request if the browser process is already in shutdown path.
   if (!g_browser_process || g_browser_process->IsShuttingDown())
     return false;
 
   g_browser_process->PlatformSpecificCommandLineProcessing(command_line);
 
   // TODO(erikwright): Consider removing this - AFAIK it is no longer used.
   // Handle the --uninstall-extension startup action. This needs to done here in
   // the process that is running with the target profile, otherwise the
   // uninstall will fail to unload and remove all components.
@@ skipping 13 matching lines @@
     extension_startup_helper.UninstallExtension(command_line, profile);
     return true;
   }
 
   base::FilePath user_data_dir =
       g_browser_process->profile_manager()->user_data_dir();
   base::FilePath startup_profile_dir =
       GetStartupProfilePath(user_data_dir, command_line);
 
   StartupBrowserCreator::ProcessCommandLineAlreadyRunning(
-      command_line, current_directory, startup_profile_dir);
+      command_line,
+      current_directory,
+      startup_profile_dir,
+      operation_output.Pass());
   return true;
 }
 
 void LaunchDevToolsHandlerIfNeeded(Profile* profile,
                                    const CommandLine& command_line) {
   if (command_line.HasSwitch(::switches::kRemoteDebuggingPort)) {
     std::string port_str =
         command_line.GetSwitchValueASCII(::switches::kRemoteDebuggingPort);
     int port;
     if (base::StringToInt(port_str, &port) && port > 0 && port < 65535) {
@@ skipping 277 matching lines @@
   run_message_loop_ = false;
   user_data_dir_ = chrome::GetUserDataDir(parameters());
 
   // Whether this is First Run. |do_first_run_tasks_| should be prefered to this
   // unless the desire is actually to know whether this is really First Run
   // (i.e., even if --no-first-run is passed).
   bool is_first_run = false;
   // Android's first run is done in Java instead of native.
 #if !defined(OS_ANDROID)
   process_singleton_.reset(new ChromeProcessSingleton(
-      user_data_dir_, base::Bind(&ProcessSingletonNotificationCallback)));
+      user_data_dir_, base::Bind(&ProcessSingletonOperationCallback)));
 
   bool force_first_run =
       parsed_command_line().HasSwitch(switches::kForceFirstRun);
   bool force_skip_first_run_tasks =
       (!force_first_run &&
        parsed_command_line().HasSwitch(switches::kNoFirstRun));
 
   is_first_run =
       (force_first_run || first_run::IsChromeFirstRun()) &&
       !ProfileManager::IsImportProcess(parsed_command_line());
@@ skipping 233 matching lines @@
 #endif
 
   for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
     chrome_extra_parts_[i]->PostBrowserStart();
 #if !defined(OS_ANDROID)
   // Allow ProcessSingleton to process messages.
   process_singleton_->Unlock();
 #endif
 }
 
+class CaptureOperationOutput {
+ public:
+  CaptureOperationOutput()
+      : exit_code_(new base::RefCountedData<int>(INT_MAX)) {}
+
+  int exit_code() { return exit_code_->data; }
+
+  scoped_ptr<OperationOutput> Wrap(scoped_ptr<OperationOutput> wrapped) {
+    return scoped_ptr<OperationOutput>(new Wrapper(wrapped.Pass(), exit_code_));
+  }
+
+ private:
+  class Wrapper : public OperationOutput {
+   public:
+    Wrapper(scoped_ptr<OperationOutput> wrapped,
+            const scoped_refptr<base::RefCountedData<int> >& exit_code)
+        : wrapped_(wrapped.Pass()),
+          exit_code_(exit_code) {
+    }
+
+    // OperationOutput implementation.
+    virtual bool Write(const char* data, unsigned int length) OVERRIDE {
+      if (wrapped_)
+        return wrapped_->Write(data, length);
+      return true;
+    }
+
+   private:
+    virtual bool SetExitCode(unsigned int exit_code) OVERRIDE {
+      bool success = true;
+      if (wrapped_)
+        success = OperationOutput::Complete(wrapped_.Pass(), exit_code);
+      if (success)
+        exit_code_->data = exit_code;
+      return success;
+    }
+    scoped_ptr<OperationOutput> wrapped_;
+    scoped_refptr<base::RefCountedData<int> > exit_code_;
+
+    DISALLOW_COPY_AND_ASSIGN(Wrapper);
+  };
+
+  scoped_refptr<base::RefCountedData<int> > exit_code_;
+
+  DISALLOW_COPY_AND_ASSIGN(CaptureOperationOutput);
+};
+
 #if !defined(OS_ANDROID)
 void ChromeBrowserMainParts::RunPageCycler() {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   // We assume a native desktop for tests, but we will need to find a way to
   // get the proper host desktop type once we start running these tests in ASH.
   Browser* browser = chrome::FindBrowserWithProfile(
       profile_, chrome::HOST_DESKTOP_TYPE_NATIVE);
   DCHECK(browser);
   PageCycler* page_cycler = NULL;
   base::FilePath input_file =
@@ skipping 430 matching lines @@
 #endif
 
   PreBrowserStart();
 
   // Instantiate the notification UI manager, as this triggers a perf timer
   // used to measure startup time. TODO(stevenjb): Figure out what is actually
   // triggering the timer and call that explicitly in the approprate place.
   // http://crbug.com/105065.
   browser_process_->notification_ui_manager();
 
+  CaptureOperationOutput capture_output;
+
 #if !defined(OS_ANDROID)
   // Most general initialization is behind us, but opening a
   // tab and/or session restore and such is still to be done.
   base::TimeTicks browser_open_start = base::TimeTicks::Now();
 
   // We are in regular browser boot sequence. Open initial tabs and enter the
   // main message loop.
-  int result_code;
+
 #if defined(OS_CHROMEOS)
   // On ChromeOS multiple profiles doesn't apply, and will break if we load
   // them this early as the cryptohome hasn't yet been mounted (which happens
   // only once we log in.
   std::vector<Profile*> last_opened_profiles;
 #else
   std::vector<Profile*> last_opened_profiles =
       g_browser_process->profile_manager()->GetLastOpenedProfiles();
 #endif
 
   if (!parsed_command_line().HasSwitch(switches::kDisableComponentUpdate))
     RegisterComponentsForUpdate(parsed_command_line());
 
-  if (browser_creator_->Start(parsed_command_line(), base::FilePath(),
-                              profile_, last_opened_profiles, &result_code)) {
+  if (browser_creator_->Start(
+          parsed_command_line(), base::FilePath(),
+          profile_, last_opened_profiles,
+          capture_output.Wrap(
+              OperationOutput::Create(parsed_command_line())))) {
 #if defined(OS_WIN) || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
     // Initialize autoupdate timer. Timer callback costs basically nothing
     // when browser is not in persistent mode, so it's OK to let it ride on
     // the main thread. This needs to be done here because we don't want
     // to start the timer when Chrome is run inside a test harness.
     browser_process_->StartAutoupdateTimer();
 #endif
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
     // On Linux, the running exe will be updated if an upgrade becomes
@@ skipping 53 matching lines @@
   if (parameters().ui_task) {
     // We end the startup timer here if we have parameters to run, because we
     // never start to run the main loop (where we normally stop the timer).
     startup_timer_->SignalStartupComplete(
         performance_monitor::StartupTimer::STARTUP_TEST);
     parameters().ui_task->Run();
     delete parameters().ui_task;
     run_message_loop_ = false;
   }
 
-  return result_code_;
+  return capture_output.exit_code();
 }
 
 bool ChromeBrowserMainParts::MainMessageLoopRun(int* result_code) {
 #if defined(OS_ANDROID)
   // Chrome on Android does not use default MessageLoop. It has its own
   // Android specific MessageLoop
   NOTREACHED();
   return true;
 #else
   // Set the result code set in PreMainMessageLoopRun or set above.
@@ skipping 169 matching lines @@
     if (base::win::GetVersion() <= base::win::VERSION_XP)
       uma_name += "_XP";
 
     uma_name += "_PreRead_";
     uma_name += pre_read_percentage;
     AddPreReadHistogramTime(uma_name.c_str(), time);
   }
 #endif
 #endif
 }