Adds the ability to load JSON log files to about:net-internals.

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 <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 12 matching lines @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_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/connection_tester.h"
 #include "chrome/browser/net/passive_log_collector.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/shell_dialogs.h"
+#include "chrome/browser/tab_contents/tab_contents.h"
+#include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/net/url_request_context_getter.h"
 #include "chrome/common/url_constants.h"
 #include "grit/generated_resources.h"
 #include "grit/net_internals_resources.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/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/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 #ifdef OS_WIN
 #include "chrome/browser/net/service_providers_win.h"
 #endif
 
 namespace {
 
+// Delay between when an event occurs and when it is passed to the Javascript
+// page.  All events that occur during this period are grouped together and
+// sent to the page at once, which reduces context switching and CPU usage.
+const int kNetLogEventDelayMilliseconds = 100;
+
 // 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();
@@ skipping 55 matching lines @@
 // Note that the DOMUI 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
 // 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 DOMMessageHandler,
+      public SelectFileDialog::Listener,
       public base::SupportsWeakPtr<NetInternalsMessageHandler> {
  public:
   NetInternalsMessageHandler();
   virtual ~NetInternalsMessageHandler();
 
   // DOMMessageHandler implementation.
   virtual DOMMessageHandler* Attach(DOMUI* dom_ui);
   virtual void RegisterMessages();
 
   // Executes the javascript function |function_name| in the renderer, passing
   // it the argument |value|.
   void CallJavascriptFunction(const std::wstring& function_name,
                               const Value* value);
 
+  // SelectFileDialog::Listener implementation
+  virtual void FileSelected(const FilePath& path, int index, void* params);
+  virtual void FileSelectionCanceled(void* params);
+
+  // The only callback handled on the UI thread.  As it needs to access fields
+  // from |dom_ui_|, it can't be called on the IO thread.
+  void OnLoadLogFile(const ListValue* list);
+
  private:
   class IOThreadImpl;
 
+  // Task run on the FILE thread to read the contents of a log file.  The result
+  // is then passed to IOThreadImpl's CallJavascriptFunction, which sends it
+  // back to the web page.  IOThreadImpl is used instead of the
+  // NetInternalsMessageHandler directly because it checks if the message
+  // handler has been destroyed in the meantime.
+  class ReadLogFileTask : public Task {
+   public:
+    ReadLogFileTask(IOThreadImpl* proxy, const FilePath& path);
+
+    virtual void Run();
+
+   private:
+    // IOThreadImpl implements existence checks already.  Simpler to reused them
+    // then to reimplement them.
+    scoped_refptr<IOThreadImpl> proxy_;
+
+    // Path of the file to open.
+    const FilePath path_;
+  };
+
   // This is the "real" message handler, which lives on the IO thread.
   scoped_refptr<IOThreadImpl> proxy_;
 
+  // Used for loading log files.
+  scoped_refptr<SelectFileDialog> select_log_file_dialog_;
+
   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, OnDOMUIDeleted, and
 // CallJavascriptFunction, its methods are all expected to be called from the IO
 // thread.  OnAddEntry and CallJavascriptFunction can be called from any thread,
 // and OnDOMUIDeleted can only be called from the UI thread.
 class NetInternalsMessageHandler::IOThreadImpl
     : public base::RefCountedThreadSafe<
@@ skipping 67 matching lines @@
 
   // ConnectionTester::Delegate implementation:
   virtual void OnStartConnectionTestSuite();
   virtual void OnStartConnectionTestExperiment(
       const ConnectionTester::Experiment& experiment);
   virtual void OnCompletedConnectionTestExperiment(
       const ConnectionTester::Experiment& experiment,
       int result);
   virtual void OnCompletedConnectionTestSuite();
 
+  // Helper that executes |function_name| in the attached renderer.
+  // The function takes ownership of |arg|.  Note that this can be called from
+  // any thread.
+  void CallJavascriptFunction(const std::wstring& function_name, Value* arg);
+
  private:
   class CallbackHelper;
 
   // Helper that runs |method| with |arg|, and deletes |arg| on completion.
   void DispatchToMessageHandler(ListValue* arg, MessageHandler method);
 
-  // Helper that executes |function_name| in the attached renderer.
-  // The function takes ownership of |arg|.  Note that this can be called from
-  // any thread.
-  void CallJavascriptFunction(const std::wstring& function_name,
-                              Value* arg);
+  // 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);
+
+  // Sends all pending entries to the page via Javascript, and clears the list
+  // of pending entries.  Sending multiple entries at once results in a
+  // significant reduction of CPU usage when a lot of events are happening.
+  // Must be called on the IO Thread.
+  void PostPendingEntries();
 
   // 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_;
 
   scoped_refptr<URLRequestContextGetter> context_getter_;
 
   // Helper that runs the suite of connection tests.
   scoped_ptr<ConnectionTester> connection_tester_;
 
   // True if the DOM UI has been deleted.  This is used to prevent calling
   // Javascript functions after the DOM UI is destroyed.  On refresh, the
   // messages can end up being sent to the refreshed page, causing duplicate
   // or partial entries.
   //
   // This is only read and written to on the UI thread.
   bool was_domui_deleted_;
 
   // True if we have attached an observer to the NetLog already.
   bool is_observing_log_;
   friend class base::RefCountedThreadSafe<IOThreadImpl>;
+
+  // Log entries that have yet to be passed along to Javascript page.  Non-NULL
+  // when and only when there is a pending delayed task to call
+  // PostPendingEntries.  Read and written to exclusively on the IO Thread.
+  scoped_ptr<ListValue> pending_entries_;
 };
 
 // Helper class for a DOMUI::MessageCallback which when excuted calls
 // instance->*method(value) on the IO thread.
 class NetInternalsMessageHandler::IOThreadImpl::CallbackHelper
     : public DOMUI::MessageCallback {
  public:
   CallbackHelper(IOThreadImpl* instance, IOThreadImpl::MessageHandler method)
       : instance_(instance),
         method_(method) {
@@ skipping 85 matching lines @@
 
 NetInternalsMessageHandler::NetInternalsMessageHandler() {}
 
 NetInternalsMessageHandler::~NetInternalsMessageHandler() {
   if (proxy_) {
     proxy_.get()->OnDOMUIDeleted();
     // Notify the handler on the IO thread that the renderer is gone.
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
         NewRunnableMethod(proxy_.get(), &IOThreadImpl::Detach));
   }
+  if (select_log_file_dialog_)
+    select_log_file_dialog_->ListenerDestroyed();
 }
 
 DOMMessageHandler* NetInternalsMessageHandler::Attach(DOMUI* dom_ui) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::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::FileSelected(
+    const FilePath& path, int index, void* params) {
+  select_log_file_dialog_.release();
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      new ReadLogFileTask(proxy_.get(), path));
+}
+
+void NetInternalsMessageHandler::FileSelectionCanceled(void* params) {
+  select_log_file_dialog_.release();
+}
+
+void NetInternalsMessageHandler::OnLoadLogFile(const ListValue* list) {
+  // Only allow a single dialog at a time.
+  if (select_log_file_dialog_.get())
+    return;
+  select_log_file_dialog_ = SelectFileDialog::Create(this);
+  select_log_file_dialog_->SelectFile(
+      SelectFileDialog::SELECT_OPEN_FILE, string16(), FilePath(), NULL, 0,
+      FILE_PATH_LITERAL(""),
+      dom_ui_->tab_contents()->view()->GetTopLevelNativeWindow(), NULL);
+}
+
 void NetInternalsMessageHandler::RegisterMessages() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // Only callback handled on UI thread.
+  dom_ui_->RegisterMessageCallback("loadLogFile",

[eroman, 2011/01/24 20:45:56]

nit: can you break the line here, for consistency with the other
RegisterMessageCallback() lines?

[mmenke, 2011/01/25 20:08:13]

Done.  It also violated Google style guidelines.

+      NewCallback(this, &NetInternalsMessageHandler::OnLoadLogFile));
 
   dom_ui_->RegisterMessageCallback(
       "notifyReady",
       proxy_->CreateCallback(&IOThreadImpl::OnRendererReady));
   dom_ui_->RegisterMessageCallback(
       "getProxySettings",
       proxy_->CreateCallback(&IOThreadImpl::OnGetProxySettings));
   dom_ui_->RegisterMessageCallback(
       "reloadProxySettings",
       proxy_->CreateCallback(&IOThreadImpl::OnReloadProxySettings));
@@ skipping 41 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (value) {
     dom_ui_->CallJavascriptFunction(function_name, *value);
   } else {
     dom_ui_->CallJavascriptFunction(function_name);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
+// NetInternalsMessageHandler::ReadLogFileTask
+//
+////////////////////////////////////////////////////////////////////////////////
+
+NetInternalsMessageHandler::ReadLogFileTask::ReadLogFileTask(
+    IOThreadImpl* proxy, const FilePath& path)
+    : proxy_(proxy), path_(path) {
+}
+
+void NetInternalsMessageHandler::ReadLogFileTask::Run() {
+  std::string file_contents;
+  if (!file_util::ReadFileToString(path_, &file_contents))
+    return;
+  proxy_->CallJavascriptFunction(L"g_browser.loadedLogFile",
+                                 new StringValue(file_contents));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
 // NetInternalsMessageHandler::IOThreadImpl
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 NetInternalsMessageHandler::IOThreadImpl::IOThreadImpl(
     const base::WeakPtr<NetInternalsMessageHandler>& handler,
     IOThread* io_thread,
     URLRequestContextGetter* context_getter)
     : ThreadSafeObserver(net::NetLog::LOG_ALL_BUT_BYTES),
       handler_(handler),
@@ skipping 482 matching lines @@
 }
 
 // Note that unlike other methods of IOThreadImpl, this function
 // can be called from ANY THREAD.
 void NetInternalsMessageHandler::IOThreadImpl::OnAddEntry(
     net::NetLog::EventType type,
     const base::TimeTicks& time,
     const net::NetLog::Source& source,
     net::NetLog::EventPhase phase,
     net::NetLog::EventParameters* params) {
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      NewRunnableMethod(
+          this, &IOThreadImpl::AddEntryToQueue,
+          net::NetLog::EntryToDictionaryValue(type, time, source, phase,
+                                              params, false)));
+}
+
+void NetInternalsMessageHandler::IOThreadImpl::AddEntryToQueue(Value* entry) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (!pending_entries_.get()) {
+    pending_entries_.reset(new ListValue());
+    BrowserThread::PostDelayedTask(
+        BrowserThread::IO, FROM_HERE,
+        NewRunnableMethod(this, &IOThreadImpl::PostPendingEntries),
+        kNetLogEventDelayMilliseconds);
+  }
+  pending_entries_->Append(entry);
+}
+
+void NetInternalsMessageHandler::IOThreadImpl::PostPendingEntries() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   CallJavascriptFunction(
-      L"g_browser.receivedLogEntry",
-      net::NetLog::EntryToDictionaryValue(type, time, source, phase, params,
-                                          false));
+      L"g_browser.receivedLogEntries",
+      pending_entries_.release());
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnStartConnectionTestSuite() {
   CallJavascriptFunction(L"g_browser.receivedStartConnectionTestSuite", NULL);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnStartConnectionTestExperiment(
     const ConnectionTester::Experiment& experiment) {
   CallJavascriptFunction(
       L"g_browser.receivedStartConnectionTestExperiment",
@@ skipping 68 matching lines @@
   NetInternalsHTMLSource* html_source = new NetInternalsHTMLSource();
 
   // Set up the chrome://net-internals/ source.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           ChromeURLDataManager::GetInstance(),
           &ChromeURLDataManager::AddDataSource,
           make_scoped_refptr(html_source)));
 }