Valgrind: Fix some leaks and style issues in NetInternalsUI.

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>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
-#include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
-#include "base/path_service.h"
 #include "base/platform_file.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/threading/worker_pool.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 16 matching lines @@
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "grit/generated_resources.h"
 #include "grit/net_internals_resources.h"
-#include "net/base/escape.h"
 #include "net/base/host_cache.h"
 #include "net/base/host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/transport_security_state.h"
-#include "net/base/x509_cert_types.h"
 #include "net/disk_cache/disk_cache.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/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
-#include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
-#ifdef OS_CHROMEOS
+#if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/system/syslogs_provider.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/debug_daemon_client.h"
 #endif
-#ifdef OS_WIN
+#if defined(OS_WIN)
 #include "chrome/browser/net/service_providers_win.h"
 #endif
 
 using base::PassPlatformFile;
 using base::PlatformFile;
 using base::PlatformFileError;
 using content::BrowserThread;
 using content::WebContents;
 using content::WebUIMessageHandler;
 
@@ skipping 57 matching lines @@
       new ChromeWebUIDataSource(chrome::kChromeUINetInternalsHost);
 
   source->set_default_resource(IDR_NET_INTERNALS_INDEX_HTML);
   source->add_resource_path("help.html", IDR_NET_INTERNALS_HELP_HTML);
   source->add_resource_path("help.js", IDR_NET_INTERNALS_HELP_JS);
   source->add_resource_path("index.js", IDR_NET_INTERNALS_INDEX_JS);
   source->set_json_path("strings.js");
   return source;
 }
 
-#ifdef OS_CHROMEOS
+#if defined(OS_CHROMEOS)
 // Small helper class used to create temporary log file and pass its
 // handle and error status to callback.
 // Use case:
 // DebugLogFileHelper* helper = new DebugLogFileHelper();
 // base::WorkerPool::PostTaskAndReply(FROM_HERE,
 //     base::Bind(&DebugLogFileHelper::DoWork, base::Unretained(helper), ...),
 //     base::Bind(&DebugLogFileHelper::Reply, base::Owned(helper), ...),
 //     false);
 class DebugLogFileHelper {
  public:
@@ skipping 117 matching lines @@
   DCHECK(!callback.is_null());
   const FilePath fileshelf = download_util::GetDefaultDownloadDirectory();
   DebugLogFileHelper* helper = new DebugLogFileHelper();
   bool posted = base::WorkerPool::PostTaskAndReply(FROM_HERE,
       base::Bind(&DebugLogFileHelper::DoWork,
           base::Unretained(helper), fileshelf),
       base::Bind(&DebugLogFileHelper::Reply, base::Owned(helper),
           base::Bind(&WriteDebugLogToFile, callback)), false);
   DCHECK(posted);
 }
