Convert WebRtcLoggingHandlerHost to use the blocking thread pool.

chrome/browser/media/webrtc_log_uploader.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_log_uploader.h"
 
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 28 matching lines @@
 }  // namespace
 
 WebRtcLogUploadDoneData::WebRtcLogUploadDoneData() {}
 
 WebRtcLogUploadDoneData::~WebRtcLogUploadDoneData() {}
 
 WebRtcLogUploader::WebRtcLogUploader()
     : log_count_(0),
       post_data_(NULL),
       shutting_down_(false) {
-  file_thread_checker_.DetachFromThread();
+  blocking_sequence_checker_.DetachFromSequence();
 }
 
 WebRtcLogUploader::~WebRtcLogUploader() {
   DCHECK(create_thread_checker_.CalledOnValidThread());
   DCHECK(upload_done_data_.empty());
   DCHECK(shutting_down_);
 }
 
 void WebRtcLogUploader::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(create_thread_checker_.CalledOnValidThread());
   DCHECK(upload_done_data_.find(source) != upload_done_data_.end());
   DCHECK(!shutting_down_);
   int response_code = source->GetResponseCode();
   UploadDoneDataMap::iterator it = upload_done_data_.find(source);
   if (it != upload_done_data_.end()) {
     // The log path can be empty here if we failed getting it before. We still
     // upload the log if that's the case.
     std::string report_id;
     if (response_code == kHttpResponseOk &&
         source->GetResponseAsString(&report_id) &&
         !it->second.log_path.empty()) {
       base::FilePath log_list_path =
           WebRtcLogList::GetWebRtcLogListFileForDirectory(it->second.log_path);
-      content::BrowserThread::PostTask(
-          content::BrowserThread::FILE,
+      content::BrowserThread::PostBlockingPoolTask(
           FROM_HERE,
           base::Bind(&WebRtcLogUploader::AddUploadedLogInfoToUploadListFile,
                      base::Unretained(this),
                      log_list_path,
                      it->second.local_log_id,
                      report_id));
     }
     NotifyUploadDone(response_code, report_id, it->second);
     upload_done_data_.erase(it);
   }
@@ skipping 17 matching lines @@
 void WebRtcLogUploader::LoggingStoppedDontUpload() {
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
       base::Bind(&WebRtcLogUploader::DecreaseLogCount, base::Unretained(this)));
 }
 
 void WebRtcLogUploader::LoggingStoppedDoUpload(
     scoped_ptr<unsigned char[]> log_buffer,
     uint32 length,
     const std::map<std::string, std::string>& meta_data,
     const WebRtcLogUploadDoneData& upload_done_data) {
-  DCHECK(file_thread_checker_.CalledOnValidThread());
+  DCHECK(blocking_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(log_buffer.get());
   DCHECK(!upload_done_data.log_path.empty());
 
   std::vector<uint8> compressed_log;
   CompressLog(
       &compressed_log, reinterpret_cast<uint8*>(&log_buffer[0]), length);
 
   std::string local_log_id;
 
   if (base::PathExists(upload_done_data.log_path)) {
@@ skipping 184 matching lines @@
 }
 
 void WebRtcLogUploader::DecreaseLogCount() {
   DCHECK(create_thread_checker_.CalledOnValidThread());
   --log_count_;
 }
 
 void WebRtcLogUploader::WriteCompressedLogToFile(
     const std::vector<uint8>& compressed_log,
     const base::FilePath& log_file_path) {
-  DCHECK(file_thread_checker_.CalledOnValidThread());
+  DCHECK(blocking_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!compressed_log.empty());
   base::WriteFile(log_file_path,
                   reinterpret_cast<const char*>(&compressed_log[0]),
                   compressed_log.size());
 }
 
 void WebRtcLogUploader::AddLocallyStoredLogInfoToUploadListFile(
     const base::FilePath& upload_list_path,
     const std::string& local_log_id) {
-  DCHECK(file_thread_checker_.CalledOnValidThread());
+  DCHECK(blocking_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!upload_list_path.empty());
   DCHECK(!local_log_id.empty());
 
   std::string contents;
 
   if (base::PathExists(upload_list_path)) {
     if (!base::ReadFileToString(upload_list_path, &contents)) {
       DPLOG(WARNING) << "Could not read WebRTC log list file.";
       return;
     }
@@ skipping 23 matching lines @@
   if (written != static_cast<int>(contents.size())) {
     DPLOG(WARNING) << "Could not write all data to WebRTC log list file: "
                    << written;
   }
 }
 
 void WebRtcLogUploader::AddUploadedLogInfoToUploadListFile(
     const base::FilePath& upload_list_path,
     const std::string& local_log_id,
     const std::string& report_id) {
-  DCHECK(file_thread_checker_.CalledOnValidThread());
+  DCHECK(blocking_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!upload_list_path.empty());
   DCHECK(!local_log_id.empty());
   DCHECK(!report_id.empty());
 
   std::string contents;
 
   if (base::PathExists(upload_list_path)) {
     if (!base::ReadFileToString(upload_list_path, &contents)) {
       DPLOG(WARNING) << "Could not read WebRTC log list file.";
       return;
@@ skipping 34 matching lines @@
     if (!success) {
       error_message = "Uploading failed, response code: " +
                       base::IntToString(response_code);
     }
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
         base::Bind(upload_done_data.callback, success, report_id,
                    error_message));
   }
 }