Implements RTP header dumping.

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 18 matching lines @@
 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;
 
+// Adds the header section for a gzip file to the multipart |post_data|.
+void AddMultipartFileContentHeader(std::string* post_data,
+                                   const std::string& content_name,
+                                   const std::string& file_name) {
+  post_data->append("--");
+  post_data->append(kMultipartBoundary);
+  post_data->append("\r\nContent-Disposition: form-data; name=\"");
+  post_data->append(content_name);
+  post_data->append("\"; filename=\"");
+  post_data->append(file_name);
+  post_data->append("\"\r\nContent-Type: application/gzip\r\n\r\n");
+}
+
+// Adds |compressed_log| to |post_data|.
+void AddLogData(std::string* post_data,
+                const std::vector<uint8>& compressed_log) {
+  AddMultipartFileContentHeader(post_data, "webrtc_log", "webrtc_log.gz");
+  post_data->append(reinterpret_cast<const char*>(&compressed_log[0]),
+                    compressed_log.size());
+  post_data->append("\r\n");
+}
+
+// Adds the RTP dump data to |post_data|.
+void AddRtpDumpData(std::string* post_data,
+                    const std::string& name,
+                    const std::string& dump_data) {
+  AddMultipartFileContentHeader(post_data, name, name + ".gz");

[vrk (LEFT CHROMIUM), 2014/05/28 23:55:07]

nit: I'd suggest you remove the |file_name| parameter and append the ".gz" in
AddMultipartFileContentHeader, since AddMultipartFileContentHeader always uses
Content-Type: application/gzip.

+  post_data->append(dump_data.data(), dump_data.size());
+  post_data->append("\r\n");
+}
+
 }  // namespace
 
+WebRtcRtpDumpDescription::WebRtcRtpDumpDescription(const std::string& name,
+                                                   const base::FilePath& path)
+    : name(name), path(path) {
+}
+
 WebRtcLogUploadDoneData::WebRtcLogUploadDoneData() {}
 
 WebRtcLogUploadDoneData::~WebRtcLogUploadDoneData() {}
 
 WebRtcLogUploader::WebRtcLogUploader()
     : log_count_(0),
       post_data_(NULL),
       shutting_down_(false) {
   file_thread_checker_.DetachFromThread();
 }
@@ skipping 11 matching lines @@
   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()) {
+      // TODO(jiayl): Add the RTP dump records to chrome://webrtc-logs.
       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));
@@ skipping 50 matching lines @@
     base::FilePath log_list_path =
         WebRtcLogList::GetWebRtcLogListFileForDirectory(
             upload_done_data.log_path);
     AddLocallyStoredLogInfoToUploadListFile(log_list_path, local_log_id);
   }
 
   WebRtcLogUploadDoneData upload_done_data_with_log_id = upload_done_data;
   upload_done_data_with_log_id.local_log_id = local_log_id;
 
   scoped_ptr<std::string> post_data(new std::string());
-  SetupMultipart(post_data.get(), compressed_log, meta_data);
+  SetupMultipart(
+      post_data.get(), compressed_log, upload_done_data.rtp_dumps, meta_data);
 
   // If a test has set the test string pointer, write to it and skip uploading.
   // Still fire the upload callback so that we can run an extension API test
   // using the test framework for that without hanging.
   // TODO(grunell): Remove this when the api test for this feature is fully
   // implemented according to the test plan. http://crbug.com/257329.
   if (post_data_) {
     *post_data_ = *post_data;
     NotifyUploadDone(kHttpResponseOk, "", upload_done_data_with_log_id);
     return;
@@ skipping 21 matching lines @@
        ++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::vector<WebRtcRtpDumpDescription>& rtp_dumps,
     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";
@@ skipping 16 matching lines @@
                                   "", 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, compressed_log);
+
+  // Add the rtp dumps if any.
+  for (std::vector<WebRtcRtpDumpDescription>::const_iterator it =
+           rtp_dumps.begin();
+       it != rtp_dumps.end();
+       ++it) {
+    if (it->path.empty() || !base::PathExists(it->path)) {
+      LOG(WARNING) << "Unexpected empty RTP dump.";
+      break;
+    }
+
+    std::string dump_data;
+    if (base::ReadFileToString(it->path, &dump_data))
+      AddRtpDumpData(post_data, it->name, dump_data);

[vrk (LEFT CHROMIUM), 2014/05/28 23:55:07]

Instead of defining "rtpdump_recv" in WebRtcLoggingHandlerHost, I think you
should create kIncomingRtpDumpName and kOutgoingRtpDumpName, so you don't have
to worry about things like if the caller puts a space in the name, or uses the
same name twice.

+  }
+
   net::AddMultipartFinalDelimiterForUpload(kMultipartBoundary, post_data);
 }
 
-void WebRtcLogUploader::AddLogData(std::string* post_data,
-                                   const std::vector<uint8>& compressed_log) {
-  post_data->append("--");
-  post_data->append(kMultipartBoundary);
-  post_data->append("\r\n");
-  post_data->append("Content-Disposition: form-data; name=\"webrtc_log\"");
-  post_data->append("; filename=\"webrtc_log.gz\"\r\n");
-  post_data->append("Content-Type: application/gzip\r\n\r\n");
-  post_data->append(reinterpret_cast<const char*>(&compressed_log[0]),
-                    compressed_log.size());
-  post_data->append("\r\n");
-}
-
 void WebRtcLogUploader::CompressLog(std::vector<uint8>* compressed_log,
                                     uint8* input,
                                     uint32 input_size) {
   PartialCircularBuffer read_pcb(input, input_size);
 
   z_stream stream = {0};
   int result = deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
                             // windowBits = 15 is default, 16 is added to
                             // produce a gzip header + trailer.
                             15 + 16,
@@ skipping 171 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));
   }
 }