Add histograms to the rendez-vous process (ProcessSingleton).

chrome/browser/process_singleton_posix.cc

 // Copyright 2014 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.
 
 // On Linux, when the user tries to launch a second copy of chrome, we check
 // for a socket in the user's profile directory.  If the socket file is open we
 // send a message to the first chrome browser process with the current
 // directory and second process command line flags.  The second process then
 // exits.
 //
@@ skipping 46 matching lines @@
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/safe_strerror.h"
 #include "base/rand_util.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "base/single_thread_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 811 matching lines @@
   return NotifyOtherProcessWithTimeoutOrCreate(
       *base::CommandLine::ForCurrentProcess(), kRetryAttempts,
       base::TimeDelta::FromSeconds(kTimeoutInSeconds));
 }
 
 ProcessSingleton::NotifyResult
 ProcessSingleton::NotifyOtherProcessWithTimeoutOrCreate(
     const base::CommandLine& command_line,
     int retry_attempts,
     const base::TimeDelta& timeout) {
+  const base::TimeTicks begin_ticks = base::TimeTicks::Now();
   NotifyResult result = NotifyOtherProcessWithTimeout(
       command_line, retry_attempts, timeout, true);
-  if (result != PROCESS_NONE)
+  if (result != PROCESS_NONE) {
+    if (result == PROCESS_NOTIFIED) {
+      UMA_HISTOGRAM_MEDIUM_TIMES("Chrome.ProcessSingleton.TimeToNotify",
+                                 base::TimeTicks::Now() - begin_ticks);
+    } else {
+      UMA_HISTOGRAM_MEDIUM_TIMES("Chrome.ProcessSingleton.TimeToFailure",
+                                 base::TimeTicks::Now() - begin_ticks);
+    }
     return result;
-  if (Create())
+  }
+
+  if (Create()) {
+    UMA_HISTOGRAM_MEDIUM_TIMES("Chrome.ProcessSingleton.TimeToCreate",
+                               base::TimeTicks::Now() - begin_ticks);
     return PROCESS_NONE;
+  }
+
   // If the Create() failed, try again to notify. (It could be that another
   // instance was starting at the same time and managed to grab the lock before
   // we did.)
   // This time, we don't want to kill anything if we aren't successful, since we
   // aren't going to try to take over the lock ourselves.
   result = NotifyOtherProcessWithTimeout(
       command_line, retry_attempts, timeout, false);
+
+  if (result == PROCESS_NOTIFIED) {
+    UMA_HISTOGRAM_MEDIUM_TIMES("Chrome.ProcessSingleton.TimeToNotify",

[sky, 2016/10/07 19:47:30]

Are you sure you don't want to differentiate these two vs 903-909? They are
slightly different.

[gab, 2016/10/07 20:05:46]

Well it's still the time it took to achieve a result. The fact that it took
longer because it was conflating with another Chrome is exactly the kind of
thing that we're trying to measure for both 903 and 909.

+                               base::TimeTicks::Now() - begin_ticks);
+  } else {
+    UMA_HISTOGRAM_MEDIUM_TIMES("Chrome.ProcessSingleton.TimeToFailure",
+                               base::TimeTicks::Now() - begin_ticks);
+  }
+
   if (result != PROCESS_NONE)
     return result;
 
   return LOCK_ERROR;
 }
 
 void ProcessSingleton::OverrideCurrentPidForTesting(base::ProcessId pid) {
   current_pid_ = pid;
 }
 
@@ skipping 134 matching lines @@
 }
 
 void ProcessSingleton::KillProcess(int pid) {
   // TODO(james.su@gmail.com): Is SIGKILL ok?
   int rv = kill(static_cast<base::ProcessHandle>(pid), SIGKILL);
   // ESRCH = No Such Process (can happen if the other process is already in
   // progress of shutting down and finishes before we try to kill it).
   DCHECK(rv == 0 || errno == ESRCH) << "Error killing process: "
                                     << base::safe_strerror(errno);
 }