Convert WebRtcLoggingHandlerHost to use the blocking thread pool.

chrome/browser/media/webrtc_logging_handler_host.cc

 // Copyright 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/media/webrtc_logging_handler_host.h"
 
 #include <string>
 
 #include "base/bind.h"
-#include "base/command_line.h"
 #include "base/cpu.h"
 #include "base/file_util.h"
 #include "base/logging.h"
-#include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/media/webrtc_log_list.h"
 #include "chrome/browser/media/webrtc_log_uploader.h"
 #include "chrome/browser/media/webrtc_rtp_dump_handler.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/common/media/webrtc_logging_messages.h"
 #include "chrome/common/partial_circular_buffer.h"
-#include "chrome/common/pref_names.h"
-#include "chromeos/settings/cros_settings_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/render_process_host.h"
 #include "gpu/config/gpu_info.h"
 #include "net/base/address_family.h"
 #include "net/url_request/url_request_context_getter.h"
 
 #if defined(OS_LINUX)
 #include "base/linux_util.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #endif
 
 #if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/system/statistics_provider.h"
 #endif
 
 using base::IntToString;
 using content::BrowserThread;
 
 namespace {
 
 #if defined(OS_ANDROID)
 const size_t kWebRtcLogSize = 1 * 1024 * 1024;  // 1 MB
@@ skipping 75 matching lines @@
     meta_data_ = meta_data;
   } else if (logging_state_ == STARTED) {
     meta_data_ = meta_data;
     std::string meta_data_message;
     FormatMetaDataAsLogMessage(meta_data_, &meta_data_message);
     LogToCircularBuffer(meta_data_message);
   } else {
     error_message = "Meta data must be set before stop or upload.";
   }
   bool success = error_message.empty();
-  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-                                   base::Bind(callback, success,
-                                              error_message));
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(callback, success, error_message));
 }
 
 void WebRtcLoggingHandlerHost::StartLogging(
     const GenericDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   start_callback_ = callback;
   if (logging_state_ != CLOSED) {
     FireGenericDoneCallback(&start_callback_, false, "A log is already open");
@@ skipping 17 matching lines @@
   logging_state_ = STOPPING;
   Send(new WebRtcLoggingMsg_StopLogging());
 }
 
 void WebRtcLoggingHandlerHost::UploadLog(const UploadDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   if (logging_state_ != STOPPED) {
     if (!callback.is_null()) {
-      content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           base::Bind(callback, false, "", kLogNotStoppedOrNoLogOpen));
     }
     return;
   }
 
   upload_callback_ = callback;
   logging_state_ = UPLOADING;
-  content::BrowserThread::PostTaskAndReplyWithResult(
-      content::BrowserThread::FILE,
+  base::PostTaskAndReplyWithResult(
+      BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
                  this),
       base::Bind(&WebRtcLoggingHandlerHost::TriggerUpload, this));
 }
 
 void WebRtcLoggingHandlerHost::UploadLogDone() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   logging_state_ = CLOSED;
 }
@@ skipping 32 matching lines @@
     const GenericDoneCallback& callback,
     const content::RenderProcessHost::WebRtcStopRtpDumpCallback&
         stop_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(stop_rtp_dump_callback_.is_null() ||
          stop_rtp_dump_callback_.Equals(stop_callback));
 
   stop_rtp_dump_callback_ = stop_callback;
 
   if (!rtp_dump_handler_) {
-    content::BrowserThread::PostTaskAndReplyWithResult(
-        content::BrowserThread::FILE,
+    base::PostTaskAndReplyWithResult(
+        BrowserThread::GetBlockingPool(),
         FROM_HERE,
         base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
                    this),
         base::Bind(&WebRtcLoggingHandlerHost::CreateRtpDumpHandlerAndStart,
                    this,
                    type,
                    callback));
     return;
   }
 
