Fixed location for debug logs.

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 77 matching lines @@
 #include "chromeos/network/onc/onc_certificate_importer_impl.h"
 #include "chromeos/network/onc/onc_utils.h"
 #endif
 #if defined(OS_WIN)
 #include "chrome/browser/net/service_providers_win.h"
 #endif
 
 using base::PassPlatformFile;
 using base::PlatformFile;
 using base::PlatformFileError;
+using base::StringValue;
 using content::BrowserThread;
 using content::WebContents;
 using content::WebUIMessageHandler;
 
 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;
@@ skipping 258 matching lines @@
     DCHECK(posted);
     return;
   }
   PlatformFile platform_file = pass_platform_file.ReleaseValue();
   chromeos::DBusThreadManager::Get()->GetDebugDaemonClient()->GetDebugLogs(
       platform_file,
       base::Bind(&WriteDebugLogToFileCompleted,
           callback, PassPlatformFile(&platform_file), file_path));
 }
 
-// Stores debug logs in the .tgz archive on the fileshelf. The file is
-// created on the worker pool, then writing to it is triggered from
+// Stores debug logs in the .tgz archive on the |fileshelf|. The file
+// is created on the worker pool, then writing to it is triggered from
 // the UI thread, and finally it is closed (on success) or deleted (on
 // failure) on the worker pool, prior to calling |callback|.
-void StoreDebugLogs(const StoreDebugLogsCallback& callback) {
+void StoreDebugLogs(const base::FilePath& fileshelf,
+                    const StoreDebugLogsCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
-  const base::FilePath fileshelf = DownloadPrefs::GetDefaultDownloadDirectory();
   DebugLogFileHelper* helper = new DebugLogFileHelper();
   bool posted = base::WorkerPool::PostTaskAndReply(FROM_HERE,
       base::Bind(&DebugLogFileHelper::DoWork,
           base::Unretained(helper), fileshelf),
       base::Bind(&DebugLogFileHelper::Reply, base::Owned(helper),
           base::Bind(&WriteDebugLogToFile, callback)), false);
   DCHECK(posted);
 }
 #endif  // defined(OS_CHROMEOS)
 
@@ skipping 437 matching lines @@
   web_ui()->RegisterMessageCallback(
       "setNetworkDebugMode",
       base::Bind(&NetInternalsMessageHandler::OnSetNetworkDebugMode,
                  base::Unretained(this)));
 #endif
 }
 
 void NetInternalsMessageHandler::SendJavascriptCommand(
     const std::string& command,
     Value* arg) {
-  scoped_ptr<Value> command_value(Value::CreateStringValue(command));
+  scoped_ptr<Value> command_value(new StringValue(command));
   scoped_ptr<Value> value(arg);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (value.get()) {
     web_ui()->CallJavascriptFunction("g_browser.receive",
                                      *command_value.get(),
                                      *value.get());
   } else {
     web_ui()->CallJavascriptFunction("g_browser.receive",
                                      *command_value.get());
   }
@@ skipping 717 matching lines @@
 
     std::string network_error;
     chromeos::onc::ImportNetworksForUser(user, network_configs, &network_error);
     if (!network_error.empty())
       error += network_error;
   } else {
     error = "No active user.";
   }
 
   LOG_IF(ERROR, !error.empty()) << error;
-  SendJavascriptCommand("receivedONCFileParse",
-                        Value::CreateStringValue(error));
+  SendJavascriptCommand("receivedONCFileParse", new StringValue(error));
 }
 
 void NetInternalsMessageHandler::OnStoreDebugLogs(const ListValue* list) {
   DCHECK(list);
-  StoreDebugLogs(
+
+  SendJavascriptCommand("receivedStoreDebugLogs",
+                        new StringValue("Creating log file..."));
+  StoreDebugLogs(DownloadPrefs(Profile::FromWebUI(web_ui())).DownloadPath(),

[mmenke, 2013/11/13 22:27:16]

Should we be using
DownloadPrefs:::FromBrowserContext(Profile::FromWebUI(web_ui())), rather than
creating a new download prefs object?

[ygorshenin1, 2013/11/13 23:55:36]

Done.

       base::Bind(&NetInternalsMessageHandler::OnStoreDebugLogsCompleted,
                  AsWeakPtr()));
 }
 
 void NetInternalsMessageHandler::OnStoreDebugLogsCompleted(
     const base::FilePath& log_path, bool succeeded) {
   std::string status;
   if (succeeded)
     status = "Created log file: " + log_path.BaseName().AsUTF8Unsafe();
   else
     status = "Failed to create log file";
-  SendJavascriptCommand("receivedStoreDebugLogs",
-                        Value::CreateStringValue(status));
+  SendJavascriptCommand("receivedStoreDebugLogs", new StringValue(status));
 }
 
 void NetInternalsMessageHandler::OnSetNetworkDebugMode(const ListValue* list) {
   std::string subsystem;
   if (list->GetSize() != 1 || !list->GetString(0, &subsystem))
     NOTREACHED();
   chromeos::DBusThreadManager::Get()->GetDebugDaemonClient()->
       SetDebugMode(
           subsystem,
           base::Bind(
               &NetInternalsMessageHandler::OnSetNetworkDebugModeCompleted,
               AsWeakPtr(),
               subsystem));
 }
 
 void NetInternalsMessageHandler::OnSetNetworkDebugModeCompleted(
     const std::string& subsystem,
     bool succeeded) {
   std::string status;
   if (succeeded)
     status = "Debug mode is changed to " + subsystem;
   else
     status = "Failed to change debug mode to " + subsystem;
-  SendJavascriptCommand("receivedSetNetworkDebugMode",
-                        Value::CreateStringValue(status));
+  SendJavascriptCommand("receivedSetNetworkDebugMode", new StringValue(status));
 }
 #endif  // defined(OS_CHROMEOS)
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetHttpPipeliningStatus(
     const ListValue* list) {
   DCHECK(!list);
   DictionaryValue* status_dict = new DictionaryValue();
 
   Value* pipelined_connection_info = NULL;
   net::HttpNetworkSession* http_network_session =
@@ skipping 242 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);
   content::WebUIDataSource::Add(profile, CreateNetInternalsHTMLSource());
 }