Home | History | Annotate | Download | only in media 
      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/file_util.h"
      8 #include "base/files/file_path.h"
      9 #include "base/logging.h"
     10 #include "base/memory/shared_memory.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/media/webrtc_log_upload_list.h"
     17 #include "chrome/common/chrome_paths.h"
     18 #include "chrome/common/chrome_version_info.h"
     19 #include "chrome/common/partial_circular_buffer.h"
     20 #include "content/public/browser/browser_thread.h"
     21 #include "net/base/mime_util.h"
     22 #include "net/base/network_delegate.h"
     23 #include "net/proxy/proxy_config.h"
     24 #include "net/proxy/proxy_config_service.h"
     25 #include "net/url_request/url_fetcher.h"
     26 #include "net/url_request/url_request_context.h"
     27 #include "net/url_request/url_request_context_builder.h"
     28 #include "net/url_request/url_request_context_getter.h"
     29 #include "third_party/zlib/zlib.h"
     30 
     31 namespace {
     32 
     33 const int kLogCountLimit = 5;
     34 const uint32 kIntermediateCompressionBufferBytes = 256 * 1024;  // 256 KB
     35 const int kLogListLimitLines = 50;
     36 
     37 const char kUploadURL[] = "https://clients2.google.com/cr/report";
     38 const char kUploadContentType[] = "multipart/form-data";
     39 const char kMultipartBoundary[] =
     40     "----**--yradnuoBgoLtrapitluMklaTelgooG--**----";
     41 
     42 const int kHttpResponseOk = 200;
     43 
     44 }  // namespace
     45 
     46 WebRtcLogUploader::WebRtcLogUploader()
     47     : log_count_(0),
     48       post_data_(NULL) {
     49   file_thread_checker_.DetachFromThread();
     50 }
     51 
     52 WebRtcLogUploader::~WebRtcLogUploader() {
     53   DCHECK(create_thread_checker_.CalledOnValidThread());
     54   // Delete all pending URLFetcher and release all references to
     55   // WebRtcLoggingHandlerHost.
     56   for (UploadDoneDataMap::iterator it = upload_done_data_.begin();
     57        it != upload_done_data_.end(); ++it) {
     58     delete it->first;
     59   }
     60   upload_done_data_.clear();
     61 }
     62 
     63 void WebRtcLogUploader::OnURLFetchComplete(
     64     const net::URLFetcher* source) {
     65   DCHECK(create_thread_checker_.CalledOnValidThread());
     66   DCHECK(upload_done_data_.find(source) != upload_done_data_.end());
     67   int response_code = source->GetResponseCode();
     68   std::string report_id;
     69   if (response_code == kHttpResponseOk &&
     70       source->GetResponseAsString(&report_id)) {
     71   content::BrowserThread::PostTask(
     72       content::BrowserThread::FILE, FROM_HERE,
     73       base::Bind(&WebRtcLogUploader::AddUploadedLogInfoToUploadListFile,
     74                  base::Unretained(this),
     75                  upload_done_data_[source].upload_list_path,
     76                  report_id));
     77   }
     78   NotifyUploadDone(response_code, report_id, upload_done_data_[source]);
     79   upload_done_data_.erase(source);
     80   delete source;
     81 }
     82 
     83 void WebRtcLogUploader::OnURLFetchUploadProgress(
     84     const net::URLFetcher* source, int64 current, int64 total) {
     85 }
     86 
     87 bool WebRtcLogUploader::ApplyForStartLogging() {
     88   DCHECK(create_thread_checker_.CalledOnValidThread());
     89   if (log_count_ < kLogCountLimit) {
     90     ++log_count_;
     91     return true;
     92   }
     93   return false;
     94 }
     95 
     96 void WebRtcLogUploader::LoggingStoppedDontUpload() {
     97   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
     98       base::Bind(&WebRtcLogUploader::DecreaseLogCount, base::Unretained(this)));
     99 }
    100 
    101 void WebRtcLogUploader::LoggingStoppedDoUpload(
    102     net::URLRequestContextGetter* request_context,
    103     scoped_ptr<unsigned char[]> log_buffer,
    104     uint32 length,
    105     const std::map<std::string, std::string>& meta_data,
    106     const WebRtcLogUploadDoneData& upload_done_data) {
    107   DCHECK(file_thread_checker_.CalledOnValidThread());
    108   DCHECK(log_buffer.get());
    109   DCHECK(!upload_done_data.upload_list_path.empty());
    110 
    111   scoped_ptr<std::string> post_data;
    112   post_data.reset(new std::string);
    113   SetupMultipart(post_data.get(),
    114                  reinterpret_cast<uint8*>(log_buffer.get()),
    115                  length,
    116                  meta_data);
    117 
    118   // If a test has set the test string pointer, write to it and skip uploading.
    119   // Still fire the upload callback so that we can run an extension API test
    120   // using the test framework for that without hanging.
    121   // TODO(grunell): Remove this when the api test for this feature is fully
    122   // implemented according to the test plan. http://crbug.com/257329.
    123   if (post_data_) {
    124     *post_data_ = *post_data;
    125     NotifyUploadDone(kHttpResponseOk, "", upload_done_data);
    126     return;
    127   }
    128 
    129   content::BrowserThread::PostTask(
    130       content::BrowserThread::UI, FROM_HERE,
    131       base::Bind(&WebRtcLogUploader::CreateAndStartURLFetcher,
    132                  base::Unretained(this),
    133                  make_scoped_refptr(request_context),
    134                  upload_done_data,
    135                  Passed(&post_data)));
    136 
    137   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
    138       base::Bind(&WebRtcLogUploader::DecreaseLogCount, base::Unretained(this)));
    139 }
    140 
    141 void WebRtcLogUploader::SetupMultipart(
    142     std::string* post_data, uint8* log_buffer, uint32 log_buffer_length,
    143     const std::map<std::string, std::string>& meta_data) {
    144 #if defined(OS_WIN)
    145   const char product[] = "Chrome";
    146 #elif defined(OS_MACOSX)
    147   const char product[] = "Chrome_Mac";
    148 #elif defined(OS_LINUX)
    149 #if !defined(ADDRESS_SANITIZER)
    150   const char product[] = "Chrome_Linux";
    151 #else
    152   const char product[] = "Chrome_Linux_ASan";
    153 #endif
    154 #elif defined(OS_ANDROID)
    155   const char product[] = "Chrome_Android";
    156 #elif defined(OS_CHROMEOS)
    157   const char product[] = "Chrome_ChromeOS";
    158 #else
    159   // This file should not be compiled for other platforms.
    160   COMPILE_ASSERT(false);
    161 #endif
    162   net::AddMultipartValueForUpload("prod", product, kMultipartBoundary,
    163                                   "", post_data);
    164   chrome::VersionInfo version_info;
    165   net::AddMultipartValueForUpload("ver", version_info.Version(),
    166                                   kMultipartBoundary, "", post_data);
    167   net::AddMultipartValueForUpload("guid", "0", kMultipartBoundary,
    168                                   "", post_data);
    169   net::AddMultipartValueForUpload("type", "webrtc_log", kMultipartBoundary,
    170                                   "", post_data);
    171 
    172   // Add custom meta data.
    173   std::map<std::string, std::string>::const_iterator it = meta_data.begin();
    174   for (; it != meta_data.end(); ++it) {
    175     net::AddMultipartValueForUpload(it->first, it->second, kMultipartBoundary,
    176                                     "", post_data);
    177   }
    178 
    179   AddLogData(post_data, log_buffer, log_buffer_length);
    180   net::AddMultipartFinalDelimiterForUpload(kMultipartBoundary, post_data);
    181 }
    182 
    183 void WebRtcLogUploader::AddLogData(std::string* post_data,
    184                                    uint8* log_buffer,
    185                                    uint32 log_buffer_length) {
    186   post_data->append("--");
    187   post_data->append(kMultipartBoundary);
    188   post_data->append("\r\n");
    189   post_data->append("Content-Disposition: form-data; name=\"webrtc_log\"");
    190   post_data->append("; filename=\"webrtc_log.gz\"\r\n");
    191   post_data->append("Content-Type: application/gzip\r\n\r\n");
    192 
    193   CompressLog(post_data, log_buffer, log_buffer_length);
    194 
    195   post_data->append("\r\n");
    196 }
    197 
    198 void WebRtcLogUploader::CompressLog(std::string* post_data,
    199                                     uint8* input,
    200                                     uint32 input_size) {
    201   PartialCircularBuffer read_pcb(input, input_size);
    202 
    203   z_stream stream = {0};
    204   int result = deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
    205                             // windowBits = 15 is default, 16 is added to
    206                             // produce a gzip header + trailer.
    207                             15 + 16,
    208                             8,  // memLevel = 8 is default.
    209                             Z_DEFAULT_STRATEGY);
    210   DCHECK_EQ(Z_OK, result);
    211 
    212   uint8 intermediate_buffer[kIntermediateCompressionBufferBytes] = {0};
    213   ResizeForNextOutput(post_data, &stream);
    214   uint32 read = 0;
    215 
    216   do {
    217     if (stream.avail_in == 0) {
    218       read = read_pcb.Read(&intermediate_buffer[0],
    219                            kIntermediateCompressionBufferBytes);
    220       stream.next_in = &intermediate_buffer[0];
    221       stream.avail_in = read;
    222       if (read != kIntermediateCompressionBufferBytes)
    223         break;
    224     }
    225     result = deflate(&stream, Z_SYNC_FLUSH);
    226     DCHECK_EQ(Z_OK, result);
    227     if (stream.avail_out == 0)
    228       ResizeForNextOutput(post_data, &stream);
    229   } while (true);
    230 
    231   // Ensure we have enough room in the output buffer. Easier to always just do a
    232   // resize than looping around and resize if needed.
    233   if (stream.avail_out < kIntermediateCompressionBufferBytes)
    234     ResizeForNextOutput(post_data, &stream);
    235 
    236   result = deflate(&stream, Z_FINISH);
    237   DCHECK_EQ(Z_STREAM_END, result);
    238   result = deflateEnd(&stream);
    239   DCHECK_EQ(Z_OK, result);
    240 
    241   post_data->resize(post_data->size() - stream.avail_out);
    242 }
    243 
    244 void WebRtcLogUploader::ResizeForNextOutput(std::string* post_data,
    245                                             z_stream* stream) {
    246   size_t old_size = post_data->size() - stream->avail_out;
    247   post_data->resize(old_size + kIntermediateCompressionBufferBytes);
    248   stream->next_out = reinterpret_cast<uint8*>(&(*post_data)[old_size]);
    249   stream->avail_out = kIntermediateCompressionBufferBytes;
    250 }
    251 
    252 void WebRtcLogUploader::CreateAndStartURLFetcher(
    253     scoped_refptr<net::URLRequestContextGetter> request_context,
    254     const WebRtcLogUploadDoneData& upload_done_data,
    255     scoped_ptr<std::string> post_data) {
    256   DCHECK(create_thread_checker_.CalledOnValidThread());
    257   std::string content_type = kUploadContentType;
    258   content_type.append("; boundary=");
    259   content_type.append(kMultipartBoundary);
    260 
    261   net::URLFetcher* url_fetcher =
    262       net::URLFetcher::Create(GURL(kUploadURL), net::URLFetcher::POST, this);
    263   url_fetcher->SetRequestContext(request_context);
    264   url_fetcher->SetUploadData(content_type, *post_data);
    265   url_fetcher->Start();
    266   upload_done_data_[url_fetcher] = upload_done_data;
    267 }
    268 
    269 void WebRtcLogUploader::DecreaseLogCount() {
    270   DCHECK(create_thread_checker_.CalledOnValidThread());
    271   --log_count_;
    272 }
    273 
    274 void WebRtcLogUploader::AddUploadedLogInfoToUploadListFile(
    275     const base::FilePath& upload_list_path,
    276     const std::string& report_id) {
    277   DCHECK(file_thread_checker_.CalledOnValidThread());
    278   std::string contents;
    279 
    280   if (base::PathExists(upload_list_path)) {
    281     bool read_ok = base::ReadFileToString(upload_list_path, &contents);
    282     DPCHECK(read_ok);
    283 
    284     // Limit the number of log entries to |kLogListLimitLines| - 1, to make room
    285     // for the new entry. Each line including the last ends with a '\n', so hit
    286     // n will be before line n-1 (from the back).
    287     int lf_count = 0;
    288     int i = contents.size() - 1;
    289     for (; i >= 0 && lf_count < kLogListLimitLines; --i) {
    290       if (contents[i] == '\n')
    291         ++lf_count;
    292     }
    293     if (lf_count >= kLogListLimitLines) {
    294       // + 1 to compensate for the for loop decrease before the conditional
    295       // check and + 1 to get the length.
    296       contents.erase(0, i + 2);
    297     }
    298   }
    299 
    300   // Write the Unix time and report ID to the log list file.
    301   base::Time time_now = base::Time::Now();
    302   contents += base::DoubleToString(time_now.ToDoubleT()) +
    303               "," + report_id + '\n';
    304 
    305   int written = file_util::WriteFile(upload_list_path, &contents[0],
    306                                      contents.size());
    307   DPCHECK(written == static_cast<int>(contents.size()));
    308 }
    309 
    310 void WebRtcLogUploader::NotifyUploadDone(
    311     int response_code,
    312     const std::string& report_id,
    313     const WebRtcLogUploadDoneData& upload_done_data) {
    314   content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
    315       base::Bind(&WebRtcLoggingHandlerHost::UploadLogDone,
    316                  upload_done_data.host));
    317   if (!upload_done_data.callback.is_null()) {
    318     bool success = response_code == kHttpResponseOk;
    319     std::string error_message;
    320     if (!success) {
    321       error_message = "Uploading failed, response code: " +
    322                       base::IntToString(response_code);
    323     }
    324     content::BrowserThread::PostTask(
    325         content::BrowserThread::UI, FROM_HERE,
    326         base::Bind(upload_done_data.callback, success, report_id,
    327                    error_message));
    328   }
    329 }
    330