Move destruction of WebRtcLogUploader to post threads teardown.

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"
-#include "base/memory/shared_memory.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/media/webrtc_log_list.h"
 #include "chrome/browser/media/webrtc_log_util.h"
-#include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/partial_circular_buffer.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/mime_util.h"
-#include "net/base/network_delegate.h"
-#include "net/proxy/proxy_config.h"
-#include "net/proxy/proxy_config_service.h"
 #include "net/url_request/url_fetcher.h"
-#include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_context_builder.h"
-#include "net/url_request/url_request_context_getter.h"
 #include "third_party/zlib/zlib.h"
 
 namespace {
 
 const int kLogCountLimit = 5;
 const uint32 kIntermediateCompressionBufferBytes = 256 * 1024;  // 256 KB
 const int kLogListLimitLines = 50;
 
 const char kUploadURL[] = "https://clients2.google.com/cr/report";
 const char kUploadContentType[] = "multipart/form-data";
 const char kMultipartBoundary[] =
     "----**--yradnuoBgoLtrapitluMklaTelgooG--**----";
 
 const int kHttpResponseOk = 200;
 
 }  // namespace
 
 WebRtcLogUploadDoneData::WebRtcLogUploadDoneData() {}
 
 WebRtcLogUploadDoneData::~WebRtcLogUploadDoneData() {}
 
 WebRtcLogUploader::WebRtcLogUploader()
     : log_count_(0),
-      post_data_(NULL) {
+      post_data_(NULL),
+      shutting_down_(false) {
   file_thread_checker_.DetachFromThread();
 }
 
 WebRtcLogUploader::~WebRtcLogUploader() {
   DCHECK(create_thread_checker_.CalledOnValidThread());
-  // Delete all pending URLFetcher and release all references to
-  // WebRtcLoggingHandlerHost.
-  for (UploadDoneDataMap::iterator it = upload_done_data_.begin();
-       it != upload_done_data_.end(); ++it) {
-    delete it->first;
-  }
-  upload_done_data_.clear();
+  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();
-  std::string report_id;
   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,
           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);
   }
+
   delete source;
 }
 
 void WebRtcLogUploader::OnURLFetchUploadProgress(
     const net::URLFetcher* source, int64 current, int64 total) {
 }
 
 bool WebRtcLogUploader::ApplyForStartLogging() {
   DCHECK(create_thread_checker_.CalledOnValidThread());
-  if (log_count_ < kLogCountLimit) {
+  if (log_count_ < kLogCountLimit && !shutting_down_) {
     ++log_count_;
     return true;
   }
   return false;
 }
 
 void WebRtcLogUploader::LoggingStoppedDontUpload() {
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
       base::Bind(&WebRtcLogUploader::DecreaseLogCount, base::Unretained(this)));
 }
 
 void WebRtcLogUploader::LoggingStoppedDoUpload(
-    net::URLRequestContextGetter* request_context,
     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(log_buffer.get());
   DCHECK(!upload_done_data.log_path.empty());
 
   std::vector<uint8> compressed_log;
   CompressLog(
@@ skipping 31 matching lines @@
     *post_data_ = *post_data;
     NotifyUploadDone(kHttpResponseOk, "", upload_done_data_with_log_id);
     return;
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&WebRtcLogUploader::CreateAndStartURLFetcher,
                  base::Unretained(this),
-                 make_scoped_refptr(request_context),
                  upload_done_data_with_log_id,
                  Passed(&post_data)));
 
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
       base::Bind(&WebRtcLogUploader::DecreaseLogCount, base::Unretained(this)));
 }
 
+void WebRtcLogUploader::StartShutdown() {
+  DCHECK(create_thread_checker_.CalledOnValidThread());
+  DCHECK(!shutting_down_);
+
+  // Delete all URLFetchers first and clear the upload done map.
+  for (UploadDoneDataMap::iterator it = upload_done_data_.begin();
+       it != upload_done_data_.end();
+       ++it) {
+    delete it->first;
+  }
+  upload_done_data_.clear();
+  shutting_down_ = true;
+}
+
 void WebRtcLogUploader::SetupMultipart(
     std::string* post_data,
     const std::vector<uint8>& compressed_log,
     const std::map<std::string, std::string>& meta_data) {
 #if defined(OS_WIN)
   const char product[] = "Chrome";
 #elif defined(OS_MACOSX)
   const char product[] = "Chrome_Mac";
 #elif defined(OS_LINUX)
 #if !defined(ADDRESS_SANITIZER)
@@ skipping 90 matching lines @@
 
 void WebRtcLogUploader::ResizeForNextOutput(std::vector<uint8>* compressed_log,
                                             z_stream* stream) {
   size_t old_size = compressed_log->size() - stream->avail_out;
   compressed_log->resize(old_size + kIntermediateCompressionBufferBytes);
   stream->next_out = &(*compressed_log)[old_size];
   stream->avail_out = kIntermediateCompressionBufferBytes;
 }
 
 void WebRtcLogUploader::CreateAndStartURLFetcher(
-    scoped_refptr<net::URLRequestContextGetter> request_context,
     const WebRtcLogUploadDoneData& upload_done_data,
     scoped_ptr<std::string> post_data) {
   DCHECK(create_thread_checker_.CalledOnValidThread());
+
+  if (shutting_down_)
+    return;
+
   std::string content_type = kUploadContentType;
   content_type.append("; boundary=");
   content_type.append(kMultipartBoundary);
 
   net::URLFetcher* url_fetcher =
       net::URLFetcher::Create(GURL(kUploadURL), net::URLFetcher::POST, this);
-  url_fetcher->SetRequestContext(request_context);
+  url_fetcher->SetRequestContext(g_browser_process->system_request_context());
   url_fetcher->SetUploadData(content_type, *post_data);
   url_fetcher->Start();
   upload_done_data_[url_fetcher] = upload_done_data;
 }
 
 void WebRtcLogUploader::DecreaseLogCount() {
   DCHECK(create_thread_checker_.CalledOnValidThread());
   --log_count_;
 }
 
@@ skipping 102 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));
   }
 }