Initialize the new net internals page using the passively collected log entri...

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/passive_log_collector.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"
@@ skipping 11 matching lines @@
 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.
+// Serializes the specified event to a DictionaryValue.
+Value* EntryToDictionaryValue(net::NetLog::EventType type,
+                              const base::TimeTicks& time,
+                              const net::NetLog::Source& source,
+                              net::NetLog::EventPhase phase,
+                              net::NetLog::EventParameters* extra_parameters) {
+  DictionaryValue* entry_dict = new DictionaryValue();
+
+  // Set the entry time. (Note that we send it as a string since integers
+  // might overflow).
+  entry_dict->SetString(L"time", TickCountToString(time));
+
+  // Set the entry source.
+  DictionaryValue* source_dict = new DictionaryValue();
+  source_dict->SetInteger(L"id", source.id);
+  source_dict->SetInteger(L"type", static_cast<int>(source.type));
+  entry_dict->Set(L"source", source_dict);
+
+  // Set the event info.
+  entry_dict->SetInteger(L"type", static_cast<int>(type));
+  entry_dict->SetInteger(L"phase", static_cast<int>(phase));
+
+  // Set the event-specific parameters.
+  if (extra_parameters)
+    entry_dict->SetString(L"extra_parameters", extra_parameters->ToString());
+
+  return entry_dict;
+}
 
 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,
                                 bool is_off_the_record,
                                 int request_id);
@@ 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);
+  void OnGetPassiveLogEntries(const Value* value);
 
   // ChromeNetLog::Observer implementation:
   virtual void OnAddEntry(net::NetLog::EventType type,
                           const base::TimeTicks& time,
                           const net::NetLog::Source& source,
                           net::NetLog::EventPhase phase,
                           net::NetLog::EventParameters* extra_parameters);
 
  private:
   class CallbackHelper;
@@ skipping 121 matching lines @@
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   proxy_ = new IOThreadImpl(this->AsWeakPtr(), g_browser_process->io_thread(),
                             dom_ui->GetProfile()->GetRequestContext());
   DOMMessageHandler* result = DOMMessageHandler::Attach(dom_ui);
   return result;
 }
 
 void NetInternalsMessageHandler::RegisterMessages() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
