Add function to get network stack state from a URLRequestContext.

chrome/browser/ui/webui/net_internals/net_internals_ui.cc

 // Copyright (c) 2012 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/ui/webui/net_internals/net_internals_ui.h"
 
 #include <algorithm>
 #include <list>
 #include <string>
 #include <utility>
@@ skipping 38 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "grit/net_internals_resources.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log_logger.h"
+#include "net/base/net_log_util.h"
 #include "net/base/net_util.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/dns/host_cache.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_stream_factory.h"
 #include "net/http/transport_security_state.h"
@@ skipping 86 matching lines @@
                                     net::NetLog::LogLevel log_level) {
   return request->GetStateAsValue();
 }
 
 // Returns true if |request1| was created before |request2|.
 bool RequestCreatedBefore(const net::URLRequest* request1,
                           const net::URLRequest* request2) {
   return request1->creation_time() < request2->creation_time();
 }
 
-// Returns the disk cache backend for |context| if there is one, or NULL.
-disk_cache::Backend* GetDiskCacheBackend(net::URLRequestContext* context) {
-  if (!context->http_transaction_factory())
-    return NULL;
-
-  net::HttpCache* http_cache = context->http_transaction_factory()->GetCache();
-  if (!http_cache)
-    return NULL;
-
-  return http_cache->GetCurrentBackend();
-}
-
 // Returns the http network session for |context| if there is one.
 // Otherwise, returns NULL.
 net::HttpNetworkSession* GetHttpNetworkSession(
     net::URLRequestContext* context) {
   if (!context->http_transaction_factory())
     return NULL;
 
   return context->http_transaction_factory()->GetSession();
 }
 
@@ skipping 190 matching lines @@
   // Called when the WebUI is deleted.  Prevents calling Javascript functions
   // afterwards.  Called on UI thread.
   void OnWebUIDeleted();
 
   //--------------------------------
   // Javascript message handlers:
   //--------------------------------
 
   void OnRendererReady(const base::ListValue* list);
 
-  void OnGetProxySettings(const base::ListValue* list);
+  void OnGetNetInfo(const base::ListValue* list);
   void OnReloadProxySettings(const base::ListValue* list);
-  void OnGetBadProxies(const base::ListValue* list);
   void OnClearBadProxies(const base::ListValue* list);
-  void OnGetHostResolverInfo(const base::ListValue* list);
   void OnClearHostResolverCache(const base::ListValue* list);
   void OnEnableIPv6(const base::ListValue* list);
   void OnStartConnectionTests(const base::ListValue* list);
   void OnHSTSQuery(const base::ListValue* list);
   void OnHSTSAdd(const base::ListValue* list);
   void OnHSTSDelete(const base::ListValue* list);
-  void OnGetHttpCacheInfo(const base::ListValue* list);
-  void OnGetSocketPoolInfo(const base::ListValue* list);
   void OnGetSessionNetworkStats(const base::ListValue* list);
   void OnCloseIdleSockets(const base::ListValue* list);
   void OnFlushSocketPools(const base::ListValue* list);
-  void OnGetSpdySessionInfo(const base::ListValue* list);
-  void OnGetSpdyStatus(const base::ListValue* list);
-  void OnGetSpdyAlternateProtocolMappings(const base::ListValue* list);
-  void OnGetQuicInfo(const base::ListValue* list);
 #if defined(OS_WIN)
   void OnGetServiceProviders(const base::ListValue* list);
 #endif
   void OnSetLogLevel(const base::ListValue* list);
 
   // ChromeNetLog::ThreadSafeObserver implementation:
   void OnAddEntry(const net::NetLog::Entry& entry) override;
 
   // ConnectionTester::Delegate implementation:
   void OnStartConnectionTestSuite() override;
