Convert //components/[f-n]* from scoped_ptr to std::unique_ptr

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/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.
-std::string* LogsToString(const FeedbackCommon::SystemLogsMap& sys_info) {
-  std::string* syslogs_string = new std::string;
+// TODO(dcheng): This should probably just take advantage of string's move
+// constructor.
+std::unique_ptr<std::string> LogsToString(

[dcheng, 2016/04/26 00:11:41]

I rewrote some bonus things in this file, because I had a hard time telling when
things were actually safe. So maybe take an extra close look at this file.

+    const FeedbackCommon::SystemLogsMap& sys_info) {
+  std::unique_ptr<std::string> syslogs_string(new std::string);
   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);
@@ skipping 34 matching lines @@
   userfeedback::ProductSpecificBinaryData* attachment =
       feedback_data->add_product_specific_binary_data();
   attachment->set_mime_type(kArbitraryMimeType);
   attachment->set_name(name);
   attachment->set_data(data);
 }
 
 }  // namespace
 
 FeedbackCommon::AttachedFile::AttachedFile(const std::string& filename,
-                                           scoped_ptr<std::string> data)
+                                           std::unique_ptr<std::string> data)
     : name(filename), data(std::move(data)) {}
 
 FeedbackCommon::AttachedFile::~AttachedFile() {}
 
 
 FeedbackCommon::FeedbackCommon() : product_id_(0) {}
 
 FeedbackCommon::~FeedbackCommon() {}
 
 // static
 bool FeedbackCommon::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;
 }
 
 void FeedbackCommon::CompressFile(const base::FilePath& filename,
                                   const std::string& zipname,
-                                  scoped_ptr<std::string> data) {
-  AttachedFile* file = new AttachedFile(
-      zipname, scoped_ptr<std::string>(new std::string()));
+                                  std::unique_ptr<std::string> data) {
+  std::unique_ptr<AttachedFile> file(
+      new AttachedFile(zipname, base::WrapUnique(new std::string())));
   if (file->name.empty()) {
     // We need to use the UTF8Unsafe methods here to accomodate Windows, which
     // uses wide strings to store filepaths.
     file->name = filename.BaseName().AsUTF8Unsafe();
     file->name.append(kZipExt);
   }
-  if (feedback_util::ZipString(filename, *(data.get()), file->data.get())) {
+  if (feedback_util::ZipString(filename, *data, file->data.get())) {
     base::AutoLock lock(attachments_lock_);
-    attachments_.push_back(file);
-  } else {
-    delete file;
+    attachments_.push_back(file.release());
   }
 }
 
 void FeedbackCommon::AddFile(const std::string& filename,
-                             scoped_ptr<std::string> data) {
+                             std::unique_ptr<std::string> data) {
   base::AutoLock lock(attachments_lock_);
   attachments_.push_back(new AttachedFile(filename, std::move(data)));
 }
 
 void FeedbackCommon::AddLog(const std::string& name, const std::string& value) {
   if (!logs_.get())
-    logs_ = scoped_ptr<SystemLogsMap>(new SystemLogsMap);
-  (*logs_.get())[name] = value;
+    logs_ = base::WrapUnique(new SystemLogsMap);
+  (*logs_)[name] = value;
 }
 
-void FeedbackCommon::AddLogs(scoped_ptr<SystemLogsMap> logs) {
+void FeedbackCommon::AddLogs(std::unique_ptr<SystemLogsMap> logs) {
   if (logs_) {
     logs_->insert(logs->begin(), logs->end());
   } else {
     logs_ = std::move(logs);
   }
 }
 
 void FeedbackCommon::CompressLogs() {
   if (!logs_)
     return;
-  std::string* logs = LogsToString(*logs_.get());
-  if (!logs->empty())
-    CompressFile(
-        base::FilePath(kLogsFilename), kLogsAttachmentName,
-        scoped_ptr<std::string>(logs));
+  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 {
   if (sys_info()) {
     for (FeedbackCommon::SystemLogsMap::const_iterator i = sys_info()->begin();
          i != sys_info()->end();
          ++i) {
       if (BelowCompressionThreshold(i->second))
         AddFeedbackData(feedback_data, i->first, i->second);
@@ skipping 37 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());
 }