Slow Reports - Embed Metadata in Traces

chrome/browser/tracing/crash_service_uploader.cc

 // Copyright 2014 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/tracing/crash_service_uploader.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
+#include "base/json/json_writer.h"
 #include "base/memory/shared_memory.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "net/base/mime_util.h"
@@ skipping 70 matching lines @@
   DCHECK(url_fetcher_.get());
 
   LOG(WARNING) << "Upload progress: " << current << " of " << total;
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(progress_callback_, current, total));
 }
 
 void TraceCrashServiceUploader::DoUpload(
     const std::string& file_contents,
+    scoped_ptr<base::DictionaryValue> metadata,
     const UploadProgressCallback& progress_callback,
     const UploadDoneCallback& done_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&TraceCrashServiceUploader::DoUploadOnFileThread,
                  base::Unretained(this), file_contents, upload_url_,
-                 progress_callback, done_callback));
+                 base::Passed(metadata.Pass()), progress_callback,
+                 done_callback));
 }
 
 void TraceCrashServiceUploader::DoUploadOnFileThread(
     const std::string& file_contents,
     const std::string& upload_url,
+    scoped_ptr<base::DictionaryValue> metadata,
     const UploadProgressCallback& progress_callback,
     const UploadDoneCallback& done_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   DCHECK(!url_fetcher_.get());
 
   progress_callback_ = progress_callback;
   done_callback_ = done_callback;
 
   if (upload_url.empty()) {
     OnUploadError("Upload URL empty or invalid");
@@ skipping 35 matching lines @@
 
   scoped_ptr<char[]> compressed_contents(new char[kMaxUploadBytes]);
   int compressed_bytes;
   if (!Compress(file_contents, kMaxUploadBytes, compressed_contents.get(),
                 &compressed_bytes)) {
     OnUploadError("Compressing file failed.");
     return;
   }
 
   std::string post_data;
-  SetupMultipart(product, version, "trace.json.gz",
+  SetupMultipart(product, version, metadata.Pass(), "trace.json.gz",
                  std::string(compressed_contents.get(), compressed_bytes),
                  &post_data);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&TraceCrashServiceUploader::CreateAndStartURLFetcher,
                  base::Unretained(this), upload_url, post_data));
 }
 
 void TraceCrashServiceUploader::OnUploadError(std::string error_message) {
   LOG(ERROR) << error_message;
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(done_callback_, false, error_message));
 }
 
 void TraceCrashServiceUploader::SetupMultipart(
     const std::string& product,
     const std::string& version,
+    scoped_ptr<base::DictionaryValue> metadata,
     const std::string& trace_filename,
     const std::string& trace_contents,
     std::string* post_data) {
   net::AddMultipartValueForUpload("prod", product, kMultipartBoundary, "",
                                   post_data);
   net::AddMultipartValueForUpload("ver", version + "-trace", kMultipartBoundary,
                                   "", post_data);
   net::AddMultipartValueForUpload("guid", "0", kMultipartBoundary, "",
                                   post_data);
   net::AddMultipartValueForUpload("type", "trace", kMultipartBoundary, "",
                                   post_data);
   // No minidump means no need for crash to process the report.
   net::AddMultipartValueForUpload("should_process", "false", kMultipartBoundary,
                                   "", post_data);
+  if (metadata) {
+    for (base::DictionaryValue::Iterator it(*metadata); !it.IsAtEnd();
+         it.Advance()) {
+      std::string value;
+      if (!it.value().GetAsString(&value)) {
+        if (!base::JSONWriter::Write(it.value(), &value))
+          continue;
+      }
+
+      net::AddMultipartValueForUpload(it.key(), value, kMultipartBoundary, "",
+                                      post_data);
+    }
+  }
 
   AddTraceFile(trace_filename, trace_contents, post_data);
 
   net::AddMultipartFinalDelimiterForUpload(kMultipartBoundary, post_data);
 }
 
 void TraceCrashServiceUploader::AddTraceFile(const std::string& trace_filename,
                                              const std::string& trace_contents,
                                              std::string* post_data) {
   post_data->append("--");
@@ skipping 49 matching lines @@
   std::string content_type = kUploadContentType;
   content_type.append("; boundary=");
   content_type.append(kMultipartBoundary);
 
   url_fetcher_ =
       net::URLFetcher::Create(GURL(upload_url), net::URLFetcher::POST, this);
   url_fetcher_->SetRequestContext(request_context_);
   url_fetcher_->SetUploadData(content_type, post_data);
   url_fetcher_->Start();
 }