Add ongoing events to net-export log when logging starts

chrome/browser/ui/webui/net_export_ui.cc

 // Copyright (c) 2013 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_export_ui.h"
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/scoped_observer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_prefs.h"
+#include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/net_export_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/common/url_constants.h"
 #include "components/grit/components_resources.h"
 #include "components/net_log/chrome_net_log.h"
 #include "components/net_log/net_export_ui_constants.h"
 #include "components/net_log/net_log_file_writer.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/browser/url_data_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/browser/web_ui_message_handler.h"
+#include "extensions/features/features.h"
 #include "net/log/net_log_capture_mode.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/shell_dialogs/select_file_dialog.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/android/intent_helper.h"
 #endif
 
 using content::BrowserThread;
 using content::WebContents;
 using content::WebUIMessageHandler;
 
 namespace {
 
+class ProxyScriptFetcherContextGetter : public net::URLRequestContextGetter {
+ public:
+  explicit ProxyScriptFetcherContextGetter(IOThread* io_thread)
+      : io_thread_(io_thread) {}
+
+  // net::URLRequestContextGetter implementation.

[eroman, 2017/02/24 00:17:38]

[optional] I suggest removing this comment and the same one below (class is so
simple this feels like clutter)

[wangyix1, 2017/02/24 00:58:07]

Done.

+  net::URLRequestContext* GetURLRequestContext() override {
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
+    DCHECK(io_thread_->globals()->proxy_script_fetcher_context.get());
+    return io_thread_->globals()->proxy_script_fetcher_context.get();
+  }
+
+  // net::URLRequestContextGetter implementation.
+  scoped_refptr<base::SingleThreadTaskRunner> GetNetworkTaskRunner()
+      const override {
+    return BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
+  }
+
+ protected:
+  ~ProxyScriptFetcherContextGetter() override {}
+
+ private:
+  IOThread* const io_thread_;  // Owned by BrowserProcess.
+};
+
 // May only be accessed on the UI thread
 base::LazyInstance<base::FilePath>::Leaky
     last_save_dir = LAZY_INSTANCE_INITIALIZER;
 
 content::WebUIDataSource* CreateNetExportHTMLSource() {
   content::WebUIDataSource* source =
       content::WebUIDataSource::Create(chrome::kChromeUINetExportHost);
 
   source->SetJsonPath("strings.js");
   source->AddResourcePath(net_log::kNetExportUIJS, IDR_NET_LOG_NET_EXPORT_JS);
@@ skipping 33 matching lines @@
   // ui::SelectFileDialog::Listener implementation.
   void FileSelected(const base::FilePath& path,
                     int index,
                     void* params) override;
   void FileSelectionCanceled(void* params) override;
 
   // net_log::NetLogFileWriter::StateObserver implementation.
   void OnNewState(const base::DictionaryValue& state) override;
 
  private:
+  using URLRequestContextGetterList =
+      std::vector<scoped_refptr<net::URLRequestContextGetter>>;
+
   // Send NetLog data via email.
   static void SendEmail(const base::FilePath& file_to_send);
 
   // chrome://net-export can be used on both mobile and desktop platforms.
   // On mobile a user cannot pick where their NetLog file is saved to.
   // Instead, everything is saved on the user's temp directory. Thus the
   // mobile user has the UI available to send their NetLog file as an
   // email while the desktop user, who gets to choose their NetLog file's
   // location, does not. Furthermore, since every time a user starts logging
   // to a new NetLog file on mobile platforms it overwrites the previous
   // NetLog file, a warning message appears on the Start Logging button
   // that informs the user of this. This does not exist on the desktop
   // UI.
   static bool UsingMobileUI();
 
   // Calls NetExportView.onExportNetLogInfoChanged JavaScript function in the
   // renderer, passing in |file_writer_state|.
   void NotifyUIWithState(std::unique_ptr<base::DictionaryValue> state);
 
   // Opens the SelectFileDialog UI with the default path to save a
   // NetLog file.
   void ShowSelectFileDialog(const base::FilePath& default_path);
 
+  // Returns a list of context getters used to retrieve ongoing events when
+  // logging starts so that net log entries can be added for those events.
+  URLRequestContextGetterList GetURLRequestContexts() const;
+
   // Cache of g_browser_process->net_log()->net_log_file_writer(). This
   // is owned by ChromeNetLog which is owned by BrowserProcessImpl.
   net_log::NetLogFileWriter* file_writer_;
 
   ScopedObserver<net_log::NetLogFileWriter,
                  net_log::NetLogFileWriter::StateObserver>
       state_observer_manager_;
 
   // The capture mode the user chose in the UI when logging started is cached
   // here and is read after a file path is chosen in the save dialog.
@@ skipping 61 matching lines @@
 void NetExportMessageHandler::OnStartNetLog(const base::ListValue* list) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::string capture_mode_string;
   bool result = list->GetString(0, &capture_mode_string);
   DCHECK(result);
 
   capture_mode_ =
       net_log::NetLogFileWriter::CaptureModeFromString(capture_mode_string);
 
   if (UsingMobileUI()) {
-    file_writer_->StartNetLog(base::FilePath(), capture_mode_);
+    file_writer_->StartNetLog(base::FilePath(), capture_mode_,
+                              GetURLRequestContexts());
   } else {
     base::FilePath initial_dir = last_save_dir.Pointer()->empty() ?
         DownloadPrefs::FromBrowserContext(
             web_ui()->GetWebContents()->GetBrowserContext())->DownloadPath() :
         *last_save_dir.Pointer();
     base::FilePath initial_path =
         initial_dir.Append(FILE_PATH_LITERAL("chrome-net-export-log.json"));
     ShowSelectFileDialog(initial_path);
   }
 }
@@ skipping 31 matching lines @@
 }
 
 void NetExportMessageHandler::FileSelected(const base::FilePath& path,
                                            int index,
                                            void* params) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(select_file_dialog_);
   select_file_dialog_ = nullptr;
   *last_save_dir.Pointer() = path.DirName();
 