-#endif  // OS_CHROMEOS
+#endif  // defined(OS_CHROMEOS)
 
 // This class receives javascript messages from the renderer.
 // Note that the WebUI infrastructure runs on the UI thread, therefore all of
 // this class's methods are expected to run on the UI thread.
 //
 // Since the network code we want to run lives on the IO thread, we proxy
 // almost everything over to NetInternalsMessageHandler::IOThreadImpl, which
 // runs on the IO thread.
 //
 // TODO(eroman): Can we start on the IO thread to begin with?
 class NetInternalsMessageHandler
     : public WebUIMessageHandler,
       public base::SupportsWeakPtr<NetInternalsMessageHandler> {
  public:
   NetInternalsMessageHandler();
   virtual ~NetInternalsMessageHandler();
 
   // WebUIMessageHandler implementation.
   virtual void RegisterMessages() OVERRIDE;
 
   // Calls g_browser.receive in the renderer, passing in |command| and |arg|.
   // Takes ownership of |arg|.  If the renderer is displaying a log file, the
   // message will be ignored.
   void SendJavascriptCommand(const std::string& command, Value* arg);
 
   // Javascript message handlers.
   void OnRendererReady(const ListValue* list);
   void OnClearBrowserCache(const ListValue* list);
   void OnGetPrerenderInfo(const ListValue* list);
-#ifdef OS_CHROMEOS
+#if defined(OS_CHROMEOS)
   void OnRefreshSystemLogs(const ListValue* list);
   void OnGetSystemLog(const ListValue* list);
   void OnImportONCFile(const ListValue* list);
   void OnStoreDebugLogs(const ListValue* list);
   void OnStoreDebugLogsCompleted(const FilePath& log_path, bool succeeded);
   void OnSetNetworkDebugMode(const ListValue* list);
   void OnSetNetworkDebugModeCompleted(const std::string& subsystem,
                                       bool succeeded);
 #endif
 
  private:
   class IOThreadImpl;
 
-#ifdef OS_CHROMEOS
+#if defined(OS_CHROMEOS)
   // Class that is used for getting network related ChromeOS logs.
   // Logs are fetched from ChromeOS libcros on user request, and only when we
   // don't yet have a copy of logs. If a copy is present, we send back data from
   // it, else we save request and answer to it when we get logs from libcros.
   // If needed, we also send request for system logs to libcros.
   // Logs refresh has to be done explicitly, by deleting old logs and then
   // loading them again.
   class SystemLogsGetter {
    public:
     SystemLogsGetter(NetInternalsMessageHandler* handler,
@@ skipping 32 matching lines @@
     chromeos::system::SyslogsProvider* syslogs_provider_;
     // List of postponed requests.
     std::list<SystemLogRequest> requests_;
     scoped_ptr<chromeos::system::LogDictionaryType> logs_;
     bool logs_received_;
     bool logs_requested_;
     CancelableRequestConsumer consumer_;
     // Libcros request handle.
     CancelableRequestProvider::Handle syslogs_request_id_;
   };
-#endif
+#endif  // defined(OS_CHROMEOS)
 
   // This is the "real" message handler, which lives on the IO thread.
   scoped_refptr<IOThreadImpl> proxy_;
 
   base::WeakPtr<prerender::PrerenderManager> prerender_manager_;
 
-#ifdef OS_CHROMEOS
+#if defined(OS_CHROMEOS)
   // Class that handles getting and filtering system logs.
   scoped_ptr<SystemLogsGetter> syslogs_getter_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(NetInternalsMessageHandler);
 };
 
 // This class is the "real" message handler. It is allocated and destroyed on
 // the UI thread.  With the exception of OnAddEntry, OnWebUIDeleted, and
 // SendJavascriptCommand, its methods are all expected to be called from the IO
@@ skipping 50 matching lines @@
   void OnHSTSQuery(const ListValue* list);
   void OnHSTSAdd(const ListValue* list);
   void OnHSTSDelete(const ListValue* list);
   void OnGetHttpCacheInfo(const ListValue* list);
   void OnGetSocketPoolInfo(const ListValue* list);
   void OnCloseIdleSockets(const ListValue* list);
   void OnFlushSocketPools(const ListValue* list);
   void OnGetSpdySessionInfo(const ListValue* list);
   void OnGetSpdyStatus(const ListValue* list);
   void OnGetSpdyAlternateProtocolMappings(const ListValue* list);
-#ifdef OS_WIN
+#if defined(OS_WIN)
   void OnGetServiceProviders(const ListValue* list);
 #endif
   void OnGetHttpPipeliningStatus(const ListValue* list);
   void OnSetLogLevel(const ListValue* list);
 
   // ChromeNetLog::ThreadSafeObserver implementation:
   virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
 
   // ConnectionTester::Delegate implementation:
   virtual void OnStartConnectionTestSuite() OVERRIDE;
   virtual void OnStartConnectionTestExperiment(
       const ConnectionTester::Experiment& experiment) OVERRIDE;
   virtual void OnCompletedConnectionTestExperiment(
       const ConnectionTester::Experiment& experiment,
       int result) OVERRIDE;
   virtual void OnCompletedConnectionTestSuite() OVERRIDE;
 
   // Helper that calls g_browser.receive in the renderer, passing in |command|
   // and |arg|.  Takes ownership of |arg|.  If the renderer is displaying a log
   // file, the message will be ignored.  Note that this can be called from any
   // thread.
   void SendJavascriptCommand(const std::string& command, Value* arg);
 
-  // Helper that runs |method| with |arg|, and deletes |arg| on completion.
-  void DispatchToMessageHandler(ListValue* arg, MessageHandler method);
-
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class base::DeleteHelper<IOThreadImpl>;
 
   ~IOThreadImpl();
 
   // Adds |entry| to the queue of pending log entries to be sent to the page via
   // Javascript.  Must be called on the IO Thread.  Also creates a delayed task
   // that will call PostPendingEntries, if there isn't one already.
   void AddEntryToQueue(Value* entry);
@@ skipping 47 matching lines @@
   }
 }
 
 void NetInternalsMessageHandler::RegisterMessages() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   Profile* profile = Profile::FromWebUI(web_ui());
 
   proxy_ = new IOThreadImpl(this->AsWeakPtr(), g_browser_process->io_thread(),
                             profile->GetRequestContext());
