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
|
// Copyright (c) 2009 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 NET_BASE_LOAD_LOG_H_
#define NET_BASE_LOAD_LOG_H_
#include <vector>
#include "base/ref_counted.h"
#include "base/time.h"
namespace net {
// LoadLog stores profiling information on where time was spent while servicing
// a request (waiting in queues, resolving hosts, resolving proxy, etc...).
class LoadLog : public base::RefCounted<LoadLog> {
public:
enum EventType {
#define EVENT_TYPE(label) TYPE_ ## label,
#include "net/base/load_log_event_type_list.h"
#undef EVENT_TYPE
};
// Whether this is the start/end of an event. Or in the case of EventTypes
// that are "instantaneous", kNone.
enum EventPhase {
PHASE_NONE,
PHASE_BEGIN,
PHASE_END,
};
// A logged event. Note that "phase" means if this is the start/end of a
// particular event type (in order to record a timestamp for both endpoints).
struct Event {
Event(base::TimeTicks time,
EventType type,
EventPhase phase)
: time(time), type(type), phase(phase) {
}
base::TimeTicks time;
EventType type;
EventPhase phase;
};
// The maximum size of |events_|.
enum { kMaxNumEntries = 40 };
// Ordered set of events that were logged.
// TODO(eroman): use a StackVector or array to avoid allocations.
typedef std::vector<Event> EventList;
// Create a log, which can hold up to |kMaxNumEntries| Events.
//
// If events are dropped because the log has grown too large, the final
// entry will be of type kLogTruncated.
LoadLog();
// --------------------------------------------------------------------------
// The public interface for adding events to the log are static methods.
// This makes it easier to deal with optionally NULL LoadLog.
// Adds an instantaneous event to the log.
static void AddEvent(LoadLog* log, EventType event) {
if (log)
log->Add(base::TimeTicks::Now(), event, PHASE_NONE);
}
// Adds the start of an event to the log. Presumably this event type measures
// a time duration, and will be matched by a call to EndEvent(event).
static void BeginEvent(LoadLog* log, EventType event) {
if (log)
log->Add(base::TimeTicks::Now(), event, PHASE_BEGIN);
}
// Adds the end of an event to the log. Presumably this event type measures
// a time duration, and we are matching an earlier call to BeginEvent(event).
static void EndEvent(LoadLog* log, EventType event) {
if (log)
log->Add(base::TimeTicks::Now(), event, PHASE_END);
}
// --------------------------------------------------------------------------
// Returns the list of all events in the log.
const EventList& events() const {
return events_;
}
// Returns a C-String symbolic name for |event|.
static const char* EventTypeToString(EventType event);
void Add(const Event& event);
void Add(base::TimeTicks t, EventType event, EventPhase phase) {
Add(Event(t, event, phase));
}
// Copies all events from |log|, appending it to the end of |this|.
void Append(const LoadLog* log);
private:
EventList events_;
};
} // namespace net
#endif // NET_BASE_LOAD_LOG_H_
|
