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

chrome/browser/process_singleton_lock.cc

Index: chrome/browser/process_singleton_lock.cc
diff --git a/chrome/browser/process_singleton_lock.cc b/chrome/browser/process_singleton_lock.cc
index 69636b76f8b3cbf1457b43c25a0bdbeed09605a1..9c5e837680b103831565c983e6771429300edf34 100644
--- a/chrome/browser/process_singleton_lock.cc
+++ b/chrome/browser/process_singleton_lock.cc
@@ -1,54 +1,85 @@
-// Copyright (c) 2013 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/process_singleton_lock.h"
-
-#include "base/bind.h"
-#include "base/logging.h"
-
-ProcessSingletonLock::ProcessSingletonLock(
-    const ProcessSingleton::NotificationCallback& original_callback)
-    : locked_(true),
-      original_callback_(original_callback) {}
-
-ProcessSingletonLock::~ProcessSingletonLock() {}
-
-ProcessSingleton::NotificationCallback
-ProcessSingletonLock::AsNotificationCallback() {
-  return base::Bind(&ProcessSingletonLock::NotificationCallbackImpl,
-                    base::Unretained(this));
-}
-
-void ProcessSingletonLock::Unlock() {
-  DCHECK(CalledOnValidThread());
-  locked_ = false;
-
-  // Replay the command lines of the messages which were received while the
-  // ProcessSingleton was locked. Only replay each message once.
-  std::set<DelayedStartupMessage> replayed_messages;
-  for (std::vector<DelayedStartupMessage>::const_iterator it =
-           saved_startup_messages_.begin();
-       it != saved_startup_messages_.end(); ++it) {
-    if (replayed_messages.find(*it) !=
-        replayed_messages.end())
-      continue;
-    original_callback_.Run(CommandLine(it->first), it->second);
-    replayed_messages.insert(*it);
-  }
-  saved_startup_messages_.clear();
-}
-
-bool ProcessSingletonLock::NotificationCallbackImpl(
-    const CommandLine& command_line,
-    const base::FilePath& current_directory) {
-  if (locked_) {
-    // If locked, it means we are not ready to process this message because
-    // we are probably in a first run critical phase.
-    saved_startup_messages_.push_back(
-        std::make_pair(command_line.argv(), current_directory));
-    return true;
-  } else {
-    return original_callback_.Run(command_line, current_directory);
-  }
-}
+// Copyright (c) 2013 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/process_singleton_lock.h"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "chrome/browser/operation_output.h"
+
+ProcessSingletonLock::ProcessSingletonLock(
+    const OperationCallback& operation_callback)
+    : locked_(true),
+      operation_callback_(operation_callback) {}
+
+ProcessSingletonLock::~ProcessSingletonLock() {
+  for (std::vector<DelayedStartupMessage>::const_iterator it =
+           saved_startup_messages_.begin();
+       it != saved_startup_messages_.end(); ++it) {
+    if (it->operation_output_)
+      delete it->operation_output_;
+  }
+}
+
+ProcessSingleton::NotificationCallback
+ProcessSingletonLock::AsNotificationCallback() {
+  return base::Bind(&ProcessSingletonLock::NotificationCallbackImpl,
+                    base::Unretained(this));
+}
+
+void ProcessSingletonLock::Unlock() {
+  DCHECK(CalledOnValidThread());
+  locked_ = false;
+
+  // Replay the command lines of the messages which were received while the
+  // ProcessSingleton was locked. Only replay each message once.
+  std::set<std::pair<CommandLine::StringVector,
+                     base::FilePath> > replayed_messages;
+  for (std::vector<DelayedStartupMessage>::const_iterator it =
+           saved_startup_messages_.begin();
+       it != saved_startup_messages_.end(); ++it) {
+    scoped_ptr<OperationOutput> operation_output(it->operation_output_);
+    std::pair<CommandLine::StringVector, base::FilePath> pair(
+        it->argv_, it->current_directory_);
+    if (replayed_messages.find(pair) != replayed_messages.end())
+      continue;
+    operation_callback_.Run(CommandLine(it->argv_),
+                            it->current_directory_,
+                            operation_output.Pass());
+    replayed_messages.insert(pair);
+  }
+  saved_startup_messages_.clear();
+}
+
+bool ProcessSingletonLock::NotificationCallbackImpl(
+    const CommandLine& command_line,
+    const base::FilePath& current_directory) {
+  scoped_ptr<OperationOutput> operation_output =
+      OperationOutput::Create(command_line);
+
+  if (locked_) {
+    // If locked, it means we are not ready to process this message because
+    // we are probably in a first run critical phase.
+    saved_startup_messages_.push_back(

[robertshield, 2013/03/28 14:31:48]

minor nit: since these are only going to be played back once each, consider
deduping at insertion time, rather than when replaying the list.

[gab, 2013/03/28 14:52:41]

I thought about this too, the theory being that insert would be O(n) and replay
O(n) as well instead of O(1) and O(n^2) as it is now, but I don't think it has
any benefits in practice (i.e. the choice is basically between deduping against
the full_list here or against the replayed_list on replay; seems to me that the
size of replayed_list is always <= the size of the full_list for any given item;
making dedupping at replay time more efficient (or equal) in terms of overall
cost (inserts+replay).

At least these were my thoughts on patch 2/3 and I don't think things have
changed here (haven't fully grokked this CL yet).

+        DelayedStartupMessage(command_line.argv(),
+                              current_directory,
+                              operation_output.release()));
+    return true;
+  } else {
+    return operation_callback_.Run(command_line,
+                                   current_directory,
+                                   operation_output.Pass());
+  }
+}
+
+ProcessSingletonLock::DelayedStartupMessage::DelayedStartupMessage(
+    const CommandLine::StringVector& argv,
+    const base::FilePath& current_directory,
+    OperationOutput* operation_output)
+    : argv_(argv),
+      current_directory_(current_directory),
+      operation_output_(operation_output) {
+}
+
+ProcessSingletonLock::DelayedStartupMessage::~DelayedStartupMessage() { }