Update about:net-internals to use Javascript for loading logs.

chrome/browser/ui/webui/net_internals_ui.cc

 // Copyright (c) 2011 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_ui.h"
 
 #include <algorithm>
 #include <list>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/command_line.h"
-#include "base/file_util.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.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/prefs/pref_member.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/ui/shell_dialogs.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_thread.h"
-#include "content/browser/tab_contents/tab_contents.h"
-#include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/common/notification_details.h"
+#include "content/common/notification_type.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/base/x509_cert_types.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_alternate_protocols.h"
@@ skipping 91 matching lines @@
 // 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 SelectFileDialog::Listener,
       public base::SupportsWeakPtr<NetInternalsMessageHandler>,
       public NotificationObserver {
  public:
   NetInternalsMessageHandler();
   virtual ~NetInternalsMessageHandler();
 
   // WebUIMessageHandler implementation.
   virtual WebUIMessageHandler* Attach(WebUI* web_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);
 
   // NotificationObserver implementation.
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // Javascript message handlers.
   void OnRendererReady(const ListValue* list);
   void OnEnableHttpThrottling(const ListValue* list);
 #ifdef OS_CHROMEOS
   void OnRefreshSystemLogs(const ListValue* list);
   void OnGetSystemLog(const ListValue* list);
 #endif
 
-  // 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 |web_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_;
-  };
-
 #ifdef 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:
@@ skipping 51 matching lines @@
   scoped_ptr<WebUI::MessageCallback> renderer_ready_io_callback_;
 
   // This is the "real" message handler, which lives on the IO thread.
   scoped_refptr<IOThreadImpl> proxy_;
 
 #ifdef OS_CHROMEOS
   // Class that handles getting and filtering system logs.
   scoped_ptr<SystemLogsGetter> syslogs_getter_;
 #endif
 
-  // 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, OnWebUIDeleted, and
 // CallJavascriptFunction, its methods are all expected to be called from the IO
 // thread.  OnAddEntry and CallJavascriptFunction can be called from any thread,
 // and OnWebUIDeleted can only be called from the UI thread.
 class NetInternalsMessageHandler::IOThreadImpl
     : public base::RefCountedThreadSafe<
@@ skipping 230 matching lines @@
 
 NetInternalsMessageHandler::NetInternalsMessageHandler() {}
 
 NetInternalsMessageHandler::~NetInternalsMessageHandler() {
   if (proxy_) {
     proxy_.get()->OnWebUIDeleted();
     // 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();
 }
 
 WebUIMessageHandler* NetInternalsMessageHandler::Attach(WebUI* web_ui) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   PrefService* pref_service = web_ui->GetProfile()->GetPrefs();
   http_throttling_enabled_.Init(prefs::kHttpThrottlingEnabled, pref_service,
                                 this);
 
   proxy_ = new IOThreadImpl(this->AsWeakPtr(), g_browser_process->io_thread(),
                             web_ui->GetProfile()->GetRequestContext());
 #ifdef OS_CHROMEOS
   syslogs_getter_.reset(new SystemLogsGetter(this,
       chromeos::SystemAccess::GetInstance()));
 #endif
   renderer_ready_io_callback_.reset(
       proxy_->CreateCallback(&IOThreadImpl::OnRendererReady));
 
   WebUIMessageHandler* result = WebUIMessageHandler::Attach(web_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(""), web_ui_->tab_contents(),
-      web_ui_->tab_contents()->view()->GetTopLevelNativeWindow(), NULL);
-}
-
 void NetInternalsMessageHandler::RegisterMessages() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  // Only callback handled on UI thread.
-  web_ui_->RegisterMessageCallback(
-      "loadLogFile",
-      NewCallback(this, &NetInternalsMessageHandler::OnLoadLogFile));
-
   web_ui_->RegisterMessageCallback(
       "notifyReady",
       NewCallback(this, &NetInternalsMessageHandler::OnRendererReady));
   web_ui_->RegisterMessageCallback(
       "getProxySettings",
       proxy_->CreateCallback(&IOThreadImpl::OnGetProxySettings));
   web_ui_->RegisterMessageCallback(
       "reloadProxySettings",
       proxy_->CreateCallback(&IOThreadImpl::OnReloadProxySettings));
   web_ui_->RegisterMessageCallback(
@@ skipping 109 matching lines @@
 
   bool enable = false;
   if (!list->GetBoolean(0, &enable)) {
     NOTREACHED();
     return;
   }
 
   http_throttling_enabled_.SetValue(enable);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-//
-// 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));
-}
-
 #ifdef OS_CHROMEOS
 ////////////////////////////////////////////////////////////////////////////////
 //
 // NetInternalsMessageHandler::SystemLogsGetter
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 NetInternalsMessageHandler::SystemLogsGetter::SystemLogsGetter(
     NetInternalsMessageHandler* handler,
     chromeos::SystemAccess* system_access)
@@ skipping 878 matching lines @@
 // NetInternalsUI
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 NetInternalsUI::NetInternalsUI(TabContents* contents) : ChromeWebUI(contents) {
   AddMessageHandler((new NetInternalsMessageHandler())->Attach(this));
 
   NetInternalsHTMLSource* html_source = new NetInternalsHTMLSource();
 
   // Set up the chrome://net-internals/ source.
-  contents->profile()->GetChromeURLDataManager()->AddDataSource(html_source);
+  GetProfile()->GetChromeURLDataManager()->AddDataSource(html_source);
 }