1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef NET_BASE_CAPTURING_NET_LOG_H_
6#define NET_BASE_CAPTURING_NET_LOG_H_
7
8#include <string>
9#include <vector>
10
11#include "base/atomicops.h"
12#include "base/basictypes.h"
13#include "base/compiler_specific.h"
14#include "base/memory/ref_counted.h"
15#include "base/memory/scoped_ptr.h"
16#include "base/synchronization/lock.h"
17#include "base/time/time.h"
18#include "net/base/net_log.h"
19
20namespace base {
21class DictionaryValue;
22class ListValue;
23}
24
25namespace net {
26
27// CapturingNetLog is a NetLog which instantiates Observer that saves messages
28// to a bounded buffer.  It is intended for testing only, and is part of the
29// net_test_support project. This is provided for convinience and compatilbility
30// with the old unittests.
31class CapturingNetLog : public NetLog {
32 public:
33  struct CapturedEntry {
34    CapturedEntry(EventType type,
35                  const base::TimeTicks& time,
36                  Source source,
37                  EventPhase phase,
38                  scoped_ptr<base::DictionaryValue> params);
39    // Copy constructor needed to store in a std::vector because of the
40    // scoped_ptr.
41    CapturedEntry(const CapturedEntry& entry);
42
43    ~CapturedEntry();
44
45    // Equality operator needed to store in a std::vector because of the
46    // scoped_ptr.
47    CapturedEntry& operator=(const CapturedEntry& entry);
48
49    // Attempt to retrieve an value of the specified type with the given name
50    // from |params|.  Returns true on success, false on failure.  Does not
51    // modify |value| on failure.
52    bool GetStringValue(const std::string& name, std::string* value) const;
53    bool GetIntegerValue(const std::string& name, int* value) const;
54    bool GetListValue(const std::string& name, base::ListValue** value) const;
55
56    // Same as GetIntegerValue, but returns the error code associated with a
57    // log entry.
58    bool GetNetErrorCode(int* value) const;
59
60    // Returns the parameters as a JSON string, or empty string if there are no
61    // parameters.
62    std::string GetParamsJson() const;
63
64    EventType type;
65    base::TimeTicks time;
66    Source source;
67    EventPhase phase;
68    scoped_ptr<base::DictionaryValue> params;
69  };
70
71  // Ordered set of entries that were logged.
72  typedef std::vector<CapturedEntry> CapturedEntryList;
73
74  CapturingNetLog();
75  virtual ~CapturingNetLog();
76
77  void SetLogLevel(LogLevel log_level);
78
79  // Below methods are forwarded to capturing_net_log_observer_.
80  void GetEntries(CapturedEntryList* entry_list) const;
81  void GetEntriesForSource(Source source, CapturedEntryList* entry_list) const;
82  size_t GetSize() const;
83  void Clear();
84
85 private:
86  // Observer is an implementation of NetLog::ThreadSafeObserver
87  // that saves messages to a bounded buffer. It is intended for testing only,
88  // and is part of the net_test_support project.
89  class Observer : public NetLog::ThreadSafeObserver {
90   public:
91    Observer();
92    virtual ~Observer();
93
94    // Returns the list of all entries in the log.
95    void GetEntries(CapturedEntryList* entry_list) const;
96
97    // Fills |entry_list| with all entries in the log from the specified Source.
98    void GetEntriesForSource(Source source,
99                             CapturedEntryList* entry_list) const;
100
101    // Returns number of entries in the log.
102    size_t GetSize() const;
103
104    void Clear();
105
106   private:
107    // ThreadSafeObserver implementation:
108    virtual void OnAddEntry(const Entry& entry) OVERRIDE;
109
110    // Needs to be "mutable" so can use it in GetEntries().
111    mutable base::Lock lock_;
112
113    CapturedEntryList captured_entries_;
114
115    DISALLOW_COPY_AND_ASSIGN(Observer);
116  };
117
118  Observer capturing_net_log_observer_;
119
120  DISALLOW_COPY_AND_ASSIGN(CapturingNetLog);
121};
122
123// Helper class that exposes a similar API as BoundNetLog, but uses a
124// CapturingNetLog rather than the more generic NetLog.
125//
126// CapturingBoundNetLog can easily be converted to a BoundNetLog using the
127// bound() method.
128class CapturingBoundNetLog {
129 public:
130  CapturingBoundNetLog();
131  ~CapturingBoundNetLog();
132
133  // The returned BoundNetLog is only valid while |this| is alive.
134  BoundNetLog bound() const { return net_log_; }
135
136  // Fills |entry_list| with all entries in the log.
137  void GetEntries(CapturingNetLog::CapturedEntryList* entry_list) const;
138
139  // Fills |entry_list| with all entries in the log from the specified Source.
140  void GetEntriesForSource(
141      NetLog::Source source,
142      CapturingNetLog::CapturedEntryList* entry_list) const;
143
144  // Returns number of entries in the log.
145  size_t GetSize() const;
146
147  void Clear();
148
149  // Sets the log level of the underlying CapturingNetLog.
150  void SetLogLevel(NetLog::LogLevel log_level);
151
152 private:
153  CapturingNetLog capturing_net_log_;
154  const BoundNetLog net_log_;
155
156  DISALLOW_COPY_AND_ASSIGN(CapturingBoundNetLog);
157};
158
159}  // namespace net
160
161#endif  // NET_BASE_CAPTURING_NET_LOG_H_
162