Add UMA for disk latency for cache accesses.

net/disk_cache/simple/simple_synchronous_entry.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 "net/disk_cache/simple/simple_synchronous_entry.h"
 
 #include <algorithm>
 #include <cstring>
 #include <functional>
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/hash.h"
 #include "base/location.h"
+#include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/sha1.h"
 #include "base/strings/stringprintf.h"
+#include "base/time/time.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/simple/simple_backend_version.h"
 #include "net/disk_cache/simple/simple_histogram_macros.h"
 #include "net/disk_cache/simple/simple_util.h"
 #include "third_party/zlib/zlib.h"
 
 using base::File;
 using base::FilePath;
 using base::Time;
@@ skipping 179 matching lines @@
     : sparse_offset(sparse_offset_p),
       buf_len(buf_len_p) {}
 
 // static
 void SimpleSynchronousEntry::OpenEntry(
     net::CacheType cache_type,
     const FilePath& path,
     const uint64 entry_hash,
     bool had_index,
     SimpleEntryCreationResults *out_results) {
+  base::Time open_start_time(base::Time::Now());

[Deprecated (see juliatuttle), 2015/05/13 20:21:38]

Perhaps use TimeTicks? I am under the impression it is better for things that
don't need wallclock time, as it doesn't jump around when the system clock
changes.

[Randy Smith (Not in Mondays), 2015/05/13 20:32:52]

Oh, good point.  I haven't done this in too long, and clearly forget things
easily.  Done.

   SimpleSynchronousEntry* sync_entry =
       new SimpleSynchronousEntry(cache_type, path, "", entry_hash);
   out_results->result =
       sync_entry->InitializeForOpen(had_index,
                                     &out_results->entry_stat,
                                     &out_results->stream_0_data,
                                     &out_results->stream_0_crc32);
   if (out_results->result != net::OK) {
     sync_entry->Doom();
     delete sync_entry;
     out_results->sync_entry = NULL;
     out_results->stream_0_data = NULL;
     return;
   }
+  UMA_HISTOGRAM_TIMES("SimpleCache.DiskOpenLatency",

[Deprecated (see juliatuttle), 2015/05/13 20:21:38]

This looks good as long as you only care about open latency, but you'd mentioned
wanting to compare it to time-to-first-byte, which would correspond with the
first *data* read. I don't know how big a difference that would be.

[Randy Smith (Not in Mondays), 2015/05/13 20:32:52]

So Bryan and I chatted, and decided we'd be mostly comparing this against
Net.TCP_ConnectionLatency, which is probably also not quite right, but at least
gets to the same "get ready to read the bytes" stage.    I'm not sure there's
really an easy way to compare time to first byte disk cache vs. network without
a fair amount more work than will happen for branch.

+                      base::Time::Now() - open_start_time);
   out_results->sync_entry = sync_entry;
 }
 
 // static
 void SimpleSynchronousEntry::CreateEntry(
     net::CacheType cache_type,
     const FilePath& path,
     const std::string& key,
     const uint64 entry_hash,
     bool had_index,
@@ skipping 1184 matching lines @@
   range.offset = offset;
   range.length = len;
   range.data_crc32 = data_crc32;
   range.file_offset = data_file_offset;
   sparse_ranges_.insert(std::make_pair(offset, range));
 
   return true;
 }
 
 }  // namespace disk_cache