Add the most recent crash report IDs to feedback reports

components/feedback/feedback_common.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 "components/feedback/feedback_common.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
+#include "components/feedback/feedback_report.h"
 #include "components/feedback/feedback_util.h"
 #include "components/feedback/proto/common.pb.h"
 #include "components/feedback/proto/dom.pb.h"
 #include "components/feedback/proto/extension.pb.h"
 #include "components/feedback/proto/math.pb.h"
 
 namespace {
 
 #if defined(OS_CHROMEOS)
 constexpr int kChromeOSProductId = 208;
 #else
 constexpr int kChromeBrowserProductId = 237;
 #endif
 
-const char kMultilineIndicatorString[] = "<multiline>\n";
-const char kMultilineStartString[] = "---------- START ----------\n";
-const char kMultilineEndString[] = "---------- END ----------\n\n";
+constexpr char kMultilineIndicatorString[] = "<multiline>\n";
+constexpr char kMultilineStartString[] = "---------- START ----------\n";
+constexpr char kMultilineEndString[] = "---------- END ----------\n\n";
 
 // The below thresholds were chosen arbitrarily to conveniently show small data
 // as part of the report itself without having to look into the system_logs.zip
 // file.
-const size_t kFeedbackMaxLength = 1024;
-const size_t kFeedbackMaxLineCount = 10;
+constexpr size_t kFeedbackMaxLength = 1024;
+constexpr size_t kFeedbackMaxLineCount = 10;
 
-const base::FilePath::CharType kLogsFilename[] =
+constexpr base::FilePath::CharType kLogsFilename[] =
     FILE_PATH_LITERAL("system_logs.txt");
-const char kLogsAttachmentName[] = "system_logs.zip";
+constexpr char kLogsAttachmentName[] = "system_logs.zip";
 
-const char kZipExt[] = ".zip";
+constexpr char kZipExt[] = ".zip";
 
-const char kPngMimeType[] = "image/png";
-const char kArbitraryMimeType[] = "application/octet-stream";
+constexpr char kPngMimeType[] = "image/png";
+constexpr char kArbitraryMimeType[] = "application/octet-stream";
 
 // Determine if the given feedback value is small enough to not need to
 // be compressed.
 bool BelowCompressionThreshold(const std::string& content) {
   if (content.length() > kFeedbackMaxLength)
     return false;
   const size_t line_count = std::count(content.begin(), content.end(), '\n');
   if (line_count > kFeedbackMaxLineCount)
     return false;
   return true;
 }
 
 // Converts the system logs into a string that we can compress and send
 // with the report.
 // TODO(dcheng): This should probably just take advantage of string's move
 // constructor.
 std::unique_ptr<std::string> LogsToString(
     const FeedbackCommon::SystemLogsMap& sys_info) {
   std::unique_ptr<std::string> syslogs_string(new std::string);
   for (const auto& iter : sys_info) {
     std::string key = iter.first;
     std::string value = iter.second;
 
     base::TrimString(key, "\n ", &key);
     base::TrimString(value, "\n ", &value);
 
+    // We must avoid adding the crash IDs to the system_logs.txt file for
+    // privacy reasons. They should just be part of the product specific data.
+    if (key == feedback::FeedbackReport::kCrashReportIdsKey)
+      continue;
+
     if (value.find("\n") != std::string::npos) {
       syslogs_string->append(key + "=" + kMultilineIndicatorString +
                              kMultilineStartString + value + "\n" +
                              kMultilineEndString);
     } else {
       syslogs_string->append(key + "=" + value + "\n");
     }
   }
   return syslogs_string;
 }
@@ skipping 148 matching lines @@
 
 void FeedbackCommon::CompressLogs() {
   if (!logs_)
     return;
   std::unique_ptr<std::string> logs = LogsToString(*logs_);
   if (!logs->empty()) {
     CompressFile(base::FilePath(kLogsFilename), kLogsAttachmentName,
                  std::move(logs));
   }
 }
+
 void FeedbackCommon::AddFilesAndLogsToReport(
     userfeedback::ExtensionSubmit* feedback_data) const {
   for (size_t i = 0; i < attachments(); ++i) {
     const AttachedFile* file = attachment(i);
     AddAttachment(feedback_data, file->name.c_str(), *file->data);
   }
 
   if (!logs_)
     return;
 
   for (const auto& iter : *logs_) {
     if (BelowCompressionThreshold(iter.second)) {
       // Small enough logs should end up in the report data itself. However,
       // they're still added as part of the system_logs.zip file.
       AddFeedbackData(feedback_data, iter.first, iter.second);
     }
   }
 }