Move memory management code into separate class for future reuse.

base/debug/activity_analyzer.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/debug/activity_analyzer.h"
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
@@ skipping 72 matching lines @@
 }
 
 void GlobalActivityAnalyzer::PrepareAllAnalyzers() {
   // Fetch all the records. This will retrieve only ones created since the
   // last run since the PMA iterator will continue from where it left off.
   uint32_t type;
   PersistentMemoryAllocator::Reference ref;
   while ((ref = allocator_iterator_.GetNext(&type)) != 0) {
     switch (type) {
       case GlobalActivityTracker::kTypeIdActivityTracker:
-      case GlobalActivityTracker::kTypeIdActivityTrackerFree:
+      case ~GlobalActivityTracker::kTypeIdActivityTracker:

[Alexei Svitkine (slow), 2016/10/13 19:23:20]

Nit: Can this also use the helper function? You can probably change the switch
to an if in that case.

Or make another helper in GlobalActivityTracker that asks if it's of that type
and inline the logic there, so the details are contained in that code.

[bcwhite, 2016/10/13 19:35:13]

How about if I just make the class take a "free type" constructor parameter,
instead?  The free type can be defined in the enum as anything (including
free_type=~type).  Helper methods go away and everything is clean again.  Cost
is one more const uint32_t member variable.

         // Free or not, add it to the list of references for later analysis.
         tracker_references_.insert(ref);
         break;
     }
   }
 
   // Go through all the known references and create analyzers for them with
   // snapshots of the current state.
   analyzers_.clear();
   for (PersistentMemoryAllocator::Reference tracker_ref : tracker_references_) {
@@ skipping 15 matching lines @@
     // Add this analyzer to the map of known ones, indexed by a unique thread
     // identifier.
     DCHECK(!base::ContainsKey(analyzers_, analyzer->GetThreadKey()));
     analyzer->allocator_reference_ = ref;
     analyzers_[analyzer->GetThreadKey()] = std::move(analyzer);
   }
 }
 
 }  // namespace debug
 }  // namespace base