-  file_writer_->StartNetLog(path, capture_mode_);
+  file_writer_->StartNetLog(path, capture_mode_, GetURLRequestContexts());
 }
 
 void NetExportMessageHandler::FileSelectionCanceled(void* params) {
   DCHECK(select_file_dialog_);
   select_file_dialog_ = nullptr;
 }
 
 void NetExportMessageHandler::OnNewState(const base::DictionaryValue& state) {
   NotifyUIWithState(state.CreateDeepCopy());
 }
@@ skipping 47 matching lines @@
   select_file_dialog_ = ui::SelectFileDialog::Create(
       this, new ChromeSelectFilePolicy(webcontents));
   ui::SelectFileDialog::FileTypeInfo file_type_info;
   file_type_info.extensions = {{FILE_PATH_LITERAL("json")}};
   gfx::NativeWindow owning_window = webcontents->GetTopLevelNativeWindow();
   select_file_dialog_->SelectFile(
       ui::SelectFileDialog::SELECT_SAVEAS_FILE, base::string16(), default_path,
       &file_type_info, 0, base::FilePath::StringType(), owning_window, nullptr);
 }
 
+NetExportMessageHandler::URLRequestContextGetterList
+NetExportMessageHandler::GetURLRequestContexts() const {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  URLRequestContextGetterList context_getters;
+
+  Profile* profile = Profile::FromWebUI(web_ui());
+
+  context_getters.push_back(profile->GetRequestContext());
+  context_getters.push_back(
+      content::BrowserContext::GetDefaultStoragePartition(profile)
+          ->GetMediaURLRequestContext());
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+  context_getters.push_back(profile->GetRequestContextForExtensions());
+#endif
+  context_getters.push_back(
+      g_browser_process->io_thread()->system_url_request_context_getter());
+  context_getters.push_back(
+      new ProxyScriptFetcherContextGetter(g_browser_process->io_thread()));
+
+  return context_getters;
+}
+
 }  // namespace
 
 NetExportUI::NetExportUI(content::WebUI* web_ui) : WebUIController(web_ui) {
   web_ui->AddMessageHandler(base::MakeUnique<NetExportMessageHandler>());
 
   // Set up the chrome://net-export/ source.
   Profile* profile = Profile::FromWebUI(web_ui);
   content::WebUIDataSource::Add(profile, CreateNetExportHTMLSource());
 }