-#ifdef OS_CHROMEOS
+#if defined(OS_CHROMEOS)
   syslogs_getter_.reset(new SystemLogsGetter(this,
       chromeos::system::SyslogsProvider::GetInstance()));
 #endif
 
   prerender::PrerenderManager* prerender_manager =
       prerender::PrerenderManagerFactory::GetForProfile(profile);
   if (prerender_manager) {
     prerender_manager_ = prerender_manager->AsWeakPtr();
   } else {
     prerender_manager_ = base::WeakPtr<prerender::PrerenderManager>();
@@ skipping 72 matching lines @@
       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_));
-#ifdef OS_WIN
+#if defined(OS_WIN)
   web_ui()->RegisterMessageCallback(
       "getServiceProviders",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnGetServiceProviders, proxy_));
 #endif
 
   web_ui()->RegisterMessageCallback(
       "getHttpPipeliningStatus",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnGetHttpPipeliningStatus, proxy_));
   web_ui()->RegisterMessageCallback(
       "setLogLevel",
       base::Bind(&IOThreadImpl::CallbackHelper,
                  &IOThreadImpl::OnSetLogLevel, proxy_));
   web_ui()->RegisterMessageCallback(
       "clearBrowserCache",
       base::Bind(&NetInternalsMessageHandler::OnClearBrowserCache,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "getPrerenderInfo",
       base::Bind(&NetInternalsMessageHandler::OnGetPrerenderInfo,
                  base::Unretained(this)));
-#ifdef OS_CHROMEOS
+#if defined(OS_CHROMEOS)
   web_ui()->RegisterMessageCallback(
       "refreshSystemLogs",
       base::Bind(&NetInternalsMessageHandler::OnRefreshSystemLogs,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "getSystemLog",
       base::Bind(&NetInternalsMessageHandler::OnGetSystemLog,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "importONCFile",
@@ skipping 49 matching lines @@
     value = new DictionaryValue();
     value->SetBoolean("enabled", false);
     value->SetBoolean("omnibox_enabled", false);
   } else {
     value = prerender_manager->GetAsValue();
   }
   SendJavascriptCommand("receivedPrerenderInfo", value);
 }
 
 
-#ifdef OS_CHROMEOS
+#if defined(OS_CHROMEOS)
 ////////////////////////////////////////////////////////////////////////////////
 //
 // NetInternalsMessageHandler::SystemLogsGetter
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 NetInternalsMessageHandler::SystemLogsGetter::SystemLogsGetter(
     NetInternalsMessageHandler* handler,
     chromeos::system::SyslogsProvider* syslogs_provider)
     : handler_(handler),
@@ skipping 73 matching lines @@
     } else {
       result->SetString("log", "<no relevant lines found>");
     }
   } else {
     result->SetString("log", "<invalid log name>");
   }
   result->SetString("cellId", request.cell_id);
 
   handler_->SendJavascriptCommand("getSystemLogCallback", result);
 }
