1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
// 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.
#ifndef BASE_METRICS_HISTOGRAM_BASE_H_
#define BASE_METRICS_HISTOGRAM_BASE_H_
#include <string>
#include <vector>
#include "base/atomicops.h"
#include "base/base_export.h"
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "base/time/time.h"
class Pickle;
class PickleIterator;
namespace base {
class DictionaryValue;
class HistogramBase;
class HistogramSamples;
class ListValue;
////////////////////////////////////////////////////////////////////////////////
// These enums are used to facilitate deserialization of histograms from other
// processes into the browser. If you create another class that inherits from
// HistogramBase, add new histogram types and names below.
enum BASE_EXPORT HistogramType {
HISTOGRAM,
LINEAR_HISTOGRAM,
BOOLEAN_HISTOGRAM,
CUSTOM_HISTOGRAM,
SPARSE_HISTOGRAM,
};
std::string HistogramTypeToString(HistogramType type);
// Create or find existing histogram that matches the pickled info.
// Returns NULL if the pickled data has problems.
BASE_EXPORT_PRIVATE HistogramBase* DeserializeHistogramInfo(
PickleIterator* iter);
////////////////////////////////////////////////////////////////////////////////
class BASE_EXPORT HistogramBase {
public:
typedef int Sample; // Used for samples.
typedef subtle::Atomic32 AtomicCount; // Used to count samples.
typedef int32 Count; // Used to manipulate counts in temporaries.
static const Sample kSampleType_MAX; // INT_MAX
enum Flags {
kNoFlags = 0,
// Histogram should be UMA uploaded.
kUmaTargetedHistogramFlag = 0x1,
// Indicates that this is a stability histogram. This flag exists to specify
// which histograms should be included in the initial stability log. Please
// refer to |MetricsService::PrepareInitialStabilityLog|.
kUmaStabilityHistogramFlag = kUmaTargetedHistogramFlag | 0x2,
// Indicates that the histogram was pickled to be sent across an IPC
// Channel. If we observe this flag on a histogram being aggregated into
// after IPC, then we are running in a single process mode, and the
// aggregation should not take place (as we would be aggregating back into
// the source histogram!).
kIPCSerializationSourceFlag = 0x10,
// Only for Histogram and its sub classes: fancy bucket-naming support.
kHexRangePrintingFlag = 0x8000,
};
// Histogram data inconsistency types.
enum Inconsistency {
NO_INCONSISTENCIES = 0x0,
RANGE_CHECKSUM_ERROR = 0x1,
BUCKET_ORDER_ERROR = 0x2,
COUNT_HIGH_ERROR = 0x4,
COUNT_LOW_ERROR = 0x8,
NEVER_EXCEEDED_VALUE = 0x10
};
explicit HistogramBase(const std::string& name);
virtual ~HistogramBase();
std::string histogram_name() const { return histogram_name_; }
// Comapres |name| to the histogram name and triggers a DCHECK if they do not
// match. This is a helper function used by histogram macros, which results in
// in more compact machine code being generated by the macros.
void CheckName(const StringPiece& name) const;
// Operations with Flags enum.
int32 flags() const { return flags_; }
void SetFlags(int32 flags);
void ClearFlags(int32 flags);
virtual HistogramType GetHistogramType() const = 0;
// Whether the histogram has construction arguments as parameters specified.
// For histograms that don't have the concept of minimum, maximum or
// bucket_count, this function always returns false.
virtual bool HasConstructionArguments(Sample expected_minimum,
Sample expected_maximum,
size_t expected_bucket_count) const = 0;
virtual void Add(Sample value) = 0;
// 2 convenient functions that call Add(Sample).
void AddTime(const TimeDelta& time);
void AddBoolean(bool value);
virtual void AddSamples(const HistogramSamples& samples) = 0;
virtual bool AddSamplesFromPickle(PickleIterator* iter) = 0;
// Serialize the histogram info into |pickle|.
// Note: This only serializes the construction arguments of the histogram, but
// does not serialize the samples.
bool SerializeInfo(Pickle* pickle) const;
// Try to find out data corruption from histogram and the samples.
// The returned value is a combination of Inconsistency enum.
virtual int FindCorruption(const HistogramSamples& samples) const;
// Snapshot the current complete set of sample data.
// Override with atomic/locked snapshot if needed.
virtual scoped_ptr<HistogramSamples> SnapshotSamples() const = 0;
// The following methods provide graphical histogram displays.
virtual void WriteHTMLGraph(std::string* output) const = 0;
virtual void WriteAscii(std::string* output) const = 0;
// Produce a JSON representation of the histogram. This is implemented with
// the help of GetParameters and GetCountAndBucketData; overwrite them to
// customize the output.
void WriteJSON(std::string* output) const;
protected:
// Subclasses should implement this function to make SerializeInfo work.
virtual bool SerializeInfoImpl(Pickle* pickle) const = 0;
// Writes information about the construction parameters in |params|.
virtual void GetParameters(DictionaryValue* params) const = 0;
// Writes information about the current (non-empty) buckets and their sample
// counts to |buckets|, the total sample count to |count| and the total sum
// to |sum|.
virtual void GetCountAndBucketData(Count* count,
int64* sum,
ListValue* buckets) const = 0;
//// Produce actual graph (set of blank vs non blank char's) for a bucket.
void WriteAsciiBucketGraph(double current_size,
double max_size,
std::string* output) const;
// Return a string description of what goes in a given bucket.
const std::string GetSimpleAsciiBucketRange(Sample sample) const;
// Write textual description of the bucket contents (relative to histogram).
// Output is the count in the buckets, as well as the percentage.
void WriteAsciiBucketValue(Count current,
double scaled_sum,
std::string* output) const;
private:
const std::string histogram_name_;
int32 flags_;
DISALLOW_COPY_AND_ASSIGN(HistogramBase);
};
} // namespace base
#endif // BASE_METRICS_HISTOGRAM_BASE_H_
|