@@ skipping 30 matching lines @@
   // Must be called on the IO Thread.
   void PostPendingEntries();
 
   // Adds entries with the states of ongoing URL requests.
   void PrePopulateEventList();
 
   net::URLRequestContext* GetMainContext() {
     return main_context_getter_->GetURLRequestContext();
   }
 
+  void SendNetInfo(int info_sources);

[eroman, 2014/10/28 21:59:41]

Please add documentation. In particular, not clear what "net info" means, or
"sources"

[mmenke, 2014/10/29 15:44:55]

Done.

+
   // Pointer to the UI-thread message handler. Only access this from
   // the UI thread.
   base::WeakPtr<NetInternalsMessageHandler> handler_;
 
   // The global IOThread, which contains the global NetLog to observer.
   IOThread* io_thread_;
 
   // The main URLRequestContextGetter for the tab's profile.
   scoped_refptr<net::URLRequestContextGetter> main_context_getter_;
 
@@ skipping 58 matching lines @@
     prerender_manager_ = prerender_manager->AsWeakPtr();
   } else {
     prerender_manager_ = base::WeakPtr<prerender::PrerenderManager>();
   }
 
   web_ui()->RegisterMessageCallback(
       "notifyReady",
       base::Bind(&NetInternalsMessageHandler::OnRendererReady,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
-      "getProxySettings",
+      "getNetInfo",
       base::Bind(&IOThreadImpl::CallbackHelper,
-                 &IOThreadImpl::OnGetProxySettings, proxy_));
+                 &IOThreadImpl::OnGetNetInfo, proxy_));
   web_ui()->RegisterMessageCallback(
       "reloadProxySettings",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnReloadProxySettings, proxy_));
   web_ui()->RegisterMessageCallback(
-      "getBadProxies",
-      base::Bind(&IOThreadImpl::CallbackHelper,
-                 &IOThreadImpl::OnGetBadProxies, proxy_));
-  web_ui()->RegisterMessageCallback(
       "clearBadProxies",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnClearBadProxies, proxy_));
   web_ui()->RegisterMessageCallback(
-      "getHostResolverInfo",
-      base::Bind(&IOThreadImpl::CallbackHelper,
-                 &IOThreadImpl::OnGetHostResolverInfo, proxy_));
-  web_ui()->RegisterMessageCallback(
       "clearHostResolverCache",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnClearHostResolverCache, proxy_));
   web_ui()->RegisterMessageCallback(
       "enableIPv6",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnEnableIPv6, proxy_));
   web_ui()->RegisterMessageCallback(
       "startConnectionTests",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnStartConnectionTests, proxy_));
   web_ui()->RegisterMessageCallback(
       "hstsQuery",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnHSTSQuery, proxy_));
   web_ui()->RegisterMessageCallback(
       "hstsAdd",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnHSTSAdd, proxy_));
   web_ui()->RegisterMessageCallback(
       "hstsDelete",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnHSTSDelete, proxy_));
   web_ui()->RegisterMessageCallback(
-      "getHttpCacheInfo",
-      base::Bind(&IOThreadImpl::CallbackHelper,
-                 &IOThreadImpl::OnGetHttpCacheInfo, proxy_));
-  web_ui()->RegisterMessageCallback(
-      "getSocketPoolInfo",
-      base::Bind(&IOThreadImpl::CallbackHelper,
-                 &IOThreadImpl::OnGetSocketPoolInfo, proxy_));
-  web_ui()->RegisterMessageCallback(
       "getSessionNetworkStats",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnGetSessionNetworkStats, proxy_));
   web_ui()->RegisterMessageCallback(
       "closeIdleSockets",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnCloseIdleSockets, proxy_));
   web_ui()->RegisterMessageCallback(
       "flushSocketPools",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnFlushSocketPools, proxy_));
