Support experiment to store persistent metrics in memory-mapped file.

chrome/browser/metrics/chrome_metrics_service_client.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.
 
 #include "chrome/browser/metrics/chrome_metrics_service_client.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 162 matching lines @@
   file_metrics_provider->RegisterSource(
       program_dir.AppendASCII(installer::kSetupHistogramAllocatorName),
       metrics::FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_DIR,
       metrics::FileMetricsProvider::ASSOCIATE_CURRENT_RUN,
       installer::kSetupHistogramAllocatorName);
 #endif
 
   return file_metrics_provider;
 }
 
+void CleanUpGlobalPersistentHistogramStorage() {
+  // If there is a global metrics file being updated on disk, mark it to be
+  // deleted when the process exits. A normal shutdown is almost complete
+  // so there is no benefit in keeping a file with no new data to be processed
+  // during the next startup sequence.

[Ilya Sherman, 2016/06/29 20:41:38]

nit: I'd move this comment to be just above the function, and also add a bit of
text mentioning that this basically trades off slower shutdown vs. slower
startup.

[bcwhite, 2016/06/30 22:56:12]

Done.

+  base::GlobalHistogramAllocator* allocator =
+      base::GlobalHistogramAllocator::Get();
+  if (!allocator)
+    return;
+
+  const base::FilePath& path = allocator->GetPersistentLocation();
+  if (path.empty())
+    return;
+
+  // Open (with delete) and then immediately close the file by going out

[Alexei Svitkine (slow), 2016/06/29 19:13:43]

Nit: Wrapping is off? I think some words below should fit on this line.

[bcwhite, 2016/06/30 22:56:12]

One word.

+  // of scope. This is the only cross-platform safe way to delete a file
+  // that may be open elsewhere.

[Ilya Sherman, 2016/06/29 20:41:38]

If the file is open elsewhere, is there anything that guarantees that there
won't be any further attempts to read from or write to the file?

[bcwhite, 2016/06/30 22:56:12]

None.  Existing opens will continue to operate normally.  New opens will fail
and the actual contents will be free'd once the last open handle gets closed.

[Ilya Sherman, 2016/06/30 23:16:48]

Ah, nice.  I think this would be great to document explicitly in this comment --
that behavior wasn't obvious to me.

[bcwhite, 2016/07/11 18:06:39]

Will do.

+  base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_READ |
+                        base::File::FLAG_DELETE_ON_CLOSE);
+}
+
 }  // namespace
 
 
 const char ChromeMetricsServiceClient::kBrowserMetricsName[] = "BrowserMetrics";
 
 ChromeMetricsServiceClient::ChromeMetricsServiceClient(
     metrics::MetricsStateManager* state_manager)
     : metrics_state_manager_(state_manager),
 #if defined(OS_CHROMEOS)
       chromeos_metrics_provider_(nullptr),
@@ skipping 11 matching lines @@
       start_time_(base::TimeTicks::Now()),
       has_uploaded_profiler_data_(false),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
   RecordCommandLineMetrics();
   RegisterForNotifications();
 }
 
 ChromeMetricsServiceClient::~ChromeMetricsServiceClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
+  CleanUpGlobalPersistentHistogramStorage();
 }
 
 // static
 std::unique_ptr<ChromeMetricsServiceClient> ChromeMetricsServiceClient::Create(
     metrics::MetricsStateManager* state_manager,
     PrefService* local_state) {
   // Perform two-phase initialization so that |client->metrics_service_| only
   // receives pointers to fully constructed objects.
   std::unique_ptr<ChromeMetricsServiceClient> client(
       new ChromeMetricsServiceClient(state_manager));
@@ skipping 486 matching lines @@
   }
 }
 
 void ChromeMetricsServiceClient::OnURLOpenedFromOmnibox(OmniboxLog* log) {
   metrics_service_->OnApplicationNotIdle();
 }
 
 bool ChromeMetricsServiceClient::IsUMACellularUploadLogicEnabled() {
   return metrics::IsCellularLogicEnabled();
 }