Add fine grain tracing to HostResolverImpl....

net/url_request/url_request_view_net_internals_job.cc

 // Copyright (c) 2009 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/url_request/url_request_view_net_internals_job.h"
 
 #include <sstream>
 
 #include "base/format_macros.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "net/base/escape.h"
-#include "net/base/host_cache.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_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/view_cache_helper.h"
 
@@ skipping 15 matching lines @@
 // string |command| back to the browser, and then refreshes the page.
 void DrawCommandButton(const std::string& title,
                        const std::string& command,
                        std::string* data) {
   StringAppendF(data, "<input type=\"button\" value=\"%s\" "
                "onclick=\"DoCommand('%s')\" />",
                title.c_str(),
                command.c_str());
 }
 
+//------------------------------------------------------------------------------
+// URLRequestContext helpers.
+//------------------------------------------------------------------------------
+
+net::HostResolverImpl* GetHostResolverImpl(URLRequestContext* context) {
+  if (context->host_resolver()->IsHostResolverImpl())
+    return static_cast<net::HostResolverImpl*> (context->host_resolver());
+  return NULL;
+}
+
+net::HostCache* GetHostCache(URLRequestContext* context) {
+  if (GetHostResolverImpl(context))
+    return GetHostResolverImpl(context)->cache();
+  return NULL;
+}
 
 //------------------------------------------------------------------------------
 // Subsection definitions.
 //------------------------------------------------------------------------------
 
 class SubSection {
  public:
   // |name| is the URL path component for this subsection.
   // |title| is the textual description.
   SubSection(SubSection* parent, const char* name, const char* title)
@@ skipping 91 matching lines @@
 
   SubSection* parent_;
   std::string name_;
   std::string title_;
 
   SubSectionList children_;
 };
 
 class ProxyServiceCurrentConfigSubSection : public SubSection {
  public:
-  ProxyServiceCurrentConfigSubSection(SubSection* parent)
+  explicit ProxyServiceCurrentConfigSubSection(SubSection* parent)
       : SubSection(parent, "config", "Current configuration") {
   }
 
   virtual void OutputBody(URLRequestContext* context, std::string* out) {
     DrawCommandButton("Force reload", "reload-proxy-config", out);
 
     net::ProxyService* proxy_service = context->proxy_service();
     if (proxy_service->config_has_been_initialized()) {
       // net::ProxyConfig defines an operator<<.
       std::ostringstream stream;
       stream << proxy_service->config();
       OutputTextInPre(stream.str(), out);
     } else {
       out->append("<i>Not yet initialized</i>");
     }
   }
 };
 
 class ProxyServiceLastInitLogSubSection : public SubSection {
  public:
-  ProxyServiceLastInitLogSubSection(SubSection* parent)
+  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>");
     }
   }
 };
 
 class ProxyServiceBadProxiesSubSection : public SubSection {
  public:
-  ProxyServiceBadProxiesSubSection(SubSection* parent)
+  explicit ProxyServiceBadProxiesSubSection(SubSection* parent)
       : SubSection(parent, "bad_proxies", "Bad Proxies") {
   }
 
   virtual void OutputBody(URLRequestContext* context, std::string* out) {
     net::ProxyService* proxy_service = context->proxy_service();
     const net::ProxyRetryInfoMap& bad_proxies_map =
         proxy_service->proxy_retry_info();
 
     DrawCommandButton("Clear", "clear-badproxies", out);
 
@@ skipping 22 matching lines @@
                     ttl_ms);
 
       out->append("</tr>");
     }
     out->append("</table>");
   }
 };
 
 class ProxyServiceSubSection : public SubSection {
  public:
-  ProxyServiceSubSection(SubSection* parent)
+  explicit ProxyServiceSubSection(SubSection* parent)
       : SubSection(parent, "proxyservice", "ProxyService") {
     AddSubSection(new ProxyServiceCurrentConfigSubSection(this));
     AddSubSection(new ProxyServiceLastInitLogSubSection(this));
     AddSubSection(new ProxyServiceBadProxiesSubSection(this));
   }
 };
 
 class HostResolverCacheSubSection : public SubSection {
  public:
-  HostResolverCacheSubSection(SubSection* parent)
+  explicit HostResolverCacheSubSection(SubSection* parent)
       : SubSection(parent, "hostcache", "HostCache") {
   }
 
   virtual void OutputBody(URLRequestContext* context, std::string* out) {
-    const net::HostCache* host_cache = context->host_resolver()->GetHostCache();
+    const net::HostCache* host_cache = GetHostCache(context);
 
     if (!host_cache || host_cache->caching_is_disabled()) {
       out->append("<i>Caching is disabled.</i>");
       return;
     }
 
     DrawCommandButton("Clear", "clear-hostcache", out);
 
     StringAppendF(
         out,
@@ skipping 75 matching lines @@
         return "IPV6";
       case net::ADDRESS_FAMILY_UNSPECIFIED:
         return "UNSPECIFIED";
       default:
         NOTREACHED();
         return "???";
     }
   }
 };
 