-#endif
+#endif  // defined(OS_CHROMEOS)
+
 ////////////////////////////////////////////////////////////////////////////////
 //
 // NetInternalsMessageHandler::IOThreadImpl
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 NetInternalsMessageHandler::IOThreadImpl::IOThreadImpl(
     const base::WeakPtr<NetInternalsMessageHandler>& handler,
     IOThread* io_thread,
     net::URLRequestContextGetter* context_getter)
     : handler_(handler),
       io_thread_(io_thread),
       context_getter_(context_getter),
       was_webui_deleted_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 NetInternalsMessageHandler::IOThreadImpl::~IOThreadImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::CallbackHelper(
     MessageHandler method,
     scoped_refptr<IOThreadImpl> io_thread,
     const ListValue* list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // We need to make a copy of the value in order to pass it over to the IO
-  // thread. We will delete this in IOThreadImpl::DispatchMessageHandler().
-  ListValue* list_copy =
-      static_cast<ListValue*>(list ? list->DeepCopy() : NULL);
+  // thread. |list_copy| will be deleted when the task is destroyed. The called
+  // |method| cannot take ownership of |list_copy|.
+  ListValue* list_copy = (list && list->GetSize()) ? list->DeepCopy() : NULL;
 
-  if (!BrowserThread::PostTask(
-          BrowserThread::IO, FROM_HERE,
-          base::Bind(method, io_thread, list_copy))) {
-    // Failed posting the task, avoid leaking |list_copy|.
-    delete list_copy;
-  }
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(method, io_thread, base::Owned(list_copy)));
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::Detach() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Unregister with network stack to observe events.
   if (net_log())
     net_log()->RemoveThreadSafeObserver(this);
 
   // Cancel any in-progress connection tests.
   connection_tester_.reset();
