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
|
// 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 NET_BASE_CAPTURING_NET_LOG_H_
#define NET_BASE_CAPTURING_NET_LOG_H_
#include <string>
#include <vector>
#include "base/atomicops.h"
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/synchronization/lock.h"
#include "base/time.h"
#include "net/base/net_log.h"
namespace base {
class DictionaryValue;
}
namespace net {
// CapturingNetLog is an implementation of NetLog that saves messages to a
// bounded buffer. It is intended for testing only, and is part of the
// net_test_support project.
class CapturingNetLog : public NetLog {
public:
struct CapturedEntry {
CapturedEntry(EventType type,
const base::TimeTicks& time,
Source source,
EventPhase phase,
scoped_ptr<base::DictionaryValue> params);
// Copy constructor needed to store in a std::vector because of the
// scoped_ptr.
CapturedEntry(const CapturedEntry& entry);
~CapturedEntry();
// Equality operator needed to store in a std::vector because of the
// scoped_ptr.
CapturedEntry& operator=(const CapturedEntry& entry);
// Attempt to retrieve an value of the specified type with the given name
// from |params|. Returns true on success, false on failure. Does not
// modify |value| on failure.
bool GetStringValue(const std::string& name, std::string* value) const;
bool GetIntegerValue(const std::string& name, int* value) const;
// Same as GetIntegerValue, but returns the error code associated with a
// log entry.
bool GetNetErrorCode(int* value) const;
// Returns the parameters as a JSON string, or empty string if there are no
// parameters.
std::string GetParamsJson() const;
EventType type;
base::TimeTicks time;
Source source;
EventPhase phase;
scoped_ptr<base::DictionaryValue> params;
};
// Ordered set of entries that were logged.
typedef std::vector<CapturedEntry> CapturedEntryList;
CapturingNetLog();
virtual ~CapturingNetLog();
// Returns the list of all entries in the log.
void GetEntries(CapturedEntryList* entry_list) const;
// Returns number of entries in the log.
size_t GetSize() const;
void Clear();
void SetLogLevel(NetLog::LogLevel log_level);
// NetLog implementation:
virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
virtual uint32 NextID() OVERRIDE;
virtual LogLevel GetLogLevel() const OVERRIDE;
virtual void AddThreadSafeObserver(ThreadSafeObserver* observer,
LogLevel log_level) OVERRIDE;
virtual void SetObserverLogLevel(ThreadSafeObserver* observer,
LogLevel log_level) OVERRIDE;
virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE;
private:
// Needs to be "mutable" so can use it in GetEntries().
mutable base::Lock lock_;
// Last assigned source ID. Incremented to get the next one.
base::subtle::Atomic32 last_id_;
CapturedEntryList captured_entries_;
NetLog::LogLevel log_level_;
DISALLOW_COPY_AND_ASSIGN(CapturingNetLog);
};
// Helper class that exposes a similar API as BoundNetLog, but uses a
// CapturingNetLog rather than the more generic NetLog.
//
// CapturingBoundNetLog can easily be converted to a BoundNetLog using the
// bound() method.
class CapturingBoundNetLog {
public:
CapturingBoundNetLog();
~CapturingBoundNetLog();
// The returned BoundNetLog is only valid while |this| is alive.
BoundNetLog bound() const { return net_log_; }
// Fills |entry_list| with all entries in the log.
void GetEntries(CapturingNetLog::CapturedEntryList* entry_list) const;
// Returns number of entries in the log.
size_t GetSize() const;
void Clear();
// Sets the log level of the underlying CapturingNetLog.
void SetLogLevel(NetLog::LogLevel log_level);
private:
CapturingNetLog capturing_net_log_;
const BoundNetLog net_log_;
DISALLOW_COPY_AND_ASSIGN(CapturingBoundNetLog);
};
} // namespace net
#endif // NET_BASE_CAPTURING_NET_LOG_H_
|
