src/chrome/browser/media/webrtc_log_uploader.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/media/webrtc_log_uploader.h"
   6
   7 #include "base/files/file_enumerator.h"
   8 #include "base/files/file_path.h"
   9 #include "base/files/file_util.h"
  10 #include "base/logging.h"
  11 #include "base/path_service.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/strings/string_split.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/time/time.h"
  16 #include "chrome/browser/browser_process.h"
  17 #include "chrome/browser/media/webrtc_log_list.h"
  18 #include "chrome/browser/media/webrtc_log_util.h"
  19 #include "chrome/common/chrome_version_info.h"
  20 #include "chrome/common/partial_circular_buffer.h"
  21 #include "content/public/browser/browser_thread.h"
  22 #include "net/base/mime_util.h"
  23 #include "net/url_request/url_fetcher.h"
  24 #include "third_party/zlib/zlib.h"
  25
  26 namespace {
  27
  28 const int kLogCountLimit = 5;
  29 const uint32 kIntermediateCompressionBufferBytes = 256 * 1024;  // 256 KB
  30 const int kLogListLimitLines = 50;
  31
  32 const char kUploadURL[] = "https://clients2.google.com/cr/report";
  33 const char kUploadContentType[] = "multipart/form-data";
  34 const char kMultipartBoundary[] =
  35     "----**--yradnuoBgoLtrapitluMklaTelgooG--**----";
  36
  37 const int kHttpResponseOk = 200;
  38
  39 // Adds the header section for a gzip file to the multipart |post_data|.
  40 void AddMultipartFileContentHeader(std::string* post_data,
  41                                    const std::string& content_name) {
  42   post_data->append("--");
  43   post_data->append(kMultipartBoundary);
  44   post_data->append("\r\nContent-Disposition: form-data; name=\"");
  45   post_data->append(content_name);
  46   post_data->append("\"; filename=\"");
  47   post_data->append(content_name + ".gz");
  48   post_data->append("\"\r\nContent-Type: application/gzip\r\n\r\n");
  49 }
  50
  51 // Adds |compressed_log| to |post_data|.
  52 void AddLogData(std::string* post_data,
  53                 const std::vector<uint8>& compressed_log) {
  54   AddMultipartFileContentHeader(post_data, "webrtc_log");
  55   post_data->append(reinterpret_cast<const char*>(&compressed_log[0]),
  56                     compressed_log.size());
  57   post_data->append("\r\n");
  58 }
  59
  60 // Adds the RTP dump data to |post_data|.
  61 void AddRtpDumpData(std::string* post_data,
  62                     const std::string& name,
  63                     const std::string& dump_data) {
  64   AddMultipartFileContentHeader(post_data, name);
  65   post_data->append(dump_data.data(), dump_data.size());
  66   post_data->append("\r\n");
  67 }
  68
  69 }  // namespace
  70
  71 WebRtcLogUploadDoneData::WebRtcLogUploadDoneData() {}
  72
  73 WebRtcLogUploadDoneData::~WebRtcLogUploadDoneData() {}
  74
  75 WebRtcLogUploader::WebRtcLogUploader()
  76     : log_count_(0),
  77       post_data_(NULL),
  78       shutting_down_(false) {
  79   file_thread_checker_.DetachFromThread();
  80 }
  81
  82 WebRtcLogUploader::~WebRtcLogUploader() {
  83   DCHECK(create_thread_checker_.CalledOnValidThread());
  84   DCHECK(upload_done_data_.empty());
  85   DCHECK(shutting_down_);
  86 }
  87
  88 void WebRtcLogUploader::OnURLFetchComplete(
  89     const net::URLFetcher* source) {
  90   DCHECK(create_thread_checker_.CalledOnValidThread());
  91   DCHECK(upload_done_data_.find(source) != upload_done_data_.end());
  92   DCHECK(!shutting_down_);
  93   int response_code = source->GetResponseCode();
  94   UploadDoneDataMap::iterator it = upload_done_data_.find(source);
  95   if (it != upload_done_data_.end()) {
  96     // The log path can be empty here if we failed getting it before. We still
  97     // upload the log if that's the case.
  98     std::string report_id;
  99     if (response_code == kHttpResponseOk &&
 100         source->GetResponseAsString(&report_id) &&
 101         !it->second.log_path.empty()) {
 102       // TODO(jiayl): Add the RTP dump records to chrome://webrtc-logs.
 103       base::FilePath log_list_path =
 104           WebRtcLogList::GetWebRtcLogListFileForDirectory(it->second.log_path);
 105       content::BrowserThread::PostTask(
 106           content::BrowserThread::FILE,
 107           FROM_HERE,
 108           base::Bind(&WebRtcLogUploader::AddUploadedLogInfoToUploadListFile,
 109                      base::Unretained(this),
 110                      log_list_path,
 111                      it->second.local_log_id,
 112                      report_id));
 113     }
 114     NotifyUploadDone(response_code, report_id, it->second);
 115     upload_done_data_.erase(it);
 116   }
 117
 118   delete source;
 119 }
 120
 121 void WebRtcLogUploader::OnURLFetchUploadProgress(
 122     const net::URLFetcher* source, int64 current, int64 total) {
 123 }
 124
 125 bool WebRtcLogUploader::ApplyForStartLogging() {
 126   DCHECK(create_thread_checker_.CalledOnValidThread());
 127   if (log_count_ < kLogCountLimit && !shutting_down_) {
 128     ++log_count_;
 129     return true;
 130   }
 131   return false;
 132 }
 133
 134 void WebRtcLogUploader::LoggingStoppedDontUpload() {
 135   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
 136       base::Bind(&WebRtcLogUploader::DecreaseLogCount, base::Unretained(this)));
 137 }
 138
 139 void WebRtcLogUploader::LoggingStoppedDoUpload(
 140     scoped_ptr<unsigned char[]> log_buffer,
 141     uint32 length,
 142     const std::map<std::string, std::string>& meta_data,
 143     const WebRtcLogUploadDoneData& upload_done_data) {
 144   DCHECK(file_thread_checker_.CalledOnValidThread());
 145   DCHECK(log_buffer.get());
 146   DCHECK(!upload_done_data.log_path.empty());
 147
 148   std::vector<uint8> compressed_log;
 149   CompressLog(
 150       &compressed_log, reinterpret_cast<uint8*>(&log_buffer[0]), length);
 151
 152   std::string local_log_id;
 153
 154   if (base::PathExists(upload_done_data.log_path)) {
 155     WebRtcLogUtil::DeleteOldWebRtcLogFiles(upload_done_data.log_path);
 156
 157     local_log_id = base::DoubleToString(base::Time::Now().ToDoubleT());
 158     base::FilePath log_file_path =
 159         upload_done_data.log_path.AppendASCII(local_log_id)
 160             .AddExtension(FILE_PATH_LITERAL(".gz"));
 161     WriteCompressedLogToFile(compressed_log, log_file_path);
 162
 163     base::FilePath log_list_path =
 164         WebRtcLogList::GetWebRtcLogListFileForDirectory(
 165             upload_done_data.log_path);
 166     AddLocallyStoredLogInfoToUploadListFile(log_list_path, local_log_id);
 167   }
 168
 169   WebRtcLogUploadDoneData upload_done_data_with_log_id = upload_done_data;
 170   upload_done_data_with_log_id.local_log_id = local_log_id;
 171
 172   scoped_ptr<std::string> post_data(new std::string());
 173   SetupMultipart(post_data.get(),
 174                  compressed_log,
 175                  upload_done_data.incoming_rtp_dump,
 176                  upload_done_data.outgoing_rtp_dump,
 177                  meta_data);
 178
 179   // If a test has set the test string pointer, write to it and skip uploading.
 180   // Still fire the upload callback so that we can run an extension API test
 181   // using the test framework for that without hanging.
 182   // TODO(grunell): Remove this when the api test for this feature is fully
 183   // implemented according to the test plan. http://crbug.com/257329.
 184   if (post_data_) {
 185     *post_data_ = *post_data;
 186     NotifyUploadDone(kHttpResponseOk, "", upload_done_data_with_log_id);
 187     return;
 188   }
 189
 190   content::BrowserThread::PostTask(
 191       content::BrowserThread::UI,
 192       FROM_HERE,
 193       base::Bind(&WebRtcLogUploader::CreateAndStartURLFetcher,
 194                  base::Unretained(this),
 195                  upload_done_data_with_log_id,
 196                  Passed(&post_data)));
 197
 198   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
 199       base::Bind(&WebRtcLogUploader::DecreaseLogCount, base::Unretained(this)));
 200 }
 201
 202 void WebRtcLogUploader::StartShutdown() {
 203   DCHECK(create_thread_checker_.CalledOnValidThread());
 204   DCHECK(!shutting_down_);
 205
 206   // Delete all URLFetchers first and clear the upload done map.
 207   for (UploadDoneDataMap::iterator it = upload_done_data_.begin();
 208        it != upload_done_data_.end();
 209        ++it) {
 210     delete it->first;
 211   }
 212   upload_done_data_.clear();
 213   shutting_down_ = true;
 214 }
 215
 216 void WebRtcLogUploader::SetupMultipart(
 217     std::string* post_data,
 218     const std::vector<uint8>& compressed_log,
 219     const base::FilePath& incoming_rtp_dump,
 220     const base::FilePath& outgoing_rtp_dump,
 221     const std::map<std::string, std::string>& meta_data) {
 222 #if defined(OS_WIN)
 223   const char product[] = "Chrome";
 224 #elif defined(OS_MACOSX)
 225   const char product[] = "Chrome_Mac";
 226 #elif defined(OS_LINUX)
 227 #if !defined(ADDRESS_SANITIZER)
 228   const char product[] = "Chrome_Linux";
 229 #else
 230   const char product[] = "Chrome_Linux_ASan";
 231 #endif
 232 #elif defined(OS_ANDROID)
 233   const char product[] = "Chrome_Android";
 234 #elif defined(OS_CHROMEOS)
 235   const char product[] = "Chrome_ChromeOS";
 236 #else
 237 #error Platform not supported.
 238 #endif
 239   net::AddMultipartValueForUpload("prod", product, kMultipartBoundary,
 240                                   "", post_data);
 241   chrome::VersionInfo version_info;
 242   net::AddMultipartValueForUpload("ver", version_info.Version() + "-webrtc",
 243                                   kMultipartBoundary, "", post_data);
 244   net::AddMultipartValueForUpload("guid", "0", kMultipartBoundary,
 245                                   "", post_data);
 246   net::AddMultipartValueForUpload("type", "webrtc_log", kMultipartBoundary,
 247                                   "", post_data);
 248
 249   // Add custom meta data.
 250   std::map<std::string, std::string>::const_iterator it = meta_data.begin();
 251   for (; it != meta_data.end(); ++it) {
 252     net::AddMultipartValueForUpload(it->first, it->second, kMultipartBoundary,
 253                                     "", post_data);
 254   }
 255
 256   AddLogData(post_data, compressed_log);
 257
 258   // Add the rtp dumps if they exist.
 259   base::FilePath rtp_dumps[2] = {incoming_rtp_dump, outgoing_rtp_dump};
 260   static const char* kRtpDumpNames[2] = {"rtpdump_recv", "rtpdump_send"};
 261
 262   for (size_t i = 0; i < 2; ++i) {
 263     if (!rtp_dumps[i].empty() && base::PathExists(rtp_dumps[i])) {
 264       std::string dump_data;
 265       if (base::ReadFileToString(rtp_dumps[i], &dump_data))
 266         AddRtpDumpData(post_data, kRtpDumpNames[i], dump_data);
 267     }
 268   }
 269
 270   net::AddMultipartFinalDelimiterForUpload(kMultipartBoundary, post_data);
 271 }
 272
 273 void WebRtcLogUploader::CompressLog(std::vector<uint8>* compressed_log,
 274                                     uint8* input,
 275                                     uint32 input_size) {
 276   PartialCircularBuffer read_pcb(input, input_size);
 277
 278   z_stream stream = {0};
 279   int result = deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
 280                             // windowBits = 15 is default, 16 is added to
 281                             // produce a gzip header + trailer.
 282                             15 + 16,
 283                             8,  // memLevel = 8 is default.
 284                             Z_DEFAULT_STRATEGY);
 285   DCHECK_EQ(Z_OK, result);
 286
 287   uint8 intermediate_buffer[kIntermediateCompressionBufferBytes] = {0};
 288   ResizeForNextOutput(compressed_log, &stream);
 289   uint32 read = 0;
 290
 291   do {
 292     if (stream.avail_in == 0) {
 293       read = read_pcb.Read(&intermediate_buffer[0],
 294                            kIntermediateCompressionBufferBytes);
 295       stream.next_in = &intermediate_buffer[0];
 296       stream.avail_in = read;
 297       if (read != kIntermediateCompressionBufferBytes)
 298         break;
 299     }
 300     result = deflate(&stream, Z_SYNC_FLUSH);
 301     DCHECK_EQ(Z_OK, result);
 302     if (stream.avail_out == 0)
 303       ResizeForNextOutput(compressed_log, &stream);
 304   } while (true);
 305
 306   // Ensure we have enough room in the output buffer. Easier to always just do a
 307   // resize than looping around and resize if needed.
 308   if (stream.avail_out < kIntermediateCompressionBufferBytes)
 309     ResizeForNextOutput(compressed_log, &stream);
 310
 311   result = deflate(&stream, Z_FINISH);
 312   DCHECK_EQ(Z_STREAM_END, result);
 313   result = deflateEnd(&stream);
 314   DCHECK_EQ(Z_OK, result);
 315
 316   compressed_log->resize(compressed_log->size() - stream.avail_out);
 317 }
 318
 319 void WebRtcLogUploader::ResizeForNextOutput(std::vector<uint8>* compressed_log,
 320                                             z_stream* stream) {
 321   size_t old_size = compressed_log->size() - stream->avail_out;
 322   compressed_log->resize(old_size + kIntermediateCompressionBufferBytes);
 323   stream->next_out = &(*compressed_log)[old_size];
 324   stream->avail_out = kIntermediateCompressionBufferBytes;
 325 }
 326
 327 void WebRtcLogUploader::CreateAndStartURLFetcher(
 328     const WebRtcLogUploadDoneData& upload_done_data,
 329     scoped_ptr<std::string> post_data) {
 330   DCHECK(create_thread_checker_.CalledOnValidThread());
 331
 332   if (shutting_down_)
 333     return;
 334
 335   std::string content_type = kUploadContentType;
 336   content_type.append("; boundary=");
 337   content_type.append(kMultipartBoundary);
 338
 339   net::URLFetcher* url_fetcher =
 340       net::URLFetcher::Create(GURL(kUploadURL), net::URLFetcher::POST, this);
 341   url_fetcher->SetRequestContext(g_browser_process->system_request_context());
 342   url_fetcher->SetUploadData(content_type, *post_data);
 343   url_fetcher->Start();
 344   upload_done_data_[url_fetcher] = upload_done_data;
 345 }
 346
 347 void WebRtcLogUploader::DecreaseLogCount() {
 348   DCHECK(create_thread_checker_.CalledOnValidThread());
 349   --log_count_;
 350 }
 351
 352 void WebRtcLogUploader::WriteCompressedLogToFile(
 353     const std::vector<uint8>& compressed_log,
 354     const base::FilePath& log_file_path) {
 355   DCHECK(file_thread_checker_.CalledOnValidThread());
 356   DCHECK(!compressed_log.empty());
 357   base::WriteFile(log_file_path,
 358                   reinterpret_cast<const char*>(&compressed_log[0]),
 359                   compressed_log.size());
 360 }
 361
 362 void WebRtcLogUploader::AddLocallyStoredLogInfoToUploadListFile(
 363     const base::FilePath& upload_list_path,
 364     const std::string& local_log_id) {
 365   DCHECK(file_thread_checker_.CalledOnValidThread());
 366   DCHECK(!upload_list_path.empty());
 367   DCHECK(!local_log_id.empty());
 368
 369   std::string contents;
 370
 371   if (base::PathExists(upload_list_path)) {
 372     if (!base::ReadFileToString(upload_list_path, &contents)) {
 373       DPLOG(WARNING) << "Could not read WebRTC log list file.";
 374       return;
 375     }
 376
 377     // Limit the number of log entries to |kLogListLimitLines| - 1, to make room
 378     // for the new entry. Each line including the last ends with a '\n', so hit
 379     // n will be before line n-1 (from the back).
 380     int lf_count = 0;
 381     int i = contents.size() - 1;
 382     for (; i >= 0 && lf_count < kLogListLimitLines; --i) {
 383       if (contents[i] == '\n')
 384         ++lf_count;
 385     }
 386     if (lf_count >= kLogListLimitLines) {
 387       // + 1 to compensate for the for loop decrease before the conditional
 388       // check and + 1 to get the length.
 389       contents.erase(0, i + 2);
 390     }
 391   }
 392
 393   // Write the log ID to the log list file. Leave the upload time and report ID
 394   // empty.
 395   contents += ",," + local_log_id + '\n';
 396
 397   int written =
 398       base::WriteFile(upload_list_path, &contents[0], contents.size());
 399   if (written != static_cast<int>(contents.size())) {
 400     DPLOG(WARNING) << "Could not write all data to WebRTC log list file: "
 401                    << written;
 402   }
 403 }
 404
 405 void WebRtcLogUploader::AddUploadedLogInfoToUploadListFile(
 406     const base::FilePath& upload_list_path,
 407     const std::string& local_log_id,
 408     const std::string& report_id) {
 409   DCHECK(file_thread_checker_.CalledOnValidThread());
 410   DCHECK(!upload_list_path.empty());
 411   DCHECK(!local_log_id.empty());
 412   DCHECK(!report_id.empty());
 413
 414   std::string contents;
 415
 416   if (base::PathExists(upload_list_path)) {
 417     if (!base::ReadFileToString(upload_list_path, &contents)) {
 418       DPLOG(WARNING) << "Could not read WebRTC log list file.";
 419       return;
 420     }
 421   }
 422
 423   // Write the Unix time and report ID to the log list file. We should be able
 424   // to find the local log ID, in that case insert the data into the existing
 425   // line. Otherwise add it in the end.
 426   base::Time time_now = base::Time::Now();
 427   std::string time_now_str = base::DoubleToString(time_now.ToDoubleT());
 428   size_t pos = contents.find(",," + local_log_id);
 429   if (pos != std::string::npos) {
 430     contents.insert(pos, time_now_str);
 431     contents.insert(pos + time_now_str.length() + 1, report_id);
 432   } else {
 433     contents += time_now_str + "," + report_id + ",\n";
 434   }
 435
 436   int written =
 437       base::WriteFile(upload_list_path, &contents[0], contents.size());
 438   if (written != static_cast<int>(contents.size())) {
 439     DPLOG(WARNING) << "Could not write all data to WebRTC log list file: "
 440                    << written;
 441   }
 442 }
 443
 444 void WebRtcLogUploader::NotifyUploadDone(
 445     int response_code,
 446     const std::string& report_id,
 447     const WebRtcLogUploadDoneData& upload_done_data) {
 448   content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
 449       base::Bind(&WebRtcLoggingHandlerHost::UploadLogDone,
 450                  upload_done_data.host));
 451   if (!upload_done_data.callback.is_null()) {
 452     bool success = response_code == kHttpResponseOk;
 453     std::string error_message;
 454     if (!success) {
 455       error_message = "Uploading failed, response code: " +
 456                       base::IntToString(response_code);
 457     }
 458     content::BrowserThread::PostTask(
 459         content::BrowserThread::UI, FROM_HERE,
 460         base::Bind(upload_done_data.callback, success, report_id,
 461                    error_message));
 462   }
 463 }