This CL adds a NetLog observer, and uses the newly added

NESTABLE_ASYNC APIs
(https://codereview.chromium.org/536503002/) to log NetLog
entries in Tracing. This CL is a part of the effort to get
NetLog data into Tracing.

Design Doc:
https://docs.google.com/document/d/1Z2uqj59UEts5IiXX78mkdU4kd6e7kE3JUKPoDK97bVs/edit?usp=sharing

BUG=399701

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

Cr-Commit-Position: refs/heads/master@{#295089}

chrome/browser/net/chrome_net_log.cc

@@ -16,6 +16,7 @@
 #include "chrome/common/chrome_switches.h"
 #include "content/public/common/content_switches.h"
 #include "net/base/net_log_logger.h"
+#include "net/base/trace_net_log_observer.h"
 
 ChromeNetLog::ChromeNetLog()
     : net_log_temp_file_(new NetLogTempFile(this)) {
@@ -59,6 +60,9 @@ ChromeNetLog::ChromeNetLog()
       net_log_logger_->StartObserving(this);
     }
   }
+
+  trace_net_log_observer_.reset(new net::TraceNetLogObserver());
+  trace_net_log_observer_->WatchForTraceStart(this);
 }
 
 ChromeNetLog::~ChromeNetLog() {
@@ -66,5 +70,7 @@ ChromeNetLog::~ChromeNetLog() {
   // Remove the observers we own before we're destroyed.
   if (net_log_logger_)
     RemoveThreadSafeObserver(net_log_logger_.get());
+  if (trace_net_log_observer_)
+    trace_net_log_observer_->StopWatchForTraceStart();
 }
 

chrome/browser/net/chrome_net_log.h

@@ -13,6 +13,7 @@
 
 namespace net {
 class NetLogLogger;
+class TraceNetLogObserver;
 }
 
 class NetLogTempFile;
@@ -32,6 +33,8 @@ class ChromeNetLog : public net::NetLog {
   scoped_ptr<net::NetLogLogger> net_log_logger_;
   scoped_ptr<NetLogTempFile> net_log_temp_file_;
 
+  scoped_ptr<net::TraceNetLogObserver> trace_net_log_observer_;
+
   DISALLOW_COPY_AND_ASSIGN(ChromeNetLog);
 };
 

net/base/trace_net_log_observer.cc

+// Copyright 2014 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.
+
+#include "net/base/trace_net_log_observer.h"
+
+#include <stdio.h>
+
+#include <string>
+
+#include "base/debug/trace_event.h"
+#include "base/json/json_writer.h"
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/values.h"
+#include "net/base/net_log.h"
+
+namespace net {
+
+namespace {
+
+class TracedValue : public base::debug::ConvertableToTraceFormat {
+ public:
+  explicit TracedValue(scoped_ptr<base::Value> value) : value_(value.Pass()) {}
+
+ private:
+  virtual ~TracedValue() {}
+
+  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
+    if (value_) {
+      std::string tmp;
+      base::JSONWriter::Write(value_.get(), &tmp);
+      *out += tmp;
+    } else {
+      *out += "\"\"";
+    }
+  }
+
+ private:
+  scoped_ptr<base::Value> value_;
+};
+
+}  // namespace
+
+TraceNetLogObserver::TraceNetLogObserver() : net_log_to_watch_(NULL) {
+}
+
+TraceNetLogObserver::~TraceNetLogObserver() {
+  DCHECK(!net_log_to_watch_);
+  DCHECK(!net_log());
+}
+
+void TraceNetLogObserver::OnAddEntry(const NetLog::Entry& entry) {
+  scoped_ptr<base::Value> params(entry.ParametersToValue());
+  switch (entry.phase()) {
+    case NetLog::PHASE_BEGIN:
+      TRACE_EVENT_NESTABLE_ASYNC_BEGIN2(
+          "netlog", NetLog::EventTypeToString(entry.type()), entry.source().id,
+          "source_type", NetLog::SourceTypeToString(entry.source().type),
+          "params", scoped_refptr<base::debug::ConvertableToTraceFormat>(
+              new TracedValue(params.Pass())));
+      break;
+    case NetLog::PHASE_END:
+      TRACE_EVENT_NESTABLE_ASYNC_END2(
+          "netlog", NetLog::EventTypeToString(entry.type()), entry.source().id,
+          "source_type", NetLog::SourceTypeToString(entry.source().type),
+          "params", scoped_refptr<base::debug::ConvertableToTraceFormat>(
+              new TracedValue(params.Pass())));
+      break;
+    case NetLog::PHASE_NONE:
+      TRACE_EVENT_NESTABLE_ASYNC_INSTANT2(
+          "netlog", NetLog::EventTypeToString(entry.type()), entry.source().id,
+          "source_type", NetLog::SourceTypeToString(entry.source().type),
+          "params", scoped_refptr<base::debug::ConvertableToTraceFormat>(
+              new TracedValue(params.Pass())));
+      break;
+  }
+}
+
+void TraceNetLogObserver::WatchForTraceStart(NetLog* netlog) {
+  DCHECK(!net_log_to_watch_);
+  DCHECK(!net_log());
+  net_log_to_watch_ = netlog;
+  base::debug::TraceLog::GetInstance()->AddEnabledStateObserver(this);
+}
+
+void TraceNetLogObserver::StopWatchForTraceStart() {
+  // Should only stop if is currently watching.
+  DCHECK(net_log_to_watch_);
+  base::debug::TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
+  if (net_log())
+    net_log()->RemoveThreadSafeObserver(this);
+  net_log_to_watch_ = NULL;
+}
+
+void TraceNetLogObserver::OnTraceLogEnabled() {
+  net_log_to_watch_->AddThreadSafeObserver(this,
+                                           NetLog::LOG_STRIP_PRIVATE_DATA);
+}
+
+void TraceNetLogObserver::OnTraceLogDisabled() {
+  if (net_log())
+    net_log()->RemoveThreadSafeObserver(this);
+}
+
+}  // namespace net