@@ skipping 46 matching lines @@
                  incoming));
 }
 
 void WebRtcLoggingHandlerHost::DumpRtpPacketOnIOThread(
     scoped_ptr<uint8[]> packet_header,
     size_t header_length,
     size_t packet_length,
     bool incoming) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  // |rtp_dump_handler_| could be NULL if we are waiting for the FILE thread to
-  // create/ensure the log directory.
+  // |rtp_dump_handler_| could be NULL if we are waiting for the blocking
+  // thread pool to create/ensure the log directory.
   if (rtp_dump_handler_) {
     rtp_dump_handler_->OnRtpPacket(
         packet_header.get(), header_length, packet_length, incoming);
   }
 }
 
 void WebRtcLoggingHandlerHost::OnChannelClosing() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (logging_state_ == STARTED || logging_state_ == STOPPED) {
     if (upload_log_on_render_close_) {
       logging_state_ = UPLOADING;
       logging_started_time_ = base::Time();
-
-      content::BrowserThread::PostTaskAndReplyWithResult(
-          content::BrowserThread::FILE,
+      base::PostTaskAndReplyWithResult(
+          BrowserThread::GetBlockingPool(),
           FROM_HERE,
           base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
                      this),
           base::Bind(&WebRtcLoggingHandlerHost::TriggerUpload, this));
     } else {
       g_browser_process->webrtc_log_uploader()->LoggingStoppedDontUpload();
     }
   }
-  content::BrowserMessageFilter::OnChannelClosing();
+  BrowserMessageFilter::OnChannelClosing();
 }
 
 void WebRtcLoggingHandlerHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 bool WebRtcLoggingHandlerHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebRtcLoggingHandlerHost, message)
@@ skipping 54 matching lines @@
 void WebRtcLoggingHandlerHost::DoStartLogging() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   log_buffer_.reset(new unsigned char[kWebRtcLogSize]);
   circular_buffer_.reset(
     new PartialCircularBuffer(log_buffer_.get(),
                               kWebRtcLogSize,
                               kWebRtcLogSize / 2,
                               false));
 
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::LogInitialInfoOnFileThread, this));
+  BrowserThread::PostBlockingPoolTask(
+      FROM_HERE,
+      base::Bind(&WebRtcLoggingHandlerHost::LogInitialInfoOnBlockingPool,
+                 this));
 }
 
-void WebRtcLoggingHandlerHost::LogInitialInfoOnFileThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+void WebRtcLoggingHandlerHost::LogInitialInfoOnBlockingPool() {
+  DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
   net::NetworkInterfaceList network_list;
   net::GetNetworkList(&network_list,
                       net::EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES);
 
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::LogInitialInfoOnIOThread, this, network_list));
+  std::string linux_distro;
+#if defined(OS_LINUX)
+  linux_distro = base::GetLinuxDistro();
+#endif
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&WebRtcLoggingHandlerHost::LogInitialInfoOnIOThread,
+                 this,
+                 network_list,
+                 linux_distro));
 }
 
 void WebRtcLoggingHandlerHost::LogInitialInfoOnIOThread(
-    const net::NetworkInterfaceList& network_list) {
+    const net::NetworkInterfaceList& network_list,
+    const std::string& linux_distro) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Log start time (current time). We don't use base/i18n/time_formatting.h
   // here because we don't want the format of the current locale.
   base::Time::Exploded now = {0};
   base::Time::Now().LocalExplode(&now);
   LogToCircularBuffer(base::StringPrintf(
       "Start %d-%02d-%02d %02d:%02d:%02d", now.year, now.month,
       now.day_of_month, now.hour, now.minute, now.second));
 
   // Write metadata if received before logging started.
   if (!meta_data_.empty()) {
     std::string info;
     FormatMetaDataAsLogMessage(meta_data_, &info);
     LogToCircularBuffer(info);
   }
 
   // OS
   LogToCircularBuffer(base::SysInfo::OperatingSystemName() + " " +
                       base::SysInfo::OperatingSystemVersion() + " " +
                       base::SysInfo::OperatingSystemArchitecture());
 #if defined(OS_LINUX)
