blob: e3759524f83c7cfce961e69fbbb0fd0e0c7c479d (
plain)
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
|
// 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.
#include "base/metrics/histogram_samples.h"
#include "base/compiler_specific.h"
#include "base/pickle.h"
namespace base {
namespace {
class SampleCountPickleIterator : public SampleCountIterator {
public:
SampleCountPickleIterator(PickleIterator* iter);
virtual bool Done() const OVERRIDE;
virtual void Next() OVERRIDE;
virtual void Get(HistogramBase::Sample* min,
HistogramBase::Sample* max,
HistogramBase::Count* count) const OVERRIDE;
private:
PickleIterator* const iter_;
HistogramBase::Sample min_;
HistogramBase::Sample max_;
HistogramBase::Count count_;
bool is_done_;
};
SampleCountPickleIterator::SampleCountPickleIterator(PickleIterator* iter)
: iter_(iter),
is_done_(false) {
Next();
}
bool SampleCountPickleIterator::Done() const {
return is_done_;
}
void SampleCountPickleIterator::Next() {
DCHECK(!Done());
if (!iter_->ReadInt(&min_) ||
!iter_->ReadInt(&max_) ||
!iter_->ReadInt(&count_))
is_done_ = true;
}
void SampleCountPickleIterator::Get(HistogramBase::Sample* min,
HistogramBase::Sample* max,
HistogramBase::Count* count) const {
DCHECK(!Done());
*min = min_;
*max = max_;
*count = count_;
}
} // namespace
HistogramSamples::HistogramSamples() : sum_(0), redundant_count_(0) {}
HistogramSamples::~HistogramSamples() {}
void HistogramSamples::Add(const HistogramSamples& other) {
sum_ += other.sum();
redundant_count_ += other.redundant_count();
bool success = AddSubtractImpl(other.Iterator().get(), ADD);
DCHECK(success);
}
bool HistogramSamples::AddFromPickle(PickleIterator* iter) {
int64 sum;
HistogramBase::Count redundant_count;
if (!iter->ReadInt64(&sum) || !iter->ReadInt(&redundant_count))
return false;
sum_ += sum;
redundant_count_ += redundant_count;
SampleCountPickleIterator pickle_iter(iter);
return AddSubtractImpl(&pickle_iter, ADD);
}
void HistogramSamples::Subtract(const HistogramSamples& other) {
sum_ -= other.sum();
redundant_count_ -= other.redundant_count();
bool success = AddSubtractImpl(other.Iterator().get(), SUBTRACT);
DCHECK(success);
}
bool HistogramSamples::Serialize(Pickle* pickle) const {
if (!pickle->WriteInt64(sum_) || !pickle->WriteInt(redundant_count_))
return false;
HistogramBase::Sample min;
HistogramBase::Sample max;
HistogramBase::Count count;
for (scoped_ptr<SampleCountIterator> it = Iterator();
!it->Done();
it->Next()) {
it->Get(&min, &max, &count);
if (!pickle->WriteInt(min) ||
!pickle->WriteInt(max) ||
!pickle->WriteInt(count))
return false;
}
return true;
}
void HistogramSamples::IncreaseSum(int64 diff) {
sum_ += diff;
}
void HistogramSamples::IncreaseRedundantCount(HistogramBase::Count diff) {
redundant_count_ += diff;
}
SampleCountIterator::~SampleCountIterator() {}
bool SampleCountIterator::GetBucketIndex(size_t* index) const {
DCHECK(!Done());
return false;
}
} // namespace base
|
