Add support for attaching custom parameters to NetLog events.

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"
@@ skipping 134 matching lines @@
   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);
+  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;
 
   // Helper that runs |method| with |arg|, and deletes |arg| on completion.
   void DispatchToMessageHandler(Value* arg, MessageHandler method);
 
   // Helper that executes |function_name| in the attached renderer.
   // The function takes ownership of |arg|.
   void CallJavascriptFunction(const std::wstring& function_name,
@@ skipping 226 matching lines @@
     dict->SetInteger(L"NONE", net::NetLog::SOURCE_NONE);
     dict->SetInteger(L"URL_REQUEST", net::NetLog::SOURCE_URL_REQUEST);
     dict->SetInteger(L"SOCKET_STREAM", net::NetLog::SOURCE_SOCKET_STREAM);
     dict->SetInteger(L"INIT_PROXY_RESOLVER",
                      net::NetLog::SOURCE_INIT_PROXY_RESOLVER);
     dict->SetInteger(L"CONNECT_JOB", net::NetLog::SOURCE_CONNECT_JOB);
 
     CallJavascriptFunction(L"g_browser.receivedLogSourceTypeConstants", dict);
   }
 
-  // Tell the javascript about the relationship between entry type enums and
-  // their symbolic name.
-  {
-    DictionaryValue* dict = new DictionaryValue();
-
-    dict->SetInteger(L"TYPE_EVENT", net::NetLog::Entry::TYPE_EVENT);
-    dict->SetInteger(L"TYPE_STRING", net::NetLog::Entry::TYPE_STRING);
-    dict->SetInteger(L"TYPE_ERROR_CODE", net::NetLog::Entry::TYPE_ERROR_CODE);
-
-    CallJavascriptFunction(L"g_browser.receivedLogEntryTypeConstants", dict);
-  }
-
   // Tell the javascript how the "time ticks" values we have given it relate to
   // actual system times. (We used time ticks throughout since they are stable
   // across system clock changes).
   {
     int64 cur_time_ms = (base::Time::Now() - base::Time()).InMilliseconds();
 
     int64 cur_time_ticks_ms =
         (base::TimeTicks::Now() - base::TimeTicks()).InMilliseconds();
 
     // If we add this number to a time tick value, it gives the timestamp.
@@ skipping 145 matching lines @@
       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) {
+    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 type.
-  {
-    net::NetLog::Entry::Type entry_type = entry.type;
-    if (entry_type == net::NetLog::Entry::TYPE_STRING_LITERAL)
-      entry_type = net::NetLog::Entry::TYPE_STRING;
-    entry_dict->SetInteger(L"type", static_cast<int>(entry_type));
-  }
-
   // Set the entry time. (Note that we send it as a string since integers
   // might overflow).
-  entry_dict->SetString(L"time", TickCountToString(entry.time));
+  entry_dict->SetString(L"time", TickCountToString(time));
 
   // Set the entry source.
   DictionaryValue* source_dict = new DictionaryValue();
-  source_dict->SetInteger(L"id", entry.source.id);
-  source_dict->SetInteger(L"type", static_cast<int>(entry.source.type));
+  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 (if it is an event entry).
-  if (entry.type == net::NetLog::Entry::TYPE_EVENT) {
-    DictionaryValue* event_dict = new DictionaryValue();
-    event_dict->SetInteger(L"type", static_cast<int>(entry.event.type));
-    event_dict->SetInteger(L"phase", static_cast<int>(entry.event.phase));
-    entry_dict->Set(L"event", event_dict);
-  }
+  // Set the event info.
+  entry_dict->SetInteger(L"type", static_cast<int>(type));
+  entry_dict->SetInteger(L"phase", static_cast<int>(phase));
 
-  // Add the string information (events my have a string too, due to current
-  // hacks).
-  if (entry.type == net::NetLog::Entry::TYPE_STRING || !entry.string.empty()) {
-    entry_dict->SetString(L"string", entry.string);
-  }
-
-  // Treat string literals the same as strings.
-  if (entry.type == net::NetLog::Entry::TYPE_STRING_LITERAL) {
-    entry_dict->SetString(L"string", entry.literal);
-  }
-
-  if (entry.type == net::NetLog::Entry::TYPE_ERROR_CODE) {
-    entry_dict->SetInteger(L"error_code", entry.error_code);
-  }
+  // Set the event-specific parameters.
+  if (extra_parameters)
+    entry_dict->SetString(L"extra_parameters", extra_parameters->ToString());
 
   CallJavascriptFunction(L"g_browser.receivedLogEntry", entry_dict);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::DispatchToMessageHandler(
     Value* arg, MessageHandler method) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   (this->*method)(arg);
   delete arg;
 }
@@ skipping 42 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)));
 }