net/base/trace_net_log_observer.h

+// Copyright 2014 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_TRACE_NET_LOG_OBSERVER_H_
+#define NET_BASE_TRACE_NET_LOG_OBSERVER_H_
+
+#include "base/debug/trace_event_impl.h"
+#include "base/macros.h"
+#include "net/base/net_export.h"
+#include "net/base/net_log.h"
+
+namespace net {
+
+// TraceNetLogObserver watches for TraceLog enable, and sends NetLog
+// events to TraceLog if it is enabled.
+class NET_EXPORT TraceNetLogObserver
+    : public NetLog::ThreadSafeObserver,
+      public base::debug::TraceLog::EnabledStateObserver {
+ public:
+  TraceNetLogObserver();
+  virtual ~TraceNetLogObserver();
+
+  // net::NetLog::ThreadSafeObserver implementation:
+  virtual void OnAddEntry(const NetLog::Entry& entry) OVERRIDE;
+
+  // Start to watch for TraceLog enable and disable events.
+  // This can't be called if already watching for events.
+  // Watches NetLog only when tracing is enabled.
+  void WatchForTraceStart(NetLog* net_log);
+
+  // Stop watching for TraceLog enable and disable events.
+  // If WatchForTraceStart is called, this must be called before
+  // TraceNetLogObserver is destroyed.
+  void StopWatchForTraceStart();
+
+  // base::debug::TraceLog::EnabledStateChangedObserver implementation:
+  virtual void OnTraceLogEnabled() OVERRIDE;
+  virtual void OnTraceLogDisabled() OVERRIDE;
+
+ private:
+  NetLog* net_log_to_watch_;
+
+  DISALLOW_COPY_AND_ASSIGN(TraceNetLogObserver);
+};
+
+}  // namespace net
+
+#endif  // NET_BASE_TRACE_NET_LOG_OBSERVER_H_

net/net.gypi

@@ -270,6 +270,8 @@
       'base/static_cookie_policy.h',
       'base/test_data_stream.cc',
       'base/test_data_stream.h',
+      'base/trace_net_log_observer.cc',
+      'base/trace_net_log_observer.h',
       'base/upload_bytes_element_reader.cc',
       'base/upload_bytes_element_reader.h',
       'base/upload_data_stream.cc',
@@ -1278,6 +1280,7 @@
       'base/sdch_manager_unittest.cc',
       'base/static_cookie_policy_unittest.cc',
       'base/test_completion_callback_unittest.cc',
+      'base/trace_net_log_observer_unittest.cc',
       'base/upload_bytes_element_reader_unittest.cc',
       'base/upload_data_stream_unittest.cc',
       'base/upload_file_element_reader_unittest.cc',