Make compression optional in TraceUploader.

content/browser/tracing/tracing_ui.cc

 // Copyright (c) 2012 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 "content/browser/tracing/tracing_ui.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 298 matching lines @@
   std::string file_contents_base64;
   if (!args || args->empty() || !args->GetString(0, &file_contents_base64)) {
     web_ui()->CallJavascriptFunction("onUploadError",
                                      base::StringValue("Missing data"));
     return;
   }
 
   std::string file_contents;
   base::Base64Decode(file_contents_base64, &file_contents);
 
-  DoUploadInternal(file_contents);
+  DoUploadInternal(file_contents, TraceUploader::UNCOMPRESSED_UPLOAD);

[davidben, 2015/07/07 23:35:25]

It's not obvious from reading this why base64 implies uncompressed. Looks like
its keyed on an:
   var isBinary = /[.]gz$/.test(filename) || /[.]zip$/.test(filename);

Could you add a comment like perhaps:

  // doUploadBase64 is used to upload binary data which is assumed to already be
compressed.

[shatch, 2015/07/08 14:04:11]

Done.

 }
 
 void TracingUI::DoUpload(const base::ListValue* args) {
   std::string file_contents;
   if (!args || args->empty() || !args->GetString(0, &file_contents)) {
     web_ui()->CallJavascriptFunction("onUploadError",
                                      base::StringValue("Missing data"));
     return;
   }
 
-  DoUploadInternal(file_contents);
+  DoUploadInternal(file_contents, TraceUploader::COMPRESSED_UPLOAD);
 }
 
-void TracingUI::DoUploadInternal(const std::string& file_contents) {
+void TracingUI::DoUploadInternal(const std::string& file_contents,
+                                 TraceUploader::UploadMode upload_mode) {
   if (!delegate_) {
     web_ui()->CallJavascriptFunction("onUploadError",
                                      base::StringValue("Not implemented"));
     return;
   }
 
   if (trace_uploader_) {
     web_ui()->CallJavascriptFunction("onUploadError",
                                      base::StringValue("Upload in progress"));
     return;
   }
 
   TraceUploader::UploadProgressCallback progress_callback =
       base::Bind(&TracingUI::OnTraceUploadProgress,
       weak_factory_.GetWeakPtr());
   TraceUploader::UploadDoneCallback done_callback =
       base::Bind(&TracingUI::OnTraceUploadComplete,
       weak_factory_.GetWeakPtr());
 
   trace_uploader_ = delegate_->GetTraceUploader(
       web_ui()->GetWebContents()->GetBrowserContext()->GetRequestContext());
   DCHECK(trace_uploader_);
-  trace_uploader_->DoUpload(file_contents, nullptr, progress_callback,
-                            done_callback);
+  trace_uploader_->DoUpload(file_contents, upload_mode, nullptr,
+                            progress_callback, done_callback);
   // TODO(mmandlis): Add support for stopping the upload in progress.
 }
 
 void TracingUI::OnTraceUploadProgress(int64 current, int64 total) {
   DCHECK(current <= total);
   int percent = (current / total) * 100;
   web_ui()->CallJavascriptFunction(
         "onUploadProgress",
         base::FundamentalValue(percent),
         base::StringValue(base::StringPrintf("%" PRId64, current)),
         base::StringValue(base::StringPrintf("%" PRId64, total)));
 }
 
 void TracingUI::OnTraceUploadComplete(bool success,
                                       const std::string& feedback) {
   if (success) {
     web_ui()->CallJavascriptFunction("onUploadComplete",
                                      base::StringValue(feedback));
   } else {
     web_ui()->CallJavascriptFunction("onUploadError",
                                      base::StringValue(feedback));
   }
   trace_uploader_.reset();
 }
 
 }  // namespace content