Add anonymizer tool

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 "feedback_common.h"
+#include "components/feedback/feedback_common.h"
 
 #include "base/strings/string_util.h"
+#include "components/feedback/anonymizer_tool.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 {
 
 const char kMultilineIndicatorString[] = "<multiline>\n";
 const char kMultilineStartString[] = "---------- START ----------\n";
 const char kMultilineEndString[] = "---------- END ----------\n\n";
 
 const size_t kFeedbackMaxLength = 4 * 1024;
 const size_t kFeedbackMaxLineCount = 40;
 
 const base::FilePath::CharType kLogsFilename[] =
     FILE_PATH_LITERAL("system_logs.txt");
 const char kLogsAttachmentName[] = "system_logs.zip";
 
 const char kZipExt[] = ".zip";
 
 const char kPngMimeType[] = "image/png";
 const char kArbitraryMimeType[] = "application/octet-stream";
 
 // Converts the system logs into a string that we can compress and send
 // with the report. This method only converts those logs that we want in
 // the compressed zip file sent with the report, hence it ignores any logs
 // below the size threshold of what we want compressed.
+// Logs files are anonymized by the AnonymizerTool.
 std::string* LogsToString(const FeedbackCommon::SystemLogsMap& sys_info) {
   std::string* syslogs_string = new std::string;
+  feedback::AnonymizerTool anonymizer;
   for (FeedbackCommon::SystemLogsMap::const_iterator it = sys_info.begin();
        it != sys_info.end();
        ++it) {
     std::string key = it->first;
     std::string value = it->second;
 
     if (FeedbackCommon::BelowCompressionThreshold(value))
       continue;
 
     base::TrimString(key, "\n ", &key);
     base::TrimString(value, "\n ", &value);
 
+    value = anonymizer.Anonymize(value);
+
     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;
 }
 
+// Data is anonymized by the AnonymizerTool.
 void AddFeedbackData(userfeedback::ExtensionSubmit* feedback_data,
                      const std::string& key,
                      const std::string& value) {
   // Don't bother with empty keys or values.
   if (key.empty() || value.empty())
     return;
+
+  feedback::AnonymizerTool anonymizer;
+
   // Create log_value object and add it to the web_data object.
   userfeedback::ProductSpecificData log_value;
   log_value.set_key(key);
-  log_value.set_value(value);
+  log_value.set_value(anonymizer.Anonymize(value));
   userfeedback::WebData* web_data = feedback_data->mutable_web_data();
   *(web_data->add_product_specific_data()) = log_value;
 }
 
 // Adds data as an attachment to feedback_data if the data is non-empty.
 void AddAttachment(userfeedback::ExtensionSubmit* feedback_data,
                    const char* name,
                    const std::string& data) {
   if (data.empty())
     return;
@@ skipping 125 matching lines @@
 
     *(screenshot.mutable_dimensions()) = dimensions;
     screenshot.set_binary_content(*image());
 
     *(feedback_data->mutable_screenshot()) = screenshot;
   }
 
   if (category_tag().size())
     feedback_data->set_bucket(category_tag());
 }