Initialize StatisticsRecorder in Child Process to hold

base/metrics/statistics_recorder.h

 // Copyright (c) 2012 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.
 
 // StatisticsRecorder handles all histograms in the system. It provides a
 // general place for histograms to register, and supports a global API for
 // accessing (i.e., dumping, or graphing) the data in all the histograms.
 
 #ifndef BASE_METRICS_STATISTICS_RECORDER_H_
 #define BASE_METRICS_STATISTICS_RECORDER_H_
 
 #include <list>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 
 namespace base {
 
 class CachedRanges;
 class Histogram;
 class Lock;
 
 class BASE_EXPORT StatisticsRecorder {
  public:
   typedef std::vector<Histogram*> Histograms;
 
   StatisticsRecorder();

[jam, 2012/07/18 05:14:17]

if it's a singleton, then the constructor and destructor should be private

[jar (doing other things), 2012/07/18 16:00:01]

I think this was done to facilitate testability.

In tests, the instance is constructed and destroyed, but in regular use, it is
not.

Would you argue for private constructor and destructor, and then add FriendTest
etc. for testing?

Truth be known, there are minimal (no?) ill effects to additional constructions.
The construction is (effectively) done for side effects (initializing a group of
statics, including a lock, in a well defined order).  The singleton is used in
the browser to support race-free (permanent) initialization.

On 2012/07/18 05:14:17, John Abd-El-Malek wrote:

[jam, 2012/07/18 16:36:12]

I think that would be better, because that enforces that no production code
creates another instance of this class by mistake.

[ramant (doing other things), 2012/07/18 18:54:34]

Done.

 
   ~StatisticsRecorder();
 
+  // Initializes the StatisticsRecorder system.
+  static void Initialize();
+
   // Find out if histograms can now be registered into our list.
   static bool IsActive();
 
   // Register, or add a new histogram to the collection of statistics. If an
   // identically named histogram is already registered, then the argument
   // |histogram| will deleted.  The returned value is always the registered
   // histogram (either the argument, or the pre-existing registered histogram).
   static Histogram* RegisterOrDeleteDuplicate(Histogram* histogram);
 
   // Register, or add a new cached_ranges_ of |histogram|. If an identical
@@ skipping 26 matching lines @@
   static bool dump_on_exit() { return dump_on_exit_; }
 
   static void set_dump_on_exit(bool enable) { dump_on_exit_ = enable; }
 
   // GetSnapshot copies some of the pointers to registered histograms into the
   // caller supplied vector (Histograms).  Only histograms with names matching
   // query are returned. The query must be a substring of histogram name for its
   // pointer to be copied.
   static void GetSnapshot(const std::string& query, Histograms* snapshot);
 
-
  private:
   // We keep all registered histograms in a map, from name to histogram.
   typedef std::map<std::string, Histogram*> HistogramMap;
 
   // We keep all |cached_ranges_| in a map, from checksum to a list of
   // |cached_ranges_|.  Checksum is calculated from the |ranges_| in
   // |cached_ranges_|.
   typedef std::map<uint32, std::list<CachedRanges*>*> RangesMap;
 
   static HistogramMap* histograms_;
 
   static RangesMap* ranges_;
 
   // lock protects access to the above map.
   static base::Lock* lock_;
 
   // Dump all known histograms to log.
   static bool dump_on_exit_;
 
   DISALLOW_COPY_AND_ASSIGN(StatisticsRecorder);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_STATISTICS_RECORDER_H_