@@ skipping 13 matching lines @@
 
   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(
     const ListValue* list) {
+  DCHECK(!list);
   net::URLRequestContext* context = context_getter_->GetURLRequestContext();
   net::ProxyService* proxy_service = context->proxy_service();
 
   DictionaryValue* dict = new 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);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnReloadProxySettings(
     const ListValue* list) {
+  DCHECK(!list);
   net::URLRequestContext* context = context_getter_->GetURLRequestContext();
   context->proxy_service()->ForceReloadProxyConfig();
 
   // Cause the renderer to be notified of the new values.
   OnGetProxySettings(NULL);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetBadProxies(
     const ListValue* list) {
+  DCHECK(!list);
   net::URLRequestContext* context = context_getter_->GetURLRequestContext();
 
   const net::ProxyRetryInfoMap& bad_proxies_map =
       context->proxy_service()->proxy_retry_info();
 
   ListValue* dict_list = new 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;
 
     DictionaryValue* dict = new 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);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnClearBadProxies(
     const ListValue* list) {
+  DCHECK(!list);
   net::URLRequestContext* context = context_getter_->GetURLRequestContext();
   context->proxy_service()->ClearBadProxiesCache();
 
   // Cause the renderer to be notified of the new values.
   OnGetBadProxies(NULL);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetHostResolverInfo(
     const ListValue* list) {
+  DCHECK(!list);
   net::URLRequestContext* context = context_getter_->GetURLRequestContext();
   net::HostCache* cache = GetHostResolverCache(context);
 
   if (!cache) {
     SendJavascriptCommand("receivedHostResolverInfo", NULL);
     return;
   }
 
   DictionaryValue* dict = new DictionaryValue();
 
@@ skipping 42 matching lines @@
   }
 
   cache_info_dict->Set("entries", entry_list);
   dict->Set("cache", cache_info_dict);
 
   SendJavascriptCommand("receivedHostResolverInfo", dict);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnRunIPv6Probe(
     const ListValue* list) {
+  DCHECK(!list);
   net::URLRequestContext* context = context_getter_->GetURLRequestContext();
   net::HostResolver* resolver = context->host_resolver();
 
   // Have to set the default address family manually before calling
   // ProbeIPv6Support.
   resolver->SetDefaultAddressFamily(net::ADDRESS_FAMILY_UNSPECIFIED);
   resolver->ProbeIPv6Support();
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnClearHostResolverCache(
     const ListValue* list) {
+  DCHECK(!list);
   net::HostCache* cache =
       GetHostResolverCache(context_getter_->GetURLRequestContext());
 
   if (cache)
     cache->clear();
 
   // Cause the renderer to be notified of the new values.
   OnGetHostResolverInfo(NULL);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnEnableIPv6(
     const ListValue* list) {
+  DCHECK(!list);
   net::URLRequestContext* context = context_getter_->GetURLRequestContext();
   net::HostResolver* host_resolver = context->host_resolver();
 
   host_resolver->SetDefaultAddressFamily(net::ADDRESS_FAMILY_UNSPECIFIED);
 
   // Cause the renderer to be notified of the new value.
   OnGetHostResolverInfo(NULL);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnStartConnectionTests(
@@ skipping 26 matching lines @@
       *string += ",";
     *string += "sha1/" + encoded;
   }
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnHSTSQuery(
     const ListValue* list) {
   // |list| should be: [<domain to query>].
   std::string domain;
   CHECK(list->GetString(0, &domain));
-  DictionaryValue* result = new(DictionaryValue);
+  DictionaryValue* result = new DictionaryValue();
 
   if (!IsStringASCII(domain)) {
     result->SetString("error", "non-ASCII domain name");
   } else {
     net::TransportSecurityState* transport_security_state =
         context_getter_->GetURLRequestContext()->transport_security_state();
     if (!transport_security_state) {
       result->SetString("error", "no TransportSecurityState active");
     } else {
       net::TransportSecurityState::DomainState state;
@@ skipping 43 matching lines @@
   if (!transport_security_state)
     return;
 
   net::TransportSecurityState::DomainState state;
   state.upgrade_expiry = state.created + base::TimeDelta::FromDays(1000);
   state.include_subdomains = include_subdomains;
   if (!hashes_str.empty()) {
     std::vector<std::string> type_and_b64s;
     base::SplitString(hashes_str, ',', &type_and_b64s);
     for (std::vector<std::string>::const_iterator
-         i = type_and_b64s.begin(); i != type_and_b64s.end(); i++) {
+         i = type_and_b64s.begin(); i != type_and_b64s.end(); ++i) {
       std::string type_and_b64;
       RemoveChars(*i, " \t\r\n", &type_and_b64);
       net::SHA1Fingerprint hash;
       if (!net::TransportSecurityState::ParsePin(type_and_b64, &hash))
         continue;
 
       state.dynamic_spki_hashes.push_back(hash);
     }
   }
 
@@ skipping 12 matching lines @@
   net::TransportSecurityState* transport_security_state =
       context_getter_->GetURLRequestContext()->transport_security_state();
   if (!transport_security_state)
     return;
 
   transport_security_state->DeleteHost(domain);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetHttpCacheInfo(
     const ListValue* list) {
+  DCHECK(!list);
   DictionaryValue* info_dict = new DictionaryValue();
   DictionaryValue* stats_dict = new DictionaryValue();
 
   disk_cache::Backend* disk_cache = GetDiskCacheBackend(
       context_getter_->GetURLRequestContext());
 
   if (disk_cache) {
     // Extract the statistics key/value pairs from the backend.
     std::vector<std::pair<std::string, std::string> > stats;
     disk_cache->GetStats(&stats);
     for (size_t i = 0; i < stats.size(); ++i) {
       stats_dict->Set(stats[i].first,
                       Value::CreateStringValue(stats[i].second));
     }
   }
 
   info_dict->Set("stats", stats_dict);
 
   SendJavascriptCommand("receivedHttpCacheInfo", info_dict);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetSocketPoolInfo(
     const ListValue* list) {
+  DCHECK(!list);
   net::HttpNetworkSession* http_network_session =
       GetHttpNetworkSession(context_getter_->GetURLRequestContext());
 
   Value* socket_pool_info = NULL;
   if (http_network_session)
     socket_pool_info = http_network_session->SocketPoolInfoToValue();
 
   SendJavascriptCommand("receivedSocketPoolInfo", socket_pool_info);
 }
 
 
 void NetInternalsMessageHandler::IOThreadImpl::OnFlushSocketPools(
     const ListValue* list) {
+  DCHECK(!list);
   net::HttpNetworkSession* http_network_session =
       GetHttpNetworkSession(context_getter_->GetURLRequestContext());
 
   if (http_network_session)
     http_network_session->CloseAllConnections();
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnCloseIdleSockets(
     const ListValue* list) {
+  DCHECK(!list);
   net::HttpNetworkSession* http_network_session =
       GetHttpNetworkSession(context_getter_->GetURLRequestContext());
 
   if (http_network_session)
     http_network_session->CloseIdleConnections();
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetSpdySessionInfo(
     const ListValue* list) {
+  DCHECK(!list);
   net::HttpNetworkSession* http_network_session =
       GetHttpNetworkSession(context_getter_->GetURLRequestContext());
 
-  Value* spdy_info = NULL;
-  if (http_network_session) {
-    spdy_info = http_network_session->SpdySessionPoolInfoToValue();
-  }
-
+  Value* spdy_info = http_network_session ?
+      http_network_session->SpdySessionPoolInfoToValue() : NULL;
   SendJavascriptCommand("receivedSpdySessionInfo", spdy_info);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetSpdyStatus(
     const ListValue* list) {
+  DCHECK(!list);
   DictionaryValue* status_dict = new DictionaryValue();
 
   status_dict->Set("spdy_enabled",
                    Value::CreateBooleanValue(
                        net::HttpStreamFactory::spdy_enabled()));
   status_dict->Set("use_alternate_protocols",
                    Value::CreateBooleanValue(
                        net::HttpStreamFactory::use_alternate_protocols()));
   status_dict->Set("force_spdy_over_ssl",
                    Value::CreateBooleanValue(
@@ skipping 11 matching lines @@
     next_protos_value = Value::CreateStringValue("");
   }
   status_dict->Set("next_protos", next_protos_value);
 
   SendJavascriptCommand("receivedSpdyStatus", status_dict);
 }
 
 void
 NetInternalsMessageHandler::IOThreadImpl::OnGetSpdyAlternateProtocolMappings(
     const ListValue* list) {
+  DCHECK(!list);
   ListValue* dict_list = new ListValue();
 
   const net::HttpServerProperties& http_server_properties =
       *context_getter_->GetURLRequestContext()->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) {
     DictionaryValue* dict = new DictionaryValue();
     dict->SetString("host_port_pair", it->first.ToString());
     dict->SetString("alternate_protocol", it->second.ToString());
     dict_list->Append(dict);
   }
 
   SendJavascriptCommand("receivedSpdyAlternateProtocolMappings", dict_list);
 }
 
-#ifdef OS_WIN
+#if defined(OS_WIN)
 void NetInternalsMessageHandler::IOThreadImpl::OnGetServiceProviders(
     const ListValue* list) {
+  DCHECK(!list);
 
   DictionaryValue* service_providers = new DictionaryValue();
 
   WinsockLayeredServiceProviderList layered_providers;
   GetWinsockLayeredServiceProviders(&layered_providers);
   ListValue* layered_provider_list = new ListValue();
   for (size_t i = 0; i < layered_providers.size(); ++i) {
     DictionaryValue* service_dict = new DictionaryValue();
     service_dict->SetString("name", layered_providers[i].name);
     service_dict->SetInteger("version", layered_providers[i].version);
@@ skipping 18 matching lines @@
     namespace_dict->SetInteger("type", namespace_providers[i].type);
 
     namespace_list->Append(namespace_dict);
   }
   service_providers->Set("namespace_providers", namespace_list);
 
   SendJavascriptCommand("receivedServiceProviders", service_providers);
 }
 #endif
 
-#ifdef OS_CHROMEOS
+#if defined(OS_CHROMEOS)
 void NetInternalsMessageHandler::OnRefreshSystemLogs(const ListValue* list) {
+  DCHECK(!list);
   DCHECK(syslogs_getter_.get());
   syslogs_getter_->DeleteSystemLogs();
   syslogs_getter_->LoadSystemLogs();
 }
 
 void NetInternalsMessageHandler::OnGetSystemLog(const ListValue* list) {
   DCHECK(syslogs_getter_.get());
   syslogs_getter_->RequestSystemLog(list);
 }
 
@@ skipping 15 matching lines @@
 
   // Now that we've added the networks, we need to rescan them so they'll be
   // available from the menu more immediately.
   cros_network->RequestNetworkScan();
 
   SendJavascriptCommand("receivedONCFileParse",
                         Value::CreateStringValue(error));
 }
 
 void NetInternalsMessageHandler::OnStoreDebugLogs(const ListValue* list) {
+  DCHECK(!list);
   StoreDebugLogs(
       base::Bind(&NetInternalsMessageHandler::OnStoreDebugLogsCompleted,
                  AsWeakPtr()));
 }
 
 void NetInternalsMessageHandler::OnStoreDebugLogsCompleted(
     const FilePath& log_path, bool succeeded) {
   std::string status;
   if (succeeded)
     status = "Created log file: " + log_path.BaseName().AsUTF8Unsafe();
@@ skipping 20 matching lines @@
     const std::string& subsystem,
     bool succeeded) {
   std::string status;
   if (succeeded)
     status = "Debug mode is changed to " + subsystem;
   else
     status = "Failed to change debug mode to " + subsystem;
   SendJavascriptCommand("receivedSetNetworkDebugMode",
                         Value::CreateStringValue(status));
 }
-#endif
+#endif  // defined(OS_CHROMEOS)
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetHttpPipeliningStatus(
     const ListValue* list) {
+  DCHECK(!list);
   DictionaryValue* status_dict = new DictionaryValue();
 
   status_dict->Set("pipelining_enabled",
                    Value::CreateBooleanValue(
                        net::HttpStreamFactory::http_pipelining_enabled()));
 
   net::HttpNetworkSession* http_network_session =
       GetHttpNetworkSession(context_getter_->GetURLRequestContext());
   Value* pipelined_connection_info = NULL;
   if (http_network_session) {
@@ skipping 109 matching lines @@
       dict);
 }
 
 void
 NetInternalsMessageHandler::IOThreadImpl::OnCompletedConnectionTestSuite() {
   SendJavascriptCommand(
       "receivedCompletedConnectionTestSuite",
       NULL);
 }
 
-void NetInternalsMessageHandler::IOThreadImpl::DispatchToMessageHandler(
-    ListValue* arg, MessageHandler method) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  (this->*method)(arg);
-  delete arg;
-}
-
 // Note that this can be called from ANY THREAD.
 void NetInternalsMessageHandler::IOThreadImpl::SendJavascriptCommand(
     const std::string& command,
     Value* arg) {
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     if (handler_ && !was_webui_deleted_) {
       // We check |handler_| in case it was deleted on the UI thread earlier
       // while we were running on the IO thread.
       handler_->SendJavascriptCommand(command, arg);
     } else {
@@ skipping 153 matching lines @@
 }
 
 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);
   ChromeURLDataManager::AddDataSource(profile, CreateNetInternalsHTMLSource());
 }