net/base/capturing_net_log.cc

   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 #include "net/base/capturing_net_log.h"
   6
   7 #include "base/json/json_writer.h"
   8 #include "base/logging.h"
   9 #include "base/values.h"
  10
  11 namespace net {
  12
  13 CapturingNetLog::CapturedEntry::CapturedEntry(
  14     EventType type,
  15     const base::TimeTicks& time,
  16     Source source,
  17     EventPhase phase,
  18     scoped_ptr<base::DictionaryValue> params)
  19     : type(type),
  20       time(time),
  21       source(source),
  22       phase(phase),
  23       params(params.Pass()) {
  24 }
  25
  26 CapturingNetLog::CapturedEntry::CapturedEntry(const CapturedEntry& entry) {
  27   *this = entry;
  28 }
  29
  30 CapturingNetLog::CapturedEntry::~CapturedEntry() {}
  31
  32 CapturingNetLog::CapturedEntry&
  33 CapturingNetLog::CapturedEntry::operator=(const CapturedEntry& entry) {
  34   type = entry.type;
  35   time = entry.time;
  36   source = entry.source;
  37   phase = entry.phase;
  38   params.reset(entry.params ? entry.params->DeepCopy() : NULL);
  39   return *this;
  40 }
  41
  42 bool CapturingNetLog::CapturedEntry::GetStringValue(
  43     const std::string& name,
  44     std::string* value) const {
  45   if (!params)
  46     return false;
  47   return params->GetString(name, value);
  48 }
  49
  50 bool CapturingNetLog::CapturedEntry::GetIntegerValue(
  51     const std::string& name,
  52     int* value) const {
  53   if (!params)
  54     return false;
  55   return params->GetInteger(name, value);
  56 }
  57
  58 bool CapturingNetLog::CapturedEntry::GetListValue(
  59     const std::string& name,
  60     base::ListValue** value) const {
  61   if (!params)
  62     return false;
  63   return params->GetList(name, value);
  64 }
  65
  66 bool CapturingNetLog::CapturedEntry::GetNetErrorCode(int* value) const {
  67   return GetIntegerValue("net_error", value);
  68 }
  69
  70 std::string CapturingNetLog::CapturedEntry::GetParamsJson() const {
  71   if (!params)
  72     return std::string();
  73   std::string json;
  74   base::JSONWriter::Write(params.get(), &json);
  75   return json;
  76 }
  77
  78 CapturingNetLog::Observer::Observer() {}
  79
  80 CapturingNetLog::Observer::~Observer() {}
  81
  82 void CapturingNetLog::Observer::GetEntries(
  83     CapturedEntryList* entry_list) const {
  84   base::AutoLock lock(lock_);
  85   *entry_list = captured_entries_;
  86 }
  87
  88 void CapturingNetLog::Observer::GetEntriesForSource(
  89     NetLog::Source source,
  90     CapturedEntryList* entry_list) const {
  91   base::AutoLock lock(lock_);
  92   entry_list->clear();
  93   for (CapturedEntryList::const_iterator entry = captured_entries_.begin();
  94        entry != captured_entries_.end(); ++entry) {
  95     if (entry->source.id == source.id)
  96       entry_list->push_back(*entry);
  97   }
  98 }
  99
 100 size_t CapturingNetLog::Observer::GetSize() const {
 101   base::AutoLock lock(lock_);
 102   return captured_entries_.size();
 103 }
 104
 105 void CapturingNetLog::Observer::Clear() {
 106   base::AutoLock lock(lock_);
 107   captured_entries_.clear();
 108 }
 109
 110 void CapturingNetLog::Observer::OnAddEntry(const net::NetLog::Entry& entry) {
 111   // Only BoundNetLogs without a NetLog should have an invalid source.
 112   CHECK(entry.source().IsValid());
 113
 114   // Using Dictionaries instead of Values makes checking values a little
 115   // simpler.
 116   base::DictionaryValue* param_dict = NULL;
 117   base::Value* param_value = entry.ParametersToValue();
 118   if (param_value && !param_value->GetAsDictionary(&param_dict))
 119     delete param_value;
 120
 121   // Only need to acquire the lock when accessing class variables.
 122   base::AutoLock lock(lock_);
 123   captured_entries_.push_back(
 124       CapturedEntry(entry.type(),
 125                     base::TimeTicks::Now(),
 126                     entry.source(),
 127                     entry.phase(),
 128                     scoped_ptr<base::DictionaryValue>(param_dict)));
 129 }
 130
 131 CapturingNetLog::CapturingNetLog() {
 132   AddThreadSafeObserver(&capturing_net_log_observer_, LOG_ALL_BUT_BYTES);
 133 }
 134
 135 CapturingNetLog::~CapturingNetLog() {
 136   RemoveThreadSafeObserver(&capturing_net_log_observer_);
 137 }
 138
 139 void CapturingNetLog::SetLogLevel(NetLog::LogLevel log_level) {
 140   SetObserverLogLevel(&capturing_net_log_observer_, log_level);
 141 }
 142
 143 void CapturingNetLog::GetEntries(
 144     CapturingNetLog::CapturedEntryList* entry_list) const {
 145   capturing_net_log_observer_.GetEntries(entry_list);
 146 }
 147
 148 void CapturingNetLog::GetEntriesForSource(
 149     NetLog::Source source,
 150     CapturedEntryList* entry_list) const {
 151   capturing_net_log_observer_.GetEntriesForSource(source, entry_list);
 152 }
 153
 154 size_t CapturingNetLog::GetSize() const {
 155   return capturing_net_log_observer_.GetSize();
 156 }
 157
 158 void CapturingNetLog::Clear() {
 159   capturing_net_log_observer_.Clear();
 160 }
 161
 162 CapturingBoundNetLog::CapturingBoundNetLog()
 163     : net_log_(BoundNetLog::Make(&capturing_net_log_,
 164                                  net::NetLog::SOURCE_NONE)) {
 165 }
 166
 167 CapturingBoundNetLog::~CapturingBoundNetLog() {}
 168
 169 void CapturingBoundNetLog::GetEntries(
 170     CapturingNetLog::CapturedEntryList* entry_list) const {
 171   capturing_net_log_.GetEntries(entry_list);
 172 }
 173
 174 void CapturingBoundNetLog::GetEntriesForSource(
 175     NetLog::Source source,
 176     CapturingNetLog::CapturedEntryList* entry_list) const {
 177   capturing_net_log_.GetEntriesForSource(source, entry_list);
 178 }
 179
 180 size_t CapturingBoundNetLog::GetSize() const {
 181   return capturing_net_log_.GetSize();
 182 }
 183
 184 void CapturingBoundNetLog::Clear() {
 185   capturing_net_log_.Clear();
 186 }
 187
 188 void CapturingBoundNetLog::SetLogLevel(NetLog::LogLevel log_level) {
 189   capturing_net_log_.SetLogLevel(log_level);
 190 }
 191
 192 }  // namespace net