-  dom_ui_->RegisterMessageCallback("notifyReady",
+  dom_ui_->RegisterMessageCallback(
+      "notifyReady",
       proxy_->CreateCallback(&IOThreadImpl::OnRendererReady));
-  dom_ui_->RegisterMessageCallback("getProxySettings",
+  dom_ui_->RegisterMessageCallback(
+      "getProxySettings",
       proxy_->CreateCallback(&IOThreadImpl::OnGetProxySettings));
-  dom_ui_->RegisterMessageCallback("reloadProxySettings",
+  dom_ui_->RegisterMessageCallback(
+      "reloadProxySettings",
       proxy_->CreateCallback(&IOThreadImpl::OnReloadProxySettings));
-  dom_ui_->RegisterMessageCallback("getBadProxies",
+  dom_ui_->RegisterMessageCallback(
+      "getBadProxies",
       proxy_->CreateCallback(&IOThreadImpl::OnGetBadProxies));
-  dom_ui_->RegisterMessageCallback("clearBadProxies",
+  dom_ui_->RegisterMessageCallback(
+      "clearBadProxies",
       proxy_->CreateCallback(&IOThreadImpl::OnClearBadProxies));
-  dom_ui_->RegisterMessageCallback("getHostResolverCache",
+  dom_ui_->RegisterMessageCallback(
+      "getHostResolverCache",
       proxy_->CreateCallback(&IOThreadImpl::OnGetHostResolverCache));
-  dom_ui_->RegisterMessageCallback("clearHostResolverCache",
+  dom_ui_->RegisterMessageCallback(
+      "clearHostResolverCache",
       proxy_->CreateCallback(&IOThreadImpl::OnClearHostResolverCache));
+  dom_ui_->RegisterMessageCallback(
+      "getPassiveLogEntries",
+      proxy_->CreateCallback(&IOThreadImpl::OnGetPassiveLogEntries));
 }
 
 void NetInternalsMessageHandler::CallJavascriptFunction(
     const std::wstring& function_name,
     const Value& value) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   dom_ui_->CallJavascriptFunction(function_name, value);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 103 matching lines @@
     //               be part of the time library.
     const int64 kUnixEpochMs = 11644473600000LL;
     int64 tick_to_unix_time_ms = tick_to_time_ms - kUnixEpochMs;
 
     // 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.
+  OnGetPassiveLogEntries(NULL);
   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();
 
@@ skipping 118 matching lines @@
   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::OnGetPassiveLogEntries(
+    const Value* value) {
+  ChromeNetLog* net_log = io_thread_->globals()->net_log.get();
+
+  PassiveLogCollector::EntryList passive_entries;
+  net_log->passive_collector()->GetAllCapturedEvents(&passive_entries);
+
+  ListValue* list = new ListValue();
+  for (size_t i = 0; i < passive_entries.size(); ++i) {
+    const PassiveLogCollector::Entry& e = passive_entries[i];
+    list->Append(EntryToDictionaryValue(e.type,
+                                        e.time,
+                                        e.source,
+                                        e.phase,
+                                        e.extra_parameters));
+  }
+
+  CallJavascriptFunction(L"g_browser.receivedPassiveLogEntries", list);
+}
+
 void NetInternalsMessageHandler::IOThreadImpl::OnAddEntry(
     net::NetLog::EventType type,
     const base::TimeTicks& time,
     const net::NetLog::Source& source,
     net::NetLog::EventPhase phase,
     net::NetLog::EventParameters* extra_parameters) {
   DCHECK(is_observing_log_);
 
-  // JSONify the NetLog::Entry.
-  // TODO(eroman): Need a better format for this.
-  DictionaryValue* entry_dict = new DictionaryValue();
-
-  // Set the entry time. (Note that we send it as a string since integers
-  // might overflow).
-  entry_dict->SetString(L"time", TickCountToString(time));
-
-  // Set the entry source.
-  DictionaryValue* source_dict = new DictionaryValue();
-  source_dict->SetInteger(L"id", source.id);
-  source_dict->SetInteger(L"type", static_cast<int>(source.type));
-  entry_dict->Set(L"source", source_dict);
-
-  // Set the event info.
-  entry_dict->SetInteger(L"type", static_cast<int>(type));
-  entry_dict->SetInteger(L"phase", static_cast<int>(phase));
-
-  // Set the event-specific parameters.
-  if (extra_parameters)
-    entry_dict->SetString(L"extra_parameters", extra_parameters->ToString());
-
-  CallJavascriptFunction(L"g_browser.receivedLogEntry", entry_dict);
+  CallJavascriptFunction(
+      L"g_browser.receivedLogEntry",
+      EntryToDictionaryValue(type, time, source, phase, extra_parameters));
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::DispatchToMessageHandler(
     Value* arg, MessageHandler method) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   (this->*method)(arg);
   delete arg;
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::CallJavascriptFunction(
     const std::wstring& function_name,
     Value* arg) {
   if (ChromeThread::CurrentlyOn(ChromeThread::UI)) {
     if (handler_) {
       // We check |handler_| in case it was deleted on the UI thread earlier
       // while we were running on the IO thread.
       handler_->CallJavascriptFunction(function_name, *arg);
     }
     delete arg;
     return;
   }
 
-
   // Otherwise if we were called from the IO thread, bridge the request over to
   // the UI thread.
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   if (!ChromeThread::PostTask(
            ChromeThread::UI, FROM_HERE,
            NewRunnableMethod(
                this,
                &IOThreadImpl::CallJavascriptFunction,
                function_name, arg))) {
@@ skipping 17 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)));
 }