Record UMA statistics for file_stream operations.

net/base/file_stream_metrics_win.cc

Index: net/base/file_stream_metrics_win.cc
diff --git a/net/base/file_stream_metrics_win.cc b/net/base/file_stream_metrics_win.cc
new file mode 100644
index 0000000000000000000000000000000000000000..63ac701f71b53929bb0824efb954c5d1d1f919c3
--- /dev/null
+++ b/net/base/file_stream_metrics_win.cc
@@ -0,0 +1,150 @@
+// 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 "net/base/file_stream_metrics.h"
+
+#include <windows.h>
+
+#include "base/basictypes.h"
+
+namespace net {
+
+namespace {
+
+struct Range {
+  int low;
+  int high;
+  bool record_individually;
+};
+
+// This must be higher than the largest value that isn't remapped into a bucket.
+int kErrorBucketStart = 400;
+
+Range kErrorRangeList[] = {
+  { 0, 321, true },  // These are the ones we don't remap into buckets.
+  { 335, 371, false },
+  { 383, 387, false },

[cbentzel, 2011/08/18 13:31:28]

I really don't understand why you want gaps, as you end up recording these
anyway. Are they unexpected values?

[ahendrickson, 2011/08/18 15:56:45]

They would be values that don't appear in WinError.h.

If they happen, I want to be able to record them.

+  { 399, 404, false },
+  { 415, 418, false },
+  { 431, 433, false },
+  { 447, 868, false },
+  { 994, 1471, false },
+  { 1500, 1513, false },
+  { 1536, 1553, false },
+  { 1601, 1654, false },
+  { 1700, 1834, false },
+  { 1898, 1938, false },
+  { 2000, 2024, false },
+  { 2048, 2085, false },
+  { 2108, 2110, false },
+  { 2202, 2203, false },
+  { 2250, 2251, false },
+  { 2401, 2405, false },
+  { 3000, 3021, false },
+  { 3950, 3951, false },
+  { 4000, 4007, false },
+  { 4050, 4066, false },
+  { 4096, 4116, false },
+  { 4200, 4215, false },
+  { 4300, 4353, false },
+  { 4390, 4395, false },
+  { 4500, 4501, false },
+  { 4864, 4905, false },
+  { 5001, 5090, false },
+  { 5890, 5953, false },
+  { 6000, 6023, false },
+  { 6118, 6119, false },
+  { 6200, 6201, false },
+  { 6600, 6649, false },
+  { 6700, 6732, false },
+  { 6800, 6856, false },
+  { 7001, 7071, false },
+  { 8001, 8018, false },
+  { 8192, 8263, false },
+  { 8301, 8640, false },
+  { 8704, 8705, false },
+  { 8960, 9053, false },
+  { 9216, 9218, false },
+  { 9263, 9276, false },
+  { 9472, 9506, false },
+  { 9550, 9573, false },
+  { 9600, 9622, false },
+  { 9650, 9656, false },
+  { 9688, 9723, false },
+  { 9750, 9754, false },
+  { 9800, 9802, false },
+  { 9850, 9853, false },
+  { 9900, 9907, false },
+  { 10000, 10072, false },
+  { 10091, 10113, false },
+  { 11001, 11034, false },
+  { 12288, 12335, false },
+  { 12544, 12559, false },
+  { 12595, 12597, false },
+  { 12801, 12803, false },
+  { 13000, 13026, false },
+  { 13800, 13933, false },
+  { 14000, 14111, false },
+  { 15000, 15039, false },
+  { 15080, 15086, false },
+  { 15100, 15109, false },
+  { 15200, 15208, false },
+  { 15250, 15251, false },
+  { 15299, 15302, false },
+  { 16385, 16436, false },
+  { 18432, 18454, false },
+  { 20480, 20486, false },
+  { 24577, 24607, false },
+  { 28673, 28698, false },
+  { 32790, 32816, false },
+  { 33281, 33322, false },
+  { 35005, 35024, false },
+  { 36000, 36004, false },
+  { 40010, 40011, false },
+  { 40067, 40069, false },
+  { 53248, 53293, false },
+  { 53376, 53382, false },
+  { 57344, 57360, false },
+  { 57377, 57394, false },
+  { 65535, 65536 }
+};
+size_t kNumErrorRanges = ARRAYSIZE_UNSAFE(kErrorRangeList);
+
+}  // namespace
+
+// Windows has very many errors.  We're not interested in most of them, but we
+// don't know which ones are significant.
+// This function maps error ranges we think we don't care about to specific
+// buckets, and leaves the others alone.  If we get hits on the buckets,
+// we can add those values to the values we leave alone.
+// If we get values *between* the buckets, we record those as buckets too.
+// The range list is extracted from WinError.h.
+int GetErrorBucket(int error) {
+  error = HRESULT_CODE(error);
+
+  for (size_t n = 0; n < kNumErrorRanges; ++n) {
+    if (error < kErrorRangeList[n].low)
+      return (2 * n) - 1;  // In gap before the range.
+    if (error <= kErrorRangeList[n].high)
+      return 2 * n;  // In the range.
+  }
+
+  // After the last bucket.
+  return 2 * kNumErrorRanges - 1;
+}
+
+int MaxBucket() {
+  return 2 * kNumErrorRanges;
+}
+
+int MaxError() {
+  int max_error = 0;
+  for (size_t n = 0; n < kNumErrorRanges; ++n) {
+    if (kErrorRangeList[n].record_individually)
+      max_error = kErrorRangeList[n].high;
+  }
+  return max_error + 1;
+}
+
+}  // namespace net