Integrate Crashpad UMA

base/metrics/persistent_histogram_allocator.cc

 // Copyright 2016 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 "base/metrics/persistent_histogram_allocator.h"
 
 #include <memory>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 668 matching lines @@
 void GlobalHistogramAllocator::CreateWithLocalMemory(
     size_t size,
     uint64_t id,
     StringPiece name) {
   Set(WrapUnique(new GlobalHistogramAllocator(
       MakeUnique<LocalPersistentMemoryAllocator>(size, id, name))));
 }
 
 #if !defined(OS_NACL)
 // static
-void GlobalHistogramAllocator::CreateWithFile(
+bool GlobalHistogramAllocator::CreateWithFile(
     const FilePath& file_path,
     size_t size,
     uint64_t id,
     StringPiece name) {
   bool exists = PathExists(file_path);
   File file(
       file_path, File::FLAG_OPEN_ALWAYS | File::FLAG_SHARE_DELETE |
                  File::FLAG_READ | File::FLAG_WRITE);
 
   std::unique_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
   if (exists) {
     mmfile->Initialize(std::move(file), MemoryMappedFile::READ_WRITE);
   } else {
     mmfile->Initialize(std::move(file), {0, static_cast<int64_t>(size)},
                        MemoryMappedFile::READ_WRITE_EXTEND);
   }
   if (!mmfile->IsValid() ||
       !FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile, true)) {
     NOTREACHED();
-    return;
+    return false;
   }
 
   Set(WrapUnique(
       new GlobalHistogramAllocator(MakeUnique<FilePersistentMemoryAllocator>(
           std::move(mmfile), size, id, name, false))));
+  Get()->SetPersistentLocation(file_path);
+  return true;
 }
-#endif
+
+// static
+bool GlobalHistogramAllocator::CreateWithActiveFile(const FilePath& base_path,
+                                                    const FilePath& active_path,
+                                                    size_t size,
+                                                    uint64_t id,
+                                                    StringPiece name) {
+  if (!base::ReplaceFile(active_path, base_path, nullptr))
+    base::DeleteFile(base_path, /*recursive=*/false);
+
+  return base::GlobalHistogramAllocator::CreateWithFile(active_path, size, id,
+                                                        name);
+}
+
+// static
+bool GlobalHistogramAllocator::CreateWithActiveFileInDir(const FilePath& dir,
+                                                         size_t size,
+                                                         uint64_t id,
+                                                         StringPiece name) {
+  FilePath base_path, active_path;
+  ConstructFilePaths(dir, name, &base_path, &active_path);
+  return CreateWithActiveFile(base_path, active_path, size, id, name);
+}
+
+// static
+void GlobalHistogramAllocator::ConstructFilePaths(const FilePath& dir,
+                                                  StringPiece name,
+                                                  FilePath* out_base_path,
+                                                  FilePath* out_active_path) {
+  *out_base_path = dir.AppendASCII(name)

[Alexei Svitkine (slow), 2016/09/15 16:49:44]

Nit: I'd prefer to wrap after the =

But you can keep as-is if this is what git cl format produced.

[scottmg, 2016/09/15 17:41:13]

Yeah, this is clang-format output. It doesn't quite fit only after the =, so one
of the .s has to be a break point anyway.

+                       .AddExtension(PersistentMemoryAllocator::kFileExtension);
+  if (out_active_path) {
+    *out_active_path =
+        dir.AppendASCII(name.as_string() + std::string("-active"))
+            .AddExtension(PersistentMemoryAllocator::kFileExtension);
+  }
+}
+#endif  // !OS_NACL

[Alexei Svitkine (slow), 2016/09/15 16:49:44]

Nit: !defined(OS_NACL)

[scottmg, 2016/09/15 17:41:13]

Done.

 
 // static
 void GlobalHistogramAllocator::CreateWithSharedMemory(
     std::unique_ptr<SharedMemory> memory,
     size_t size,
     uint64_t id,
     StringPiece name) {
   if ((!memory->memory() && !memory->Map(size)) ||
       !SharedPersistentMemoryAllocator::IsSharedMemoryAcceptable(*memory)) {
     NOTREACHED();
@@ skipping 103 matching lines @@
                                                 contents)) {
     LOG(ERROR) << "Could not write \"" << Name() << "\" persistent histograms"
                << " to file: " << persistent_location_.value();
     return false;
   }
 
   return true;
 #endif
 }
 
+void GlobalHistogramAllocator::DeletePersistentLocation() {
+  if (persistent_location_.empty())
+    return;
+
+  // Open (with delete) and then immediately close the file by going out of
+  // scope. This is the only cross-platform safe way to delete a file that may
+  // be open elsewhere. Open handles will continue to operate normally but
+  // new opens will not be possible.
+  File file(persistent_location_,

[Alexei Svitkine (slow), 2016/09/15 16:49:44]

Is this supported for NACL builds? Seems like it shouldn't given the other file
manipulation code isn't.

Maybe we should add a persistent_metrics_file_utils.cc file and move all the
file handled code there instead of having the NACL ifdefs?

[bcwhite, 2016/09/15 17:07:48]

Heh.  I told him to move it in here along-side WriteToPersistentLocation().

Back when working on profiles, there was a general desire *against* _util files
preferring integration or complete segregation.

[scottmg, 2016/09/15 17:41:13]

#ifdef'd for now to match and fix the build. As Brian said I had a
persistent_metrics_file_util.cc/h in a previous CL, but I think this is tidier
overall.

Maybe we could break it up into NaCl files and non-NaCl files in a future change
maybe?

[Alexei Svitkine (slow), 2016/09/15 17:49:16]

Sure, I'm ok with that being explored in a separate CL.

[bcwhite, 2016/09/15 17:56:33]

If I remember correctly, it's only the .cc file that is the problem; I included
the #ifdef in the .h file for correctness-sake.  But you could omit the #ifdef
here and have a separate persistent_histogram_allocator_nonacl.cc file with
those definitions (in that future CL).

+            File::FLAG_OPEN | File::FLAG_READ | File::FLAG_DELETE_ON_CLOSE);
+}
+
 GlobalHistogramAllocator::GlobalHistogramAllocator(
     std::unique_ptr<PersistentMemoryAllocator> memory)
     : PersistentHistogramAllocator(std::move(memory)),
       import_iterator_(this) {}
 
 void GlobalHistogramAllocator::ImportHistogramsToStatisticsRecorder() {
   // Skip the import if it's the histogram that was last created. Should a
   // race condition cause the "last created" to be overwritten before it
   // is recognized here then the histogram will be created and be ignored
   // when it is detected as a duplicate by the statistics-recorder. This
   // simple check reduces the time of creating persistent histograms by
   // about 40%.
   Reference record_to_ignore = last_created();
 
   // There is no lock on this because the iterator is lock-free while still
   // guaranteed to only return each entry only once. The StatisticsRecorder
   // has its own lock so the Register operation is safe.
   while (true) {
     std::unique_ptr<HistogramBase> histogram =
         import_iterator_.GetNextWithIgnore(record_to_ignore);
     if (!histogram)
       break;
     StatisticsRecorder::RegisterOrDeleteDuplicate(histogram.release());
   }
 }
 
 }  // namespace base