-  web_ui()->RegisterMessageCallback(
-      "getSpdySessionInfo",
-      base::Bind(&IOThreadImpl::CallbackHelper,
-                 &IOThreadImpl::OnGetSpdySessionInfo, proxy_));
-  web_ui()->RegisterMessageCallback(
-      "getSpdyStatus",
-      base::Bind(&IOThreadImpl::CallbackHelper,
-                 &IOThreadImpl::OnGetSpdyStatus, proxy_));
-  web_ui()->RegisterMessageCallback(
-      "getSpdyAlternateProtocolMappings",
-      base::Bind(&IOThreadImpl::CallbackHelper,
-                 &IOThreadImpl::OnGetSpdyAlternateProtocolMappings, proxy_));
-  web_ui()->RegisterMessageCallback(
-      "getQuicInfo",
-      base::Bind(&IOThreadImpl::CallbackHelper,
-                 &IOThreadImpl::OnGetQuicInfo, proxy_));
 #if defined(OS_WIN)
   web_ui()->RegisterMessageCallback(
       "getServiceProviders",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnGetServiceProviders, proxy_));
 #endif
 
   web_ui()->RegisterMessageCallback(
       "setLogLevel",
       base::Bind(&IOThreadImpl::CallbackHelper,
@@ skipping 287 matching lines @@
   // Add entries for ongoing URL requests.
   PrePopulateEventList();
 
   if (!net_log()) {
     // Register with network stack to observe events.
     io_thread_->net_log()->AddThreadSafeObserver(this,
         net::NetLog::LOG_ALL_BUT_BYTES);
   }
 }
 
-void NetInternalsMessageHandler::IOThreadImpl::OnGetProxySettings(
+void NetInternalsMessageHandler::IOThreadImpl::OnGetNetInfo(
     const base::ListValue* list) {
-  DCHECK(!list);
-  net::ProxyService* proxy_service = GetMainContext()->proxy_service();
-
-  base::DictionaryValue* dict = new base::DictionaryValue();
-  if (proxy_service->fetched_config().is_valid())
-    dict->Set("original", proxy_service->fetched_config().ToValue());
-  if (proxy_service->config().is_valid())
-    dict->Set("effective", proxy_service->config().ToValue());
-
-  SendJavascriptCommand("receivedProxySettings", dict);
+  DCHECK(list);
+  int info_sources;
+  if (!list->GetInteger(0, &info_sources))
+    return;
+  SendNetInfo(info_sources);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnReloadProxySettings(
     const base::ListValue* list) {
   DCHECK(!list);
   GetMainContext()->proxy_service()->ForceReloadProxyConfig();
 
   // Cause the renderer to be notified of the new values.
-  OnGetProxySettings(NULL);
-}
-
-void NetInternalsMessageHandler::IOThreadImpl::OnGetBadProxies(
-    const base::ListValue* list) {
-  DCHECK(!list);
-
-  const net::ProxyRetryInfoMap& bad_proxies_map =
-      GetMainContext()->proxy_service()->proxy_retry_info();
-
-  base::ListValue* dict_list = new base::ListValue();
-
-  for (net::ProxyRetryInfoMap::const_iterator it = bad_proxies_map.begin();
-       it != bad_proxies_map.end(); ++it) {
-    const std::string& proxy_uri = it->first;
-    const net::ProxyRetryInfo& retry_info = it->second;
-
-    base::DictionaryValue* dict = new base::DictionaryValue();
-    dict->SetString("proxy_uri", proxy_uri);
-    dict->SetString("bad_until",
-                    net::NetLog::TickCountToString(retry_info.bad_until));
-
-    dict_list->Append(dict);
-  }
-
-  SendJavascriptCommand("receivedBadProxies", dict_list);
+  SendNetInfo(net::NET_INFO_PROXY_SETTINGS);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnClearBadProxies(
     const base::ListValue* list) {
   DCHECK(!list);
   GetMainContext()->proxy_service()->ClearBadProxiesCache();
 
   // Cause the renderer to be notified of the new values.
-  OnGetBadProxies(NULL);
-}
-
-void NetInternalsMessageHandler::IOThreadImpl::OnGetHostResolverInfo(
-    const base::ListValue* list) {
-  DCHECK(!list);
-  net::URLRequestContext* context = GetMainContext();
-  net::HostCache* cache = GetHostResolverCache(context);
-
-  if (!cache) {
-    SendJavascriptCommand("receivedHostResolverInfo", NULL);
-    return;
-  }
-
-  base::DictionaryValue* dict = new base::DictionaryValue();
-
-  base::Value* dns_config = context->host_resolver()->GetDnsConfigAsValue();
-  if (dns_config)
-    dict->Set("dns_config", dns_config);
-
-  dict->SetInteger(
-      "default_address_family",
-      static_cast<int>(context->host_resolver()->GetDefaultAddressFamily()));
-
-  base::DictionaryValue* cache_info_dict = new base::DictionaryValue();
-
-  cache_info_dict->SetInteger(
-      "capacity",
-      static_cast<int>(cache->max_entries()));
-
-  base::ListValue* entry_list = new base::ListValue();
-
-  net::HostCache::EntryMap::Iterator it(cache->entries());
-  for (; it.HasNext(); it.Advance()) {
-    const net::HostCache::Key& key = it.key();
-    const net::HostCache::Entry& entry = it.value();
-
-    base::DictionaryValue* entry_dict = new base::DictionaryValue();
-
-    entry_dict->SetString("hostname", key.hostname);
-    entry_dict->SetInteger("address_family",
-        static_cast<int>(key.address_family));
-    entry_dict->SetString("expiration",
-                          net::NetLog::TickCountToString(it.expiration()));
-
-    if (entry.error != net::OK) {
-      entry_dict->SetInteger("error", entry.error);
-    } else {
-      // Append all of the resolved addresses.
-      base::ListValue* address_list = new base::ListValue();
-      for (size_t i = 0; i < entry.addrlist.size(); ++i) {
-        address_list->AppendString(entry.addrlist[i].ToStringWithoutPort());
-      }
-      entry_dict->Set("addresses", address_list);
-    }
-
-    entry_list->Append(entry_dict);
-  }
-
-  cache_info_dict->Set("entries", entry_list);
-  dict->Set("cache", cache_info_dict);
-
-  SendJavascriptCommand("receivedHostResolverInfo", dict);
+  SendNetInfo(net::NET_INFO_BAD_PROXIES);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnClearHostResolverCache(
     const base::ListValue* list) {
   DCHECK(!list);
   net::HostCache* cache = GetHostResolverCache(GetMainContext());
 
   if (cache)
     cache->clear();
 
   // Cause the renderer to be notified of the new values.
-  OnGetHostResolverInfo(NULL);
+  SendNetInfo(net::NET_INFO_HOST_RESOLVER);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnEnableIPv6(
     const base::ListValue* list) {
   DCHECK(!list);
   net::HostResolver* host_resolver = GetMainContext()->host_resolver();
 
   host_resolver->SetDefaultAddressFamily(net::ADDRESS_FAMILY_UNSPECIFIED);
 
   // Cause the renderer to be notified of the new value.
-  OnGetHostResolverInfo(NULL);
+  SendNetInfo(net::NET_INFO_HOST_RESOLVER);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnStartConnectionTests(
     const base::ListValue* list) {
   // |value| should be: [<URL to test>].
   base::string16 url_str;
   CHECK(list->GetString(0, &url_str));
 
   // Try to fix-up the user provided URL into something valid.
   // For example, turn "www.google.com" into "http://www.google.com".
@@ skipping 129 matching lines @@
     return;
   }
   net::TransportSecurityState* transport_security_state =
       GetMainContext()->transport_security_state();
   if (!transport_security_state)
     return;
 
   transport_security_state->DeleteDynamicDataForHost(domain);
 }
 
-void NetInternalsMessageHandler::IOThreadImpl::OnGetHttpCacheInfo(
-    const base::ListValue* list) {
-  DCHECK(!list);
-  base::DictionaryValue* info_dict = new base::DictionaryValue();
-  base::DictionaryValue* stats_dict = new base::DictionaryValue();
-
-  disk_cache::Backend* disk_cache = GetDiskCacheBackend(GetMainContext());
-
-  if (disk_cache) {
-    // Extract the statistics key/value pairs from the backend.
-    base::StringPairs stats;
-    disk_cache->GetStats(&stats);
-    for (size_t i = 0; i < stats.size(); ++i) {
-      stats_dict->SetStringWithoutPathExpansion(
-          stats[i].first, stats[i].second);
-    }
-  }
-
-  info_dict->Set("stats", stats_dict);
-
-  SendJavascriptCommand("receivedHttpCacheInfo", info_dict);
-}
-
-void NetInternalsMessageHandler::IOThreadImpl::OnGetSocketPoolInfo(
-    const base::ListValue* list) {
-  DCHECK(!list);
-  net::HttpNetworkSession* http_network_session =
-      GetHttpNetworkSession(GetMainContext());
-
-  base::Value* socket_pool_info = NULL;
-  if (http_network_session)
-    socket_pool_info = http_network_session->SocketPoolInfoToValue();
-
-  SendJavascriptCommand("receivedSocketPoolInfo", socket_pool_info);
-}
-
 void NetInternalsMessageHandler::IOThreadImpl::OnGetSessionNetworkStats(
     const base::ListValue* list) {
   DCHECK(!list);
   net::HttpNetworkSession* http_network_session =
       GetHttpNetworkSession(main_context_getter_->GetURLRequestContext());
 
   base::Value* network_info = NULL;
   if (http_network_session) {
     ChromeNetworkDelegate* net_delegate =
         static_cast<ChromeNetworkDelegate*>(
@@ skipping 18 matching lines @@
 void NetInternalsMessageHandler::IOThreadImpl::OnCloseIdleSockets(
     const base::ListValue* list) {
   DCHECK(!list);
   net::HttpNetworkSession* http_network_session =
       GetHttpNetworkSession(GetMainContext());
 
   if (http_network_session)
     http_network_session->CloseIdleConnections();
 }
 
-void NetInternalsMessageHandler::IOThreadImpl::OnGetSpdySessionInfo(
-    const base::ListValue* list) {
-  DCHECK(!list);
-  net::HttpNetworkSession* http_network_session =
-      GetHttpNetworkSession(GetMainContext());
-
-  base::Value* spdy_info = http_network_session ?
-      http_network_session->SpdySessionPoolInfoToValue() : NULL;
-  SendJavascriptCommand("receivedSpdySessionInfo", spdy_info);
-}
-
-void NetInternalsMessageHandler::IOThreadImpl::OnGetSpdyStatus(
-    const base::ListValue* list) {
-  DCHECK(!list);
-  base::DictionaryValue* status_dict = new base::DictionaryValue();
-
-  net::HttpNetworkSession* http_network_session =
-      GetHttpNetworkSession(GetMainContext());
-
-  status_dict->SetBoolean("spdy_enabled",
-                          net::HttpStreamFactory::spdy_enabled());
-  status_dict->SetBoolean(
-      "use_alternate_protocols",
-      http_network_session->params().use_alternate_protocols);
-  status_dict->SetBoolean("force_spdy_over_ssl",
-                          http_network_session->params().force_spdy_over_ssl);
-  status_dict->SetBoolean("force_spdy_always",
-                          http_network_session->params().force_spdy_always);
-
-  std::vector<std::string> next_protos;
-  http_network_session->GetNextProtos(&next_protos);
-  std::string next_protos_string = JoinString(next_protos, ',');
-  status_dict->SetString("next_protos", next_protos_string);
-
-  SendJavascriptCommand("receivedSpdyStatus", status_dict);
-}
-
-void
-NetInternalsMessageHandler::IOThreadImpl::OnGetSpdyAlternateProtocolMappings(
-    const base::ListValue* list) {
-  DCHECK(!list);
-  base::ListValue* dict_list = new base::ListValue();
-
-  const net::HttpServerProperties& http_server_properties =
-      *GetMainContext()->http_server_properties();
-
-  const net::AlternateProtocolMap& map =
-      http_server_properties.alternate_protocol_map();
-
-  for (net::AlternateProtocolMap::const_iterator it = map.begin();
-       it != map.end(); ++it) {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-    dict->SetString("host_port_pair", it->first.ToString());
-    dict->SetString("alternate_protocol", it->second.ToString());
-    dict_list->Append(dict);
-  }
-
-  SendJavascriptCommand("receivedSpdyAlternateProtocolMappings", dict_list);
-}
-
-void NetInternalsMessageHandler::IOThreadImpl::OnGetQuicInfo(
-    const base::ListValue* list) {
-  DCHECK(!list);
-  net::HttpNetworkSession* http_network_session =
-      GetHttpNetworkSession(GetMainContext());
-
-  base::Value* quic_info = http_network_session ?
-      http_network_session->QuicInfoToValue() : NULL;
-  SendJavascriptCommand("receivedQuicInfo", quic_info);
-}
-
 #if defined(OS_WIN)
 void NetInternalsMessageHandler::IOThreadImpl::OnGetServiceProviders(
     const base::ListValue* list) {
   DCHECK(!list);
 
   base::DictionaryValue* service_providers = new base::DictionaryValue();
 
   WinsockLayeredServiceProviderList layered_providers;
   GetWinsockLayeredServiceProviders(&layered_providers);
   base::ListValue* layered_provider_list = new base::ListValue();
@@ skipping 312 matching lines @@
                                       &callback);
     net::NetLog::Entry entry(&entry_data, request->net_log().GetLogLevel());
 
     // Have to add |entry| to the queue synchronously, as there may already
     // be posted tasks queued up to add other events for |request|, which we
     // want |entry| to precede.
     AddEntryToQueue(entry.ToValue());
   }
 }
 
+void NetInternalsMessageHandler::IOThreadImpl::SendNetInfo(int info_sources) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  SendJavascriptCommand(
+      "receivedNetInfo",
+      net::GetNetInfo(GetMainContext(), info_sources).release());
+}
+
 }  // namespace
 
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // NetInternalsUI
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 // static
 base::Value* NetInternalsUI::GetConstants() {
-  base::DictionaryValue* constants_dict = net::NetLogLogger::GetConstants();
+  scoped_ptr<base::DictionaryValue> constants_dict = net::GetNetConstants();
   DCHECK(constants_dict);
 
   // Add a dictionary with the version of the client and its command line
   // arguments.
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
 
     chrome::VersionInfo version_info;
 
     // We have everything we need to send the right values.
     dict->SetString("name", version_info.Name());
     dict->SetString("version", version_info.Version());
     dict->SetString("cl", version_info.LastChange());
     dict->SetString("version_mod",
                     chrome::VersionInfo::GetVersionStringModifier());
     dict->SetString("official",
                     version_info.IsOfficialBuild() ? "official" : "unofficial");
     dict->SetString("os_type", version_info.OSType());
     dict->SetString("command_line",
                     CommandLine::ForCurrentProcess()->GetCommandLineString());
 
     constants_dict->Set("clientInfo", dict);
   }
 
-  return constants_dict;
+  return constants_dict.release();
 }
 
 NetInternalsUI::NetInternalsUI(content::WebUI* web_ui)
     : WebUIController(web_ui) {
   web_ui->AddMessageHandler(new NetInternalsMessageHandler());
 
   // Set up the chrome://net-internals/ source.
   Profile* profile = Profile::FromWebUI(web_ui);
   content::WebUIDataSource::Add(profile, CreateNetInternalsHTMLSource());
 }