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

chrome/browser/process_singleton_lock.cc

 // 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 ProcessSingleton::NotificationCallback& original_callback)
+    const OperationCallback& operation_callback)
     : locked_(true),
-      original_callback_(original_callback) {}
+      operation_callback_(operation_callback) {}
 
-ProcessSingletonLock::~ProcessSingletonLock() {}
+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<DelayedStartupMessage> replayed_messages;
+  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) {
-    if (replayed_messages.find(*it) !=
-        replayed_messages.end())
+    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;
-    original_callback_.Run(CommandLine(it->first), it->second);
-    replayed_messages.insert(*it);
+    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).

-        std::make_pair(command_line.argv(), current_directory));
+        DelayedStartupMessage(command_line.argv(),
+                              current_directory,
+                              operation_output.release()));
     return true;
   } else {
-    return original_callback_.Run(command_line, current_directory);
+    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() { }