Add the host resolver cache to the new net internals page.

chrome/browser/dom_ui/net_internals_ui.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/dom_ui/net_internals_ui.h"
 
 #include <sstream>
 
 #include "app/resource_bundle.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/singleton.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/dom_ui/chrome_url_data_manager.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/url_request_context_getter.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/escape.h"
+#include "net/base/host_resolver_impl.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/url_request/url_request_context.h"
 
 namespace {
 
 // Formats |t| as a decimal number, in milliseconds.
 std::string TickCountToString(const base::TimeTicks& t) {
   return Int64ToString((t - base::TimeTicks()).InMilliseconds());
 }
 
+// Returns the HostCache for |context|'s primary HostResolver, or NULL if
+// there is none.
+net::HostCache* GetHostResolverCache(URLRequestContext* context) {
+  net::HostResolverImpl* host_resolver_impl =
+      context->host_resolver()->GetAsHostResolverImpl();
+
+  if (!host_resolver_impl)
+    return NULL;
+
+  return host_resolver_impl->cache();
+}
+
 // TODO(eroman): Bootstrap the net-internals page using the passively logged
 //               data.
 
 class NetInternalsHTMLSource : public ChromeURLDataManager::DataSource {
  public:
   NetInternalsHTMLSource();
 
   // Called when the network layer has requested a resource underneath
   // the path we registered.
   virtual void StartDataRequest(const std::string& path,
@@ skipping 79 matching lines @@
   //--------------------------------
 
   // This message is called after the webpage's onloaded handler has fired.
   // it indicates that the renderer is ready to start receiving captured data.
   void OnRendererReady(const Value* value);
 
   void OnGetProxySettings(const Value* value);
   void OnReloadProxySettings(const Value* value);
   void OnGetBadProxies(const Value* value);
   void OnClearBadProxies(const Value* value);
+  void OnGetHostResolverCache(const Value* value);
+  void OnClearHostResolverCache(const Value* value);
 
   // ChromeNetLog::Observer implementation:
   virtual void OnAddEntry(const net::NetLog::Entry& entry);
 
  private:
   class CallbackHelper;
 
   // Helper that runs |method| with |arg|, and deletes |arg| on completion.
   void DispatchToMessageHandler(Value* arg, MessageHandler method);
 
@@ skipping 127 matching lines @@
   dom_ui_->RegisterMessageCallback("notifyReady",
       proxy_->CreateCallback(&IOThreadImpl::OnRendererReady));
   dom_ui_->RegisterMessageCallback("getProxySettings",
       proxy_->CreateCallback(&IOThreadImpl::OnGetProxySettings));
   dom_ui_->RegisterMessageCallback("reloadProxySettings",
       proxy_->CreateCallback(&IOThreadImpl::OnReloadProxySettings));
   dom_ui_->RegisterMessageCallback("getBadProxies",
       proxy_->CreateCallback(&IOThreadImpl::OnGetBadProxies));
   dom_ui_->RegisterMessageCallback("clearBadProxies",
       proxy_->CreateCallback(&IOThreadImpl::OnClearBadProxies));
+  dom_ui_->RegisterMessageCallback("getHostResolverCache",
+      proxy_->CreateCallback(&IOThreadImpl::OnGetHostResolverCache));
+  dom_ui_->RegisterMessageCallback("clearHostResolverCache",
+      proxy_->CreateCallback(&IOThreadImpl::OnClearHostResolverCache));
 }
 
 void NetInternalsMessageHandler::CallJavascriptFunction(
     const std::wstring& function_name,
     const Value& value) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   dom_ui_->CallJavascriptFunction(function_name, value);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 118 matching lines @@
 
     // Pass it as a string, since it may be too large to fit in an integer.
     CallJavascriptFunction(L"g_browser.receivedTimeTickOffset",
                            Value::CreateStringValue(
                                Int64ToString(tick_to_unix_time_ms)));
   }
 
   // Notify the client of the basic proxy data.
   OnGetProxySettings(NULL);
   OnGetBadProxies(NULL);
+  OnGetHostResolverCache(NULL);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetProxySettings(
     const Value* value) {
   URLRequestContext* context = context_getter_->GetURLRequestContext();
   net::ProxyService* proxy_service = context->proxy_service();
 
   // TODO(eroman): send a dictionary rather than a flat string, so client can do
   //               its own presentation.
   std::string settings_string;
@@ skipping 44 matching lines @@
 
 void NetInternalsMessageHandler::IOThreadImpl::OnClearBadProxies(
     const Value* value) {
   URLRequestContext* context = context_getter_->GetURLRequestContext();
   context->proxy_service()->ClearBadProxiesCache();
 
   // Cause the renderer to be notified of the new values.
   OnGetBadProxies(NULL);
 }
 
+void NetInternalsMessageHandler::IOThreadImpl::OnGetHostResolverCache(
+    const Value* value) {
+
+  net::HostCache* cache =
+      GetHostResolverCache(context_getter_->GetURLRequestContext());
+
+  if (!cache) {
+    CallJavascriptFunction(L"g_browser.receivedHostResolverCache", NULL);
+    return;
+  }
+
+  DictionaryValue* dict = new DictionaryValue();
+
+  dict->SetInteger(L"capacity", static_cast<int>(cache->max_entries()));
+  dict->SetInteger(
+      L"ttl_success_ms",
+      static_cast<int>(cache->success_entry_ttl().InMilliseconds()));
+  dict->SetInteger(
+      L"ttl_failure_ms",
+      static_cast<int>(cache->failure_entry_ttl().InMilliseconds()));
+
+  ListValue* entry_list = new ListValue();
+
+  for (net::HostCache::EntryMap::const_iterator it =
+       cache->entries().begin();
+       it != cache->entries().end();
+       ++it) {
+    const net::HostCache::Key& key = it->first;
+    const net::HostCache::Entry* entry = it->second.get();
+
+    DictionaryValue* entry_dict = new DictionaryValue();
+
+    entry_dict->SetString(L"hostname", key.hostname);
+    entry_dict->SetInteger(L"address_family",
+        static_cast<int>(key.address_family));
+    entry_dict->SetString(L"expiration", TickCountToString(entry->expiration));
+
+    if (entry->error != net::OK) {
+      entry_dict->SetInteger(L"error", entry->error);
+    } else {
+      // Append all of the resolved addresses.
+      ListValue* address_list = new ListValue();
+      const struct addrinfo* current_address = entry->addrlist.head();
+      while (current_address) {
+        address_list->Append(Value::CreateStringValue(
+            net::NetAddressToString(current_address)));
+        current_address = current_address->ai_next;
+      }
+      entry_dict->Set(L"addresses", address_list);
+    }
+
+    entry_list->Append(entry_dict);
+  }
+
+  dict->Set(L"entries", entry_list);
+
+  CallJavascriptFunction(L"g_browser.receivedHostResolverCache", dict);
+}
+
+void NetInternalsMessageHandler::IOThreadImpl::OnClearHostResolverCache(
+    const Value* value) {
+  net::HostCache* cache =
+      GetHostResolverCache(context_getter_->GetURLRequestContext());
+
+  if (cache)
+    cache->clear();
+
+  // Cause the renderer to be notified of the new values.
+  OnGetHostResolverCache(NULL);
+}
+
 void NetInternalsMessageHandler::IOThreadImpl::OnAddEntry(
     const net::NetLog::Entry& entry) {
   DCHECK(is_observing_log_);
 
   // JSONify the NetLog::Entry.
   // TODO(eroman): Need a better format for this.
   DictionaryValue* entry_dict = new DictionaryValue();
 
   // Set the entry type.
   {
@@ skipping 90 matching lines @@
   NetInternalsHTMLSource* html_source = new NetInternalsHTMLSource();
 
   // Set up the chrome://net-internals/ source.
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       NewRunnableMethod(
           Singleton<ChromeURLDataManager>::get(),
           &ChromeURLDataManager::AddDataSource,
           make_scoped_refptr(html_source)));
 }