Add UMA reports for Linux nacl_helper startup status

content/browser/zygote_host_linux.cc

 // Copyright (c) 2011 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 "content/browser/zygote_host_linux.h"
 
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/linux_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/pickle.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/renderer_host/render_sandbox_host_linux.h"
 #include "content/common/process_watcher.h"
 #include "content/common/result_codes.h"
@@ skipping 230 matching lines @@
     fds.push_back(i->second);
   }
 
   pid_t pid;
   {
     base::AutoLock lock(control_lock_);
     if (!UnixDomainSocket::SendMsg(control_fd_, pickle.data(), pickle.size(),
                                    fds))
       return base::kNullProcessHandle;
 
-    if (ReadReply(&pid, sizeof(pid)) != sizeof(pid))
+    // Read the reply, which pickles the PID and an optional UMA enumeration.
+    static const unsigned kMaxReplyLength = 2048;
+    char buf[kMaxReplyLength];
+    const ssize_t len = ReadReply(buf, sizeof(buf));
+
+    Pickle reply_pickle(buf, len);
+    void *iter = NULL;
+    if (len <= 0 || !reply_pickle.ReadInt(&iter, &pid))
       return base::kNullProcessHandle;
+
+    // If there is a nonempty UMA name string, then there is a UMA
+    // enumeration to record.
+    std::string uma_name;
+    int uma_sample;
+    int uma_boundary_value;
+    if (reply_pickle.ReadString(&iter, &uma_name) &&
+        !uma_name.empty() &&
+        reply_pickle.ReadInt(&iter, &uma_sample) &&
+        reply_pickle.ReadInt(&iter, &uma_boundary_value)) {
+      // We cannot use the UMA_HISTOGRAM_ENUMERATION macro here,
+      // because that's only for when the name is the same every time.
+      // Here we're using whatever name we got from the other side.
+      // But since it's likely that the same one will be used repeatedly
+      // (even though it's not guaranteed), we cache it here.
+      static base::Histogram* uma_histogram;
+      if (!uma_histogram || uma_histogram->histogram_name() != uma_name)

[brettw, 2011/10/20 06:07:09]

Use {} for multi-line (even if it's just one stmt).

+        uma_histogram = base::LinearHistogram::FactoryGet(
+            uma_name, 1,
+            uma_boundary_value,
+            uma_boundary_value + 1, base::Histogram::kUmaTargetedHistogramFlag);
+      uma_histogram->Add(uma_sample);
+    }
+
     if (pid <= 0)
       return base::kNullProcessHandle;
   }
 
   // This is just a starting score for a renderer or extension (the
   // only types of processes that will be started this way).  It will
   // get adjusted as time goes on.  (This is the same value as
   // chrome::kLowestRendererOomScore in chrome/chrome_constants.h, but
   // that's not something we can include here.)
   const int kLowestRendererOomScore = 300;
@@ skipping 118 matching lines @@
       !read_pickle.ReadInt(&iter, &tmp_exit_code)) {
     LOG(WARNING) << "Error parsing GetTerminationStatus response from zygote.";
     return base::TERMINATION_STATUS_NORMAL_TERMINATION;
   }
 
   if (exit_code)
     *exit_code = tmp_exit_code;
 
   return static_cast<base::TerminationStatus>(status);
 }