Hook up WebRTC logging extension API to the underlying functionality.

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"
@@ skipping 40 matching lines @@
 }
 
 WebRtcLogUploader::~WebRtcLogUploader() {}
 
 void WebRtcLogUploader::OnURLFetchComplete(
     const net::URLFetcher* source) {
   int response_code = source->GetResponseCode();
   std::string report_id;
   if (response_code == 200 && source->GetResponseAsString(&report_id))
     AddUploadedLogInfoToUploadListFile(report_id);
+  DCHECK(upload_done_data_.find(source) != upload_done_data_.end());
+  content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&WebRtcLoggingHandlerHost::UploadLogDone,
+                 upload_done_data_[source].host));
+  if (!upload_done_data_[source].callback.is_null()) {
+    bool success = response_code == 200;
+    std::string error_message;
+    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_[source].callback, success, report_id,
+                   error_message));
+  }
+  upload_done_data_.erase(source);
 }
 
 void WebRtcLogUploader::OnURLFetchUploadProgress(
     const net::URLFetcher* source, int64 current, int64 total) {
 }
 
 bool WebRtcLogUploader::ApplyForStartLogging() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (log_count_ < kLogCountLimit) {
     ++log_count_;
     return true;
   }
   return false;
 }
 
-void WebRtcLogUploader::UploadLog(net::URLRequestContextGetter* request_context,
-                                  scoped_ptr<base::SharedMemory> shared_memory,
-                                  uint32 length,
-                                  const std::string& app_session_id,
-                                  const std::string& app_url) {
+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<base::SharedMemory> shared_memory,
+    uint32 length,
+    const std::map<std::string, std::string>& meta_data,
+    const WebRtcLogUploadDoneData& upload_done_data) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
   DCHECK(shared_memory);
   DCHECK(shared_memory->memory());
 
   std::string post_data;
   SetupMultipart(&post_data, reinterpret_cast<uint8*>(shared_memory->memory()),
-                 length, app_session_id, app_url);
+                 length, meta_data);
 
   // If a test has set the test string pointer, write to it and skip uploading.
   // This will be removed when the browser test for this feature is fully done
   // according to the test plan. See http://crbug.com/257329.
   if (post_data_) {
     *post_data_ = post_data;
     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->SetUploadData(content_type, post_data);
   url_fetcher->Start();
+  upload_done_data_[url_fetcher] = upload_done_data;
 
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
       base::Bind(&WebRtcLogUploader::DecreaseLogCount, base::Unretained(this)));
 }
 
-void WebRtcLogUploader::SetupMultipart(std::string* post_data,
-                                       uint8* log_buffer,
-                                       uint32 log_buffer_length,
-                                       const std::string& app_session_id,
-                                       const std::string& app_url) {
+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";
 #else
   const char product[] = "Chrome_Linux_ASan";
 #endif
 #elif defined(OS_ANDROID)
   const char product[] = "Chrome_Android";
 #elif defined(OS_CHROMEOS)
   const char product[] = "Chrome_ChromeOS";
 #else
   // This file should not be compiled for other platforms.
   COMPILE_ASSERT(false);
 #endif
   net::AddMultipartValueForUpload("prod", product, kMultipartBoundary,
                                   "", post_data);
   chrome::VersionInfo version_info;
   net::AddMultipartValueForUpload("ver", version_info.Version(),
                                   kMultipartBoundary, "", post_data);
   net::AddMultipartValueForUpload("guid", "0", kMultipartBoundary,
                                   "", post_data);
   net::AddMultipartValueForUpload("type", "webrtc_log", kMultipartBoundary,
                                   "", post_data);
-  net::AddMultipartValueForUpload("app_session_id", app_session_id,
-                                  kMultipartBoundary, "", post_data);
-  net::AddMultipartValueForUpload("url", app_url, kMultipartBoundary,
-                                  "", post_data);
+
+  // Add custom meta data.
+  std::map<std::string, std::string>::const_iterator it = meta_data.begin();
+  for (; it != meta_data.end(); ++it) {
+    net::AddMultipartValueForUpload(it->first, it->second, kMultipartBoundary,
+                                    "", post_data);
+  }
+
   AddLogData(post_data, log_buffer, log_buffer_length);
   net::AddMultipartFinalDelimiterForUpload(kMultipartBoundary, post_data);
 }
 
 void WebRtcLogUploader::AddLogData(std::string* post_data,
                                    uint8* log_buffer,
                                    uint32 log_buffer_length) {
   post_data->append("--");
   post_data->append(kMultipartBoundary);
   post_data->append("\r\n");
@@ skipping 91 matching lines @@
 
   // Write the Unix time and report ID to the log list file.
   base::Time time_now = base::Time::Now();
   contents += base::DoubleToString(time_now.ToDoubleT()) +
               "," + report_id + '\n';
 
   int written = file_util::WriteFile(upload_list_path_, &contents[0],
                                      contents.size());
   DPCHECK(written == static_cast<int>(contents.size()));
 }