Evaluate NetLog::Entry callbacks relative to each observers' log level.

Adjust a test to check this case. This doesn't handle cases where log events
only appear at a given log level because of external checks, but it will avoid
the bytes showing up everywhere.

BUG=348156

Review URL: https://codereview.chromium.org/183123006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@254671 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 32 insertions, 24 deletions

diff --git a/net/base/net_log.cc b/net/base/net_log.cc
index d1e9c98..dfd07f8 100644
--- a/net/base/net_log.cc
+++ b/net/base/net_log.cc
@@ -123,21 +123,21 @@ bool NetLog::Source::FromEventParameters(base::Value* event_params,
 base::Value* NetLog::Entry::ToValue() const {
   base::DictionaryValue* entry_dict(new base::DictionaryValue());
 
-  entry_dict->SetString("time", TickCountToString(time_));
+  entry_dict->SetString("time", TickCountToString(data_->time));
 
   // Set the entry source.
   base::DictionaryValue* source_dict = new base::DictionaryValue();
-  source_dict->SetInteger("id", source_.id);
-  source_dict->SetInteger("type", static_cast<int>(source_.type));
+  source_dict->SetInteger("id", data_->source.id);
+  source_dict->SetInteger("type", static_cast<int>(data_->source.type));
   entry_dict->Set("source", source_dict);
 
   // Set the event info.
-  entry_dict->SetInteger("type", static_cast<int>(type_));
-  entry_dict->SetInteger("phase", static_cast<int>(phase_));
+  entry_dict->SetInteger("type", static_cast<int>(data_->type));
+  entry_dict->SetInteger("phase", static_cast<int>(data_->phase));
 
   // Set the event-specific parameters.
-  if (parameters_callback_) {
-    base::Value* value = parameters_callback_->Run(log_level_);
+  if (data_->parameters_callback) {
+    base::Value* value = data_->parameters_callback->Run(log_level_);
     if (value)
       entry_dict->Set("params", value);
   }
@@ -146,25 +146,30 @@ base::Value* NetLog::Entry::ToValue() const {
 }
 
 base::Value* NetLog::Entry::ParametersToValue() const {
-  if (parameters_callback_)
-    return parameters_callback_->Run(log_level_);
+  if (data_->parameters_callback)
+    return data_->parameters_callback->Run(log_level_);
   return NULL;
 }
 
-NetLog::Entry::Entry(
+NetLog::EntryData::EntryData(
     EventType type,
     Source source,
     EventPhase phase,
     base::TimeTicks time,
-    const ParametersCallback* parameters_callback,
-    LogLevel log_level)
-    : type_(type),
-      source_(source),
-      phase_(phase),
-      time_(time),
-      parameters_callback_(parameters_callback),
-      log_level_(log_level) {
-};
+    const ParametersCallback* parameters_callback)
+    : type(type),
+      source(source),
+      phase(phase),
+      time(time),
+      parameters_callback(parameters_callback) {
+}
+
+NetLog::EntryData::~EntryData() {
+}
+
+NetLog::Entry::Entry(const EntryData* data, LogLevel log_level)
+    : data_(data), log_level_(log_level) {
+}
 
 NetLog::Entry::~Entry() {
 }
@@ -189,6 +194,10 @@ NetLog* NetLog::ThreadSafeObserver::net_log() const {
   return net_log_;
 }
 
+void NetLog::ThreadSafeObserver::OnAddEntryData(const EntryData& entry_data) {
+  OnAddEntry(Entry(&entry_data, log_level()));
+}
+
 NetLog::NetLog()
     : last_id_(0),
       base_log_level_(LOG_NONE),
@@ -383,15 +392,14 @@ void NetLog::AddEntry(EventType type,
                       const Source& source,
                       EventPhase phase,
                       const NetLog::ParametersCallback* parameters_callback) {
-  LogLevel log_level = GetLogLevel();
-  if (log_level == LOG_NONE)
+  if (GetLogLevel() == LOG_NONE)
     return;
-  Entry entry(type, source, phase, base::TimeTicks::Now(),
-              parameters_callback, log_level);
+  EntryData entry_data(type, source, phase, base::TimeTicks::Now(),
+                       parameters_callback);
 
   // Notify all of the log observers.
   base::AutoLock lock(lock_);
-  FOR_EACH_OBSERVER(ThreadSafeObserver, observers_, OnAddEntry(entry));
+  FOR_EACH_OBSERVER(ThreadSafeObserver, observers_, OnAddEntryData(entry_data));
 }
 
 void BoundNetLog::AddEntry(NetLog::EventType type,