Merge multiple histogram snapshots into single one for reporting.

components/metrics/metrics_service.h

 // 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.
 
 // This file defines a service that collects information about the user
 // experience in order to help improve future versions of the app.
 
 #ifndef COMPONENTS_METRICS_METRICS_SERVICE_H_
 #define COMPONENTS_METRICS_METRICS_SERVICE_H_
 
 #include <map>
+#include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_flattener.h"
@@ skipping 75 matching lines @@
     UNINITIALIZED_PHASE = 0,
     START_METRICS_RECORDING = 100,
     CREATE_PROFILE = 200,
     STARTUP_TIMEBOMB_ARM = 300,
     THREAD_WATCHER_START = 400,
     MAIN_MESSAGE_LOOP_RUN = 500,
     SHUTDOWN_TIMEBOMB_ARM = 600,
     SHUTDOWN_COMPLETE = 700,
   };
 
+  typedef std::set<base::HistogramBase*> HistogramSet;
+
   // Creates the MetricsService with the given |state_manager|, |client|, and
   // |local_state|.  Does not take ownership of the paramaters; instead stores
   // a weak pointer to each. Caller should ensure that the parameters are valid
   // for the lifetime of this class.
   MetricsService(MetricsStateManager* state_manager,
                  MetricsServiceClient* client,
                  PrefService* local_state);
   ~MetricsService() override;
 
   // Initializes metrics recording state. Updates various bookkeeping values in
@@ skipping 172 matching lines @@
   enum RecordingState {
     INACTIVE,
     ACTIVE,
     UNSET
   };
 
   typedef std::set<base::PersistentMemoryAllocator*> AllocatorSet;
 
   // A class for iterating over the histograms in persistent memory segments.
   class PersistentHistogramIterator {
-    // This class provides a reference-counted pointer to a histogram which
-    // is necessary for histogram objects that are dynamically generated
-    // (generally pointing to persistent memory) and to be owned by an STL
-    // iterator which, by necessity, must be copyable.
-    class HistogramPointer : public base::RefCounted<HistogramPointer> {
-     public:
-      HistogramPointer(base::HistogramBase* h) : histogram_(h) {}
-      base::HistogramBase* get() { return histogram_.get(); }
-
-     private:
-      scoped_ptr<base::HistogramBase> histogram_;
-    };
-
    public:
-    PersistentHistogramIterator(AllocatorSet& allocators,
+    // The |found_histograms| set will be loaded with pointers to all the
+    // histograms found during iteration. This is important because users
+    // of the iterator may expect the returned histograms to live longer
+    // than a particular iteration step. The caller must delete these
+    // if necessary.
+    PersistentHistogramIterator(HistogramSet* found_histograms,
+                                AllocatorSet& allocators,
                                 AllocatorSet::iterator pos);
 
     PersistentHistogramIterator& operator++();
     PersistentHistogramIterator operator++(int) {
       PersistentHistogramIterator tmp(*this);
       operator++();
       return tmp;
     }
 
     bool operator==(const PersistentHistogramIterator& rhs) const {
       return allocator_iter_ == rhs.allocator_iter_ &&
              histogram_iter_ == rhs.histogram_iter_;
     }
     bool operator!=(const PersistentHistogramIterator& rhs) const {
       return allocator_iter_ != rhs.allocator_iter_ ||
              histogram_iter_ != rhs.histogram_iter_;
     }
     base::HistogramBase* operator*() {
-      return current_histogram_->get();
+      return current_histogram_;
     }
 
    private:
     AllocatorSet& allocators_;
     AllocatorSet::iterator allocator_iter_;
     base::PersistentMemoryAllocator::Iterator histogram_iter_;
 
-    // STL iterators must be copyable so a regular scoped_ptr is not
-    // sufficient as it doesn't allow such. A ref-counted one is needed.
-    scoped_refptr<HistogramPointer> current_histogram_;
+    HistogramSet* found_histograms_;
+    base::HistogramBase* current_histogram_;
   };
 
   typedef std::vector<SyntheticTrialGroup> SyntheticTrialGroups;
 
   // Calls into the client to initialize some system profile metrics.
   void StartInitTask();
 
   // Callback that moves the state to INIT_TASK_DONE. When this is called, the
   // state should be INIT_TASK_SCHEDULED.
   void FinishedInitTask();
@@ skipping 123 matching lines @@
 
   // Record complete list of stability histograms into the current log,
   // i.e., histograms with the |kUmaStabilityHistogramFlag| flag set.
   void RecordCurrentStabilityHistograms();
 
   // Skips staged upload and discards the log. Used in case of unsuccessful
   // upload or intentional sampling of logs.
   void SkipAndDiscardUpload();
 
   // Begin and End iterators for going through all the metrics under management.
-  PersistentHistogramIterator persistent_begin();
+  PersistentHistogramIterator persistent_begin(HistogramSet* found);
   PersistentHistogramIterator persistent_end();
 
   // Manager for the various in-flight logs.
   MetricsLogManager log_manager_;
 
   // |histogram_snapshot_manager_| prepares histogram deltas for transmission.
   base::HistogramSnapshotManager histogram_snapshot_manager_;
 
   // Used to manage various metrics reporting state prefs, such as client id,
   // low entropy source and whether metrics reporting is enabled. Weak pointer.
@@ skipping 82 matching lines @@
 
   // Persistent memory segments that contain histograms created elsewhere.
   AllocatorSet allocators_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsService);
 };
 
 }  // namespace metrics
 
 #endif  // COMPONENTS_METRICS_METRICS_SERVICE_H_