Don't report exit funnels for live processes.

components/browser_watcher/watcher_metrics_provider_win.cc

 // Copyright (c) 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.
 
 #include "components/browser_watcher/watcher_metrics_provider_win.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/metrics/sparse_histogram.h"
@@ skipping 14 matching lines @@
   // done consistently.
   COMPILE_ASSERT(sizeof(DWORD) == sizeof(int),
                  process_ids_have_outgrown_an_int);
 }
 
 // This function does soft matching on the PID recorded in the key only.
 // Due to PID reuse, the possibility exists that the process that's now live
 // with the given PID is not the same process the data was recorded for.
 // This doesn't matter for the purpose, as eventually the data will be
 // scavenged and reported.
-bool IsDeadProcess(base::StringPiece16 key_name) {
+bool IsDeadProcess(base::StringPiece16 key_or_value_name) {
   // Truncate the input string to the first occurrence of '-', if one exists.
-  size_t num_end = key_name.find(L'-');
+  size_t num_end = key_or_value_name.find(L'-');
   if (num_end != base::StringPiece16::npos)
-    key_name = key_name.substr(0, num_end);
+    key_or_value_name = key_or_value_name.substr(0, num_end);
 
   // Convert to the numeric PID.
   int pid = 0;
-  if (!base::StringToInt(key_name, &pid) || pid == 0)
+  if (!base::StringToInt(key_or_value_name, &pid) || pid == 0)
     return true;
 
   // This is a very inexpensive check for the common case of our own PID.
   if (static_cast<base::ProcessId>(pid) == base::GetCurrentProcId())
     return false;
 
   // The process is not our own - see whether a process with this PID exists.
   // This is more expensive than the above check, but should also be very rare,
   // as this only happens more than once for a given PID if a user is running
   // multiple Chrome instances concurrently.
@@ skipping 133 matching lines @@
   base::win::RegKey key(HKEY_CURRENT_USER,
                         registry_path.c_str(),
                         KEY_QUERY_VALUE);
   if (!key.Valid()) {
     LOG(ERROR) << "Failed to open " << registry_path << " for writing.";
     return;
   }
 
   std::vector<base::string16> to_delete;
   for (; it.Valid(); ++it) {
-    RecordSingleExitFunnel(&key, it.Name());
-    to_delete.push_back(it.Name());
+    // Defer reporting on still-live processes.
+    if (IsDeadProcess(it.Name())) {
+      RecordSingleExitFunnel(&key, it.Name());
+      to_delete.push_back(it.Name());
+    }
   }
 
   for (size_t i = 0; i < to_delete.size(); ++i) {
     LONG res = key.DeleteEmptyKey(to_delete[i].c_str());
     if (res != ERROR_SUCCESS)
       LOG(ERROR) << "Failed to delete key " << to_delete[i];
   }
 }
 
 }  // namespace
@@ skipping 16 matching lines @@
   // user account, there's a small race that will double-report the exit codes
   // from both/multiple instances. This ought to be vanishingly rare and will
   // only manifest as low-level "random" noise. To work around this it would be
   // necessary to implement some form of global locking, which is not worth it
   // here.
   RecordExitCodes(registry_path_);
   RecordExitFunnels(registry_path_);
 }
 
 }  // namespace browser_watcher