+class HostResolverTraceSubSection : public SubSection {
+ public:
+  explicit HostResolverTraceSubSection(SubSection* parent)
+      : SubSection(parent, "trace", "Trace of requests") {
+  }
+
+  virtual void OutputBody(URLRequestContext* context, std::string* out) {
+    net::HostResolverImpl* resolver = GetHostResolverImpl(context);
+    if (!resolver) {
+      out->append("<i>Tracing is not supported by this resolver.</i>");
+      return;
+    }
+
+    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) {
+      OutputTextInPre(net::LoadLogUtil::PrettyPrintAsEventTree(log), out);
+    } else {
+      out->append("<p><i>No trace information, must enable tracing.</i></p>");
+    }
+  }
+};
+
 class HostResolverSubSection : public SubSection {
  public:
-  HostResolverSubSection(SubSection* parent)
+  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,
                          std::string* out) {
   out->append("<li>");
   out->append("<nobr>");
   out->append(EscapeForHTML(url.possibly_invalid_spec()));
   out->append("</nobr>");
   if (log)
     OutputTextInPre(net::LoadLogUtil::PrettyPrintAsEventTree(log), out);
   out->append("</li>");
 }
 
 class URLRequestLiveSubSection : public SubSection {
  public:
-  URLRequestLiveSubSection(SubSection* parent)
+  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();
 
     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);
     }
     out->append("</ol>");
   }
 };
 
 class URLRequestRecentSubSection : public SubSection {
  public:
-  URLRequestRecentSubSection(SubSection* parent)
+  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();
 
     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);
     }
     out->append("</ol>");
   }
 };
 
 class URLRequestSubSection : public SubSection {
  public:
-  URLRequestSubSection(SubSection* parent)
+  explicit URLRequestSubSection(SubSection* parent)
       : SubSection(parent, "urlrequest", "URLRequest") {
     AddSubSection(new URLRequestLiveSubSection(this));
     AddSubSection(new URLRequestRecentSubSection(this));
   }
 };
 
 class HttpCacheStatsSubSection : public SubSection {
  public:
-  HttpCacheStatsSubSection(SubSection* parent)
+  explicit HttpCacheStatsSubSection(SubSection* parent)
       : SubSection(parent, "stats", "Statistics") {
   }
 
   virtual void OutputBody(URLRequestContext* context, std::string* out) {
     ViewCacheHelper::GetStatisticsHTML(context, out);
   }
 };
 
 class HttpCacheSection : public SubSection {
  public:
-  HttpCacheSection(SubSection* parent)
+  explicit HttpCacheSection(SubSection* parent)
       : SubSection(parent, "httpcache", "HttpCache") {
     AddSubSection(new HttpCacheStatsSubSection(this));
   }
 
   virtual void OutputBody(URLRequestContext* context, std::string* out) {
     // Advertise the view-cache URL (too much data to inline it).
     out->append("<p><a href='/");
     out->append(kViewHttpCacheSubPath);
     out->append("'>View all cache entries</a></p>");
   }
 };
 
 class SocketStreamLiveSubSection : public SubSection {
  public:
-  SocketStreamLiveSubSection(SubSection* parent)
+  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();
 
     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);
     }
     out->append("</ol>");
   }
 };
 
 class SocketStreamRecentSubSection : public SubSection {
  public:
-  SocketStreamRecentSubSection(SubSection* parent)
+  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();
 
     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);
     }
     out->append("</ol>");
   }
 };
 
 class SocketStreamSubSection : public SubSection {
  public:
-  SocketStreamSubSection(SubSection* parent)
+  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) {
   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);
     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();
     return true;
   }
 
   if (command == "clear-socketstream-graveyard") {
     context->socket_stream_tracker()->ClearRecentlyDeceased();
     return true;
   }
 
   if (command == "clear-hostcache") {
-    net::HostCache* host_cache = context->host_resolver()->GetHostCache();
+    net::HostCache* host_cache = GetHostCache(context);
     if (host_cache)
       host_cache->clear();
     return true;
   }
 
   if (command == "clear-badproxies") {
     context->proxy_service()->ClearBadProxiesCache();
     return true;
   }
 
+  if (command == "clear-hostresolver-trace") {
+    if (GetHostResolverImpl(context))
+      GetHostResolverImpl(context)->ClearRequestsTrace();
+  }
+
   if (command == "reload-proxy-config") {
     context->proxy_service()->ForceReloadProxyConfig();
     return true;
   }
 
   return false;
 }
 
 // Process any query strings in the request (for actions like toggling
 // full logging.
@@ skipping 28 matching lines @@
     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-socketstream-graveyard,"
+                    "clear-hostresolver-trace",
                     data);
 
   data->append("</div>");
 }
 
 }  // namespace
 
 bool URLRequestViewNetInternalsJob::GetData(std::string* mime_type,
                                             std::string* charset,
                                             std::string* data) const {
@@ skipping 94 matching lines @@
 
   if (path.size() > strlen(kViewHttpCacheSubPath) &&
       path[strlen(kViewHttpCacheSubPath)] != '/')
     return false;
 
   if (key && path.size() > strlen(kViewHttpCacheSubPath) + 1)
     *key = path.substr(strlen(kViewHttpCacheSubPath) + 1);
 
   return true;
 }