Generalize the net module's LoadLog facility from a passive container, to an event stream (NetLog).

chrome/browser/net/view_net_internals_job_factory.cc

 // Copyright (c) 2010 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 "chrome/browser/net/view_net_internals_job_factory.h"
 
 #include <sstream>
 
 #include "base/format_macros.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
+#include "chrome/browser/net/chrome_net_log.h"
+#include "chrome/browser/net/chrome_url_request_context.h"
+#include "chrome/browser/net/passive_log_collector.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/escape.h"
 #include "net/base/host_resolver_impl.h"
-#include "net/base/load_log_util.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_log_util.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket_stream/socket_stream.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_simple_job.h"
 #include "net/url_request/view_cache_helper.h"
 
 namespace {
 
 const char kViewHttpCacheSubPath[] = "view-cache";
 
+PassiveLogCollector* GetPassiveLogCollector(URLRequestContext* context) {
+  // Really this is the same as:
+  // g_browser_process->io_thread()->globals()->
+  //     net_log.get()
+  // (But we can't access g_browser_process from the IO thread).
+  ChromeNetLog* chrome_net_log = static_cast<ChromeNetLog*>(
+      static_cast<ChromeURLRequestContext*>(context)->net_log());
+  return chrome_net_log->passive_collector();
+}
+
+PassiveLogCollector::RequestTracker* GetURLRequestTracker(
+    URLRequestContext* context) {
+  return GetPassiveLogCollector(context)->url_request_tracker();
+}
+
+PassiveLogCollector::RequestTracker* GetSocketStreamTracker(
+    URLRequestContext* context) {
+  return GetPassiveLogCollector(context)->socket_stream_tracker();
+}
+
 std::string GetDetails(const GURL& url) {
   DCHECK(ViewNetInternalsJobFactory::IsSupportedURL(url));
   size_t start = strlen(chrome::kNetworkViewInternalsURL);
   if (start >= url.spec().size())
     return std::string();
   return url.spec().substr(start);
 }
 
 GURL MakeURL(const std::string& details) {
   return GURL(std::string(chrome::kNetworkViewInternalsURL) + details);
@@ skipping 185 matching lines @@
 };
 
 class ProxyServiceLastInitLogSubSection : public SubSection {
  public:
   explicit ProxyServiceLastInitLogSubSection(SubSection* parent)
       : SubSection(parent, "init_log", "Last initialized load log") {
   }
 
   virtual void OutputBody(URLRequestContext* context, std::string* out) {
     net::ProxyService* proxy_service = context->proxy_service();
-    net::LoadLog* log = proxy_service->init_proxy_resolver_log();
-    if (log) {
-      OutputTextInPre(net::LoadLogUtil::PrettyPrintAsEventTree(log), out);
-    } else {
-      out->append("<i>None.</i>");
-    }
+    OutputTextInPre(net::NetLogUtil::PrettyPrintAsEventTree(
+        proxy_service->init_proxy_resolver_log().entries(), 0), out);
   }
 };
 
 class ProxyServiceBadProxiesSubSection : public SubSection {
  public:
   explicit ProxyServiceBadProxiesSubSection(SubSection* parent)
       : SubSection(parent, "bad_proxies", "Bad Proxies") {
   }
 
   virtual void OutputBody(URLRequestContext* context, std::string* out) {
@@ skipping 160 matching lines @@
     }
 
     DrawCommandButton("Clear", "clear-hostresolver-trace", out);
 
     if (resolver->IsRequestsTracingEnabled()) {
       DrawCommandButton("Disable tracing", "hostresolver-trace-disable", out);
     } else {
       DrawCommandButton("Enable tracing", "hostresolver-trace-enable", out);
     }
 
-    scoped_refptr<net::LoadLog> log = resolver->GetRequestsTrace();
-
-    if (log) {
+    std::vector<net::NetLog::Entry> entries;
+    if (resolver->GetRequestsTrace(&entries)) {
       out->append(
           "<p>To make sense of this trace, process it with the Python script "
           "formatter.py at "
           "<a href='http://src.chromium.org/viewvc/chrome/trunk/src/net/tools/"
           "dns_trace_formatter/'>net/tools/dns_trace_formatter</a></p>");
-      OutputTextInPre(net::LoadLogUtil::PrettyPrintAsEventTree(log), out);
+      OutputTextInPre(net::NetLogUtil::PrettyPrintAsEventTree(entries, 0),
+                      out);
     } else {
       out->append("<p><i>No trace information, must enable tracing.</i></p>");
     }
   }
 };
 
 class HostResolverSubSection : public SubSection {
  public:
   explicit HostResolverSubSection(SubSection* parent)
       : SubSection(parent, "hostresolver", "HostResolver") {
     AddSubSection(new HostResolverCacheSubSection(this));
     AddSubSection(new HostResolverTraceSubSection(this));
   }
 };
 
 // Helper for the URLRequest "outstanding" and "live" sections.
-void OutputURLAndLoadLog(const GURL& url,
-                         const net::LoadLog* log,
+void OutputURLAndLoadLog(const PassiveLogCollector::RequestInfo& request,
                          std::string* out) {
   out->append("<li>");
   out->append("<nobr>");
-  out->append(EscapeForHTML(url.possibly_invalid_spec()));
+  out->append(EscapeForHTML(request.url));
   out->append("</nobr>");
-  if (log)
-    OutputTextInPre(net::LoadLogUtil::PrettyPrintAsEventTree(log), out);
+  OutputTextInPre(
+      net::NetLogUtil::PrettyPrintAsEventTree(
+          request.entries,
+          request.num_entries_truncated),
+      out);
   out->append("</li>");
 }
 
 class URLRequestLiveSubSection : public SubSection {
  public:
   explicit URLRequestLiveSubSection(SubSection* parent)
       : SubSection(parent, "outstanding", "Outstanding requests") {
   }
 
   virtual void OutputBody(URLRequestContext* context, std::string* out) {
-    std::vector<URLRequest*> requests =
-        context->url_request_tracker()->GetLiveRequests();
+    PassiveLogCollector::RequestInfoList requests =
+        GetURLRequestTracker(context)->GetLiveRequests();
 
     out->append("<ol>");
     for (size_t i = 0; i < requests.size(); ++i) {
       // Reverse the list order, so we dispay from most recent to oldest.
       size_t index = requests.size() - i - 1;
-      OutputURLAndLoadLog(requests[index]->original_url(),
-                          requests[index]->load_log(),
-                          out);
+      OutputURLAndLoadLog(requests[index], out);
     }
     out->append("</ol>");
   }
 };
 
 class URLRequestRecentSubSection : public SubSection {
  public:
   explicit URLRequestRecentSubSection(SubSection* parent)
       : SubSection(parent, "recent", "Recently completed requests") {
   }
 
   virtual void OutputBody(URLRequestContext* context, std::string* out) {
-    RequestTracker<URLRequest>::RecentRequestInfoList recent =
-        context->url_request_tracker()->GetRecentlyDeceased();
+    PassiveLogCollector::RequestInfoList recent =
+        GetURLRequestTracker(context)->GetRecentlyDeceased();
 
     DrawCommandButton("Clear", "clear-urlrequest-graveyard", out);
 
     out->append("<ol>");
     for (size_t i = 0; i < recent.size(); ++i) {
       // Reverse the list order, so we dispay from most recent to oldest.
       size_t index = recent.size() - i - 1;
-      OutputURLAndLoadLog(recent[index].original_url,
-                          recent[index].load_log, out);
+      OutputURLAndLoadLog(recent[index], out);
     }
     out->append("</ol>");
   }
 };
 
 class URLRequestSubSection : public SubSection {
  public:
   explicit URLRequestSubSection(SubSection* parent)
       : SubSection(parent, "urlrequest", "URLRequest") {
     AddSubSection(new URLRequestLiveSubSection(this));
@@ skipping 27 matching lines @@
   }
 };
 
 class SocketStreamLiveSubSection : public SubSection {
  public:
   explicit SocketStreamLiveSubSection(SubSection* parent)
       : SubSection(parent, "live", "Live SocketStreams") {
   }
 
   virtual void OutputBody(URLRequestContext* context, std::string* out) {
-    std::vector<net::SocketStream*> sockets =
-        context->socket_stream_tracker()->GetLiveRequests();
+    PassiveLogCollector::RequestInfoList sockets =
+        GetSocketStreamTracker(context)->GetLiveRequests();
 
     out->append("<ol>");
     for (size_t i = 0; i < sockets.size(); ++i) {
       // Reverse the list order, so we dispay from most recent to oldest.
       size_t index = sockets.size() - i - 1;
-      OutputURLAndLoadLog(sockets[index]->url(),
-                          sockets[index]->load_log(),
-                          out);
+      OutputURLAndLoadLog(sockets[index], out);
     }
     out->append("</ol>");
   }
 };
 
 class SocketStreamRecentSubSection : public SubSection {
  public:
   explicit SocketStreamRecentSubSection(SubSection* parent)
       : SubSection(parent, "recent", "Recently completed SocketStreams") {
   }
 
   virtual void OutputBody(URLRequestContext* context, std::string* out) {
-    RequestTracker<net::SocketStream>::RecentRequestInfoList recent =
-        context->socket_stream_tracker()->GetRecentlyDeceased();
+    PassiveLogCollector::RequestInfoList recent =
+    GetSocketStreamTracker(context)->GetRecentlyDeceased();
 
     DrawCommandButton("Clear", "clear-socketstream-graveyard", out);
 
     out->append("<ol>");
     for (size_t i = 0; i < recent.size(); ++i) {
       // Reverse the list order, so we dispay from most recent to oldest.
       size_t index = recent.size() - i - 1;
-      OutputURLAndLoadLog(recent[index].original_url,
-                          recent[index].load_log, out);
+      OutputURLAndLoadLog(recent[index], out);
     }
     out->append("</ol>");
   }
 };
 
 class SocketStreamSubSection : public SubSection {
  public:
   explicit SocketStreamSubSection(SubSection* parent)
       : SubSection(parent, "socketstream", "SocketStream") {
     AddSubSection(new SocketStreamLiveSubSection(this));
     AddSubSection(new SocketStreamRecentSubSection(this));
   }
 };
 
 class AllSubSections : public SubSection {
  public:
   AllSubSections() : SubSection(NULL, "", "") {
     AddSubSection(new ProxyServiceSubSection(this));
     AddSubSection(new HostResolverSubSection(this));
     AddSubSection(new URLRequestSubSection(this));
     AddSubSection(new HttpCacheSection(this));
     AddSubSection(new SocketStreamSubSection(this));
   }
 };
 
-bool HandleCommand(const std::string& command, URLRequestContext* context) {
+bool HandleCommand(const std::string& command,
+                   URLRequestContext* context) {
   if (StartsWithASCII(command, "full-logging-", true)) {
     bool enable_full_logging = (command == "full-logging-enable");
-    context->url_request_tracker()->SetUnbounded(enable_full_logging);
-    context->socket_stream_tracker()->SetUnbounded(enable_full_logging);
+    GetURLRequestTracker(context)->SetUnbounded(enable_full_logging);
+    GetSocketStreamTracker(context)->SetUnbounded(enable_full_logging);
     return true;
   }
 
   if (StartsWithASCII(command, "hostresolver-trace-", true)) {
     bool enable_tracing = (command == "hostresolver-trace-enable");
     if (GetHostResolverImpl(context)) {
       GetHostResolverImpl(context)->EnableRequestsTracing(enable_tracing);
     }
   }
 
   if (command == "clear-urlrequest-graveyard") {
-    context->url_request_tracker()->ClearRecentlyDeceased();
+    GetURLRequestTracker(context)->ClearRecentlyDeceased();
     return true;
   }
 
   if (command == "clear-socketstream-graveyard") {
-    context->socket_stream_tracker()->ClearRecentlyDeceased();
+    GetSocketStreamTracker(context)->ClearRecentlyDeceased();
     return true;
   }
 
   if (command == "clear-hostcache") {
     net::HostCache* host_cache = GetHostCache(context);
     if (host_cache)
       host_cache->clear();
     return true;
   }
 
@@ skipping 32 matching lines @@
   SplitString(commands_str, ',', &commands);
 
   for (size_t i = 0; i < commands.size(); ++i)
     HandleCommand(commands[i], context);
 }
 
 // Appends some HTML controls to |data| that allow the user to enable full
 // logging, and clear some of the already logged data.
 void DrawControlsHeader(URLRequestContext* context, std::string* data) {
   bool is_full_logging_enabled =
-      context->url_request_tracker()->IsUnbounded() &&
-      context->socket_stream_tracker()->IsUnbounded();
+      GetURLRequestTracker(context)->IsUnbounded() &&
+      GetSocketStreamTracker(context)->IsUnbounded();
 
   data->append("<div style='margin-bottom: 10px'>");
 
   if (is_full_logging_enabled) {
     DrawCommandButton("Disable full logging", "full-logging-disable", data);
   } else {
     DrawCommandButton("Enable full logging", "full-logging-enable", data);
   }
 
   DrawCommandButton("Clear all data",
                     // Send a list of comma separated commands:
                     "clear-badproxies,"
                     "clear-hostcache,"
                     "clear-urlrequest-graveyard,"
                     "clear-socketstream-graveyard,"
                     "clear-hostresolver-trace",
                     data);
 
   data->append("</div>");
 }
 
 bool ViewNetInternalsJob::GetData(std::string* mime_type,
                                   std::string* charset,
                                   std::string* data) const {
   mime_type->assign("text/html");
   charset->assign("UTF-8");
 
-  URLRequestContext* context = request_->context();
+  URLRequestContext* context =
+      static_cast<URLRequestContext*>(request_->context());
 
   data->clear();
 
   // Use a different handler for "view-cache/*" subpaths.
   std::string cache_key;
   if (GetViewCacheKeyForRequest(&cache_key)) {
     GURL url = MakeURL(kViewHttpCacheSubPath + std::string("/"));
     ViewCacheHelper::GetEntryInfoHTML(cache_key, context, url.spec(), data);
     return true;
   }
@@ skipping 96 matching lines @@
   return StartsWithASCII(url.spec(),
                          chrome::kNetworkViewInternalsURL,
                          true /*case_sensitive*/);
 }
 
 // static
 URLRequestJob* ViewNetInternalsJobFactory::CreateJobForRequest(
     URLRequest* request) {
   return new ViewNetInternalsJob(request);
 }