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 20 namespace base { 21 class DictionaryValue; 22 class ListValue; 23 } 24 25 namespace 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. 31 class 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. 128 class CapturingBoundNetLog { 129 public: 130 CapturingBoundNetLog(); 131 ~CapturingBoundNetLog(); 132 133 // The returned BoundNetLog is only valid while |this| is alive. bound()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