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_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_upload_list.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
 
 WebRtcLogUploader::WebRtcLogUploader()
     : log_count_(0),
       post_data_(NULL) {
   file_thread_checker_.DetachFromThread();
 }
 
 WebRtcLogUploader::~WebRtcLogUploader() {

[Ami GONE FROM CHROMIUM, 2014/03/25 17:53:17]

DCHECK the vector is empty.

[Henrik Grunell, 2014/03/26 06:59:02]

Done.

   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();
 }
 
 void WebRtcLogUploader::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(create_thread_checker_.CalledOnValidThread());
   DCHECK(upload_done_data_.find(source) != upload_done_data_.end());
   int response_code = source->GetResponseCode();
   std::string report_id;
   if (response_code == kHttpResponseOk &&
       source->GetResponseAsString(&report_id)) {
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&WebRtcLogUploader::AddUploadedLogInfoToUploadListFile,
                  base::Unretained(this),
                  upload_done_data_[source].upload_list_path,
                  report_id));
   }
   NotifyUploadDone(response_code, report_id, upload_done_data_[source]);
   upload_done_data_.erase(source);
-  delete source;
+
+  bool found_in_vector = false;
+  for (URLFetcherVector::iterator it = url_fetchers_.begin();
+       it != url_fetchers_.end();
+       ++it) {

[Ami GONE FROM CHROMIUM, 2014/03/25 17:53:17]

It's a vector, so you could
for (size_t i = 0; i < url_fetchers_.size(); ++i)
and save a couple of lines.

[Henrik Grunell, 2014/03/26 06:59:02]

Done.

+    if (*it == source) {
+      url_fetchers_.erase(it);
+      found_in_vector = true;

[Ami GONE FROM CHROMIUM, 2014/03/25 17:53:17]

can drop found_in_vector+break in favor of a return, and then LOG+delete
unconditionally outside the loop.

[Henrik Grunell, 2014/03/26 06:59:02]

Done.

+      break;
+    }
+  }
+  if (!found_in_vector) {
+    DLOG(WARNING) << "URLFetcher not found in vector.";

[Ami GONE FROM CHROMIUM, 2014/03/25 17:53:17]

Can this happen if there is a fetch in flight while Cancel is called?  If so,
seems unworthy of a warning.
If this reflects a programming error then it should be a DCHECK (and drop the
explicit delete).

[Henrik Grunell, 2014/03/26 06:59:02]

Right. This should really not happen if cancelled. Changed it to NOTREACHED.

+    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) {
     ++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.upload_list_path.empty());
 
   scoped_ptr<std::string> post_data;
   post_data.reset(new std::string);
@@ skipping 10 matching lines @@
   if (post_data_) {
     *post_data_ = *post_data;
     NotifyUploadDone(kHttpResponseOk, "", upload_done_data);
     return;
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&WebRtcLogUploader::CreateAndStartURLFetcher,
                  base::Unretained(this),
-                 make_scoped_refptr(request_context),
                  upload_done_data,
                  Passed(&post_data)));
 
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
       base::Bind(&WebRtcLogUploader::DecreaseLogCount, base::Unretained(this)));
 }
 
+void WebRtcLogUploader::CancelURLFetcherOperations() {
+  DCHECK(create_thread_checker_.CalledOnValidThread());
+  url_fetchers_.clear();
+}
+
 void WebRtcLogUploader::SetupMultipart(
     std::string* post_data, uint8* log_buffer, uint32 log_buffer_length,
     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)
   const char product[] = "Chrome_Linux";
@@ skipping 91 matching lines @@
 
 void WebRtcLogUploader::ResizeForNextOutput(std::string* post_data,
                                             z_stream* stream) {
   size_t old_size = post_data->size() - stream->avail_out;
   post_data->resize(old_size + kIntermediateCompressionBufferBytes);
   stream->next_out = reinterpret_cast<uint8*>(&(*post_data)[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());
   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);
+  scoped_ptr<net::URLFetcher> url_fetcher(
+      net::URLFetcher::Create(GURL(kUploadURL), net::URLFetcher::POST, this));
+  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;
+  upload_done_data_[url_fetcher.get()] = upload_done_data;
+  url_fetchers_.push_back(url_fetcher.Pass());
 }
 
 void WebRtcLogUploader::DecreaseLogCount() {
   DCHECK(create_thread_checker_.CalledOnValidThread());
   --log_count_;
 }
 
 void WebRtcLogUploader::AddUploadedLogInfoToUploadListFile(
     const base::FilePath& upload_list_path,
     const std::string& report_id) {
@@ skipping 43 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));
   }
 }