First cut at UI for saving net_logs data into a temporary file on

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 18 matching lines @@
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/chrome_network_delegate.h"
 #include "chrome/browser/net/connection_tester.h"
+#include "chrome/browser/net/net_log_temp_file.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_data_source.h"
 #include "chrome/common/cancelable_task_tracker.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_version_info.h"
@@ skipping 453 matching lines @@
   void OnRunIPv6Probe(const ListValue* list);
   void OnClearHostResolverCache(const ListValue* list);
   void OnEnableIPv6(const ListValue* list);
   void OnStartConnectionTests(const ListValue* list);
   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 OnGetSessionNetworkStats(const ListValue* list);
+  void OnGetMobileNetLogInfo(const ListValue* list);
+  void OnStartNetLog(const ListValue* list);
+  void OnStopNetLog(const ListValue* list);
+  void OnSendNetLog(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);
 #if defined(OS_WIN)
   void OnGetServiceProviders(const ListValue* list);
 #endif
   void OnGetHttpPipeliningStatus(const ListValue* list);
   void OnSetLogLevel(const ListValue* list);
@@ skipping 32 matching lines @@
 
   // 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();
 
   // Adds entries with the states of ongoing URL requests.
   void PrePopulateEventList();
 
+  // Calls NetLogTempFile's ProcessCommand and updates the MobileNetLogInfo.
+  void ProcessNetLogCommand(NetLogTempFile::Command command);
+
   net::URLRequestContext* GetMainContext() {
     return main_context_getter_->GetURLRequestContext();
   }
 
   // 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_;
@@ skipping 122 matching lines @@
                  &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(
+      "getMobileNetLogInfo",
+      base::Bind(&IOThreadImpl::CallbackHelper,
+                 &IOThreadImpl::OnGetMobileNetLogInfo, proxy_));
+  web_ui()->RegisterMessageCallback(
+      "startNetLog",
+      base::Bind(&IOThreadImpl::CallbackHelper,
+                 &IOThreadImpl::OnStartNetLog, proxy_));
+  web_ui()->RegisterMessageCallback(
+      "stopNetLog",
+      base::Bind(&IOThreadImpl::CallbackHelper,
+                 &IOThreadImpl::OnStopNetLog, proxy_));
+  web_ui()->RegisterMessageCallback(
+      "sendNetLog",
+      base::Bind(&IOThreadImpl::CallbackHelper,
+                 &IOThreadImpl::OnSendNetLog, 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,
@@ skipping 243 matching lines @@
   // |method| cannot take ownership of |list_copy|.
   ListValue* list_copy = (list && list->GetSize()) ? list->DeepCopy() : NULL;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(method, io_thread, base::Owned(list_copy)));
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::Detach() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // Cancel any in-progress requests to collect net_log into temporary file.
+  NetLogTempFile::GetInstance()->ProcessCommand(NetLogTempFile::DO_STOP);
+
   // Unregister with network stack to observe events.
   if (net_log())
     net_log()->RemoveThreadSafeObserver(this);
 
   // Cancel any in-progress connection tests.
   connection_tester_.reset();
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnWebUIDeleted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 364 matching lines @@
 void NetInternalsMessageHandler::IOThreadImpl::OnFlushSocketPools(
     const ListValue* list) {
   DCHECK(!list);
   net::HttpNetworkSession* http_network_session =
       GetHttpNetworkSession(GetMainContext());
 
   if (http_network_session)
     http_network_session->CloseAllConnections();
 }
 
+void NetInternalsMessageHandler::IOThreadImpl::OnGetMobileNetLogInfo(
+    const ListValue* list) {
+  DCHECK(!list);
+  SendJavascriptCommand("receivedMobileNetLogInfo",
+                        NetLogTempFile::GetInstance()->NetLogTempFileToValue());
+}
+
+void NetInternalsMessageHandler::IOThreadImpl::OnStartNetLog(
+    const ListValue* list) {
+  DCHECK(!list);
+  ProcessNetLogCommand(NetLogTempFile::DO_START);
+}
+
+void NetInternalsMessageHandler::IOThreadImpl::OnStopNetLog(
+    const ListValue* list) {
+  DCHECK(!list);
+  ProcessNetLogCommand(NetLogTempFile::DO_STOP);
+}
+
+void NetInternalsMessageHandler::IOThreadImpl::OnSendNetLog(
+    const ListValue* list) {
+  DCHECK(!list);
+  ProcessNetLogCommand(NetLogTempFile::DO_SEND);
+}
+
 void NetInternalsMessageHandler::IOThreadImpl::OnCloseIdleSockets(
     const ListValue* list) {
   DCHECK(!list);
   net::HttpNetworkSession* http_network_session =
       GetHttpNetworkSession(GetMainContext());
 
   if (http_network_session)
     http_network_session->CloseIdleConnections();
 }
 
@@ skipping 319 matching lines @@
   if (!BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&IOThreadImpl::SendJavascriptCommand, this, command, arg))) {
     // Failed posting the task, avoid leaking.
     delete arg;
   }
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::AddEntryToQueue(Value* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+#if !defined(OS_IOS)

[mmenke, 2012/12/27 20:43:05]

This seems a somewhat random thing to exclude on iOS.  The events view may be
useful on the larger screen of iPods, no?  Are you just worried about memory
usage?

[ramant (doing other things), 2013/01/04 01:47:28]

Added code in JavaScript not to store pending_entries.

Our intention was not to use memory in IOS where we run in single process mode.

Done.

   if (!pending_entries_.get()) {
     pending_entries_.reset(new ListValue());
     BrowserThread::PostDelayedTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&IOThreadImpl::PostPendingEntries, this),
         base::TimeDelta::FromMilliseconds(kNetLogEventDelayMilliseconds));
   }
   pending_entries_->Append(entry);
+#endif
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::PostPendingEntries() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (pending_entries_.get())
     SendJavascriptCommand("receivedLogEntries", pending_entries_.release());
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::PrePopulateEventList() {
   // Use a set to prevent duplicates.
@@ skipping 40 matching lines @@
                              &callback,
                              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::ProcessNetLogCommand(
+    NetLogTempFile::Command command) {
+  NetLogTempFile::GetInstance()->ProcessCommand(command);
+  SendJavascriptCommand("receivedMobileNetLogInfo",
+                        NetLogTempFile::GetInstance()->NetLogTempFileToValue());
+}
+
 }  // namespace
 
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // NetInternalsUI
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 // static
@@ skipping 143 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());
 }