-  LogToCircularBuffer("Linux distribution: " + base::GetLinuxDistro());
+  LogToCircularBuffer("Linux distribution: " + linux_distro);
 #endif
 
   // CPU
   base::CPU cpu;
   LogToCircularBuffer(
       "Cpu: " + IntToString(cpu.family()) + "." + IntToString(cpu.model()) +
       "." + IntToString(cpu.stepping()) + ", x" +
       IntToString(base::SysInfo::NumberOfProcessors()) + ", " +
       IntToString(base::SysInfo::AmountOfPhysicalMemoryMB()) + "MB");
   std::string cpu_brand = cpu.cpu_brand();
@@ skipping 50 matching lines @@
 
 void WebRtcLoggingHandlerHost::LogToCircularBuffer(const std::string& message) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(circular_buffer_.get());
   circular_buffer_->Write(message.c_str(), message.length());
   const char eol = '\n';
   circular_buffer_->Write(&eol, 1);
 }
 
 base::FilePath WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   base::FilePath log_dir_path =
       WebRtcLogList::GetWebRtcLogDirectoryForProfile(profile_->GetPath());
   base::File::Error error;
   if (!base::CreateDirectoryAndGetError(log_dir_path, &error)) {
     DLOG(ERROR) << "Could not create WebRTC log directory, error: " << error;
     return base::FilePath();
   }
   return log_dir_path;
 }
 
@@ skipping 30 matching lines @@
     upload_done_data.outgoing_rtp_dump = rtp_dumps.outgoing_dump_path;
 
     rtp_dump_handler_.reset();
     stop_rtp_dump_callback_.Reset();
   }
 
   upload_done_data.callback = upload_callback_;
   upload_done_data.host = this;
   upload_callback_.Reset();
 
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
-      &WebRtcLogUploader::LoggingStoppedDoUpload,
-      base::Unretained(g_browser_process->webrtc_log_uploader()),
-      Passed(&log_buffer_),
-      kWebRtcLogSize,
-      meta_data_,
-      upload_done_data));
+  BrowserThread::PostBlockingPoolTask(
+      FROM_HERE,
+      base::Bind(&WebRtcLogUploader::LoggingStoppedDoUpload,
+                 base::Unretained(g_browser_process->webrtc_log_uploader()),
+                 Passed(&log_buffer_),
+                 kWebRtcLogSize,
+                 meta_data_,
+                 upload_done_data));
 
   meta_data_.clear();
   circular_buffer_.reset();
 }
 
 void WebRtcLoggingHandlerHost::FireGenericDoneCallback(
     GenericDoneCallback* callback,
     bool success,
     const std::string& error_message) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(!(*callback).is_null());
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(*callback, success, error_message));
-  (*callback).Reset();
+  DCHECK(!callback->is_null());
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(*callback, success, error_message));
+  callback->Reset();
 }
 
 void WebRtcLoggingHandlerHost::CreateRtpDumpHandlerAndStart(
     RtpDumpType type,
     GenericDoneCallback callback,
     const base::FilePath& dump_dir) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // |rtp_dump_handler_| may be non-NULL if StartRtpDump is called again before
-  // GetLogDirectoryAndEnsureExists returns on the FILE thread for a previous
-  // StartRtpDump.
+  // GetLogDirectoryAndEnsureExists returns on the blocking thread pool for a
+  // previous StartRtpDump.
   if (!rtp_dump_handler_)
     rtp_dump_handler_.reset(new WebRtcRtpDumpHandler(dump_dir));
 
   DoStartRtpDump(type, &callback);
 }
 
 void WebRtcLoggingHandlerHost::DoStartRtpDump(RtpDumpType type,
                                               GenericDoneCallback* callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(rtp_dump_handler_);
 
   std::string error;
 
   bool result = rtp_dump_handler_->StartDump(type, &error);
   FireGenericDoneCallback(callback, result, error);
 }