Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/policy/system_log_uploader_unittest.cc

 // Copyright (c) 2015 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/chromeos/policy/system_log_uploader.h"
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
 #include "components/feedback/anonymizer_tool.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "net/http/http_request_headers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
@@ skipping 20 matching lines @@
   MockUploadJob(const GURL& upload_url,
                 UploadJob::Delegate* delegate,
                 bool is_upload_error,
                 int max_files);
   ~MockUploadJob() override;
 
   // policy::UploadJob:
   void AddDataSegment(const std::string& name,
                       const std::string& filename,
                       const std::map<std::string, std::string>& header_entries,
-                      scoped_ptr<std::string> data) override;
+                      std::unique_ptr<std::string> data) override;
   void Start() override;
 
  protected:
   UploadJob::Delegate* delegate_;
   bool is_upload_error_;
   int file_index_;
   int max_files_;
 };
 
 MockUploadJob::MockUploadJob(const GURL& upload_url,
                              UploadJob::Delegate* delegate,
                              bool is_upload_error,
                              int max_files)
     : delegate_(delegate),
       is_upload_error_(is_upload_error),
       file_index_(0),
       max_files_(max_files) {}
 
 MockUploadJob::~MockUploadJob() {}
 
 void MockUploadJob::AddDataSegment(
     const std::string& name,
     const std::string& filename,
     const std::map<std::string, std::string>& header_entries,
-    scoped_ptr<std::string> data) {
+    std::unique_ptr<std::string> data) {
   // Test all fields to upload.
   EXPECT_LT(file_index_, max_files_);
   EXPECT_GE(file_index_, 0);
 
   EXPECT_EQ(base::StringPrintf(SystemLogUploader::kNameFieldTemplate,
                                file_index_ + 1),
             name);
 
   EXPECT_EQ(kTestSystemLogFileNames[file_index_], filename);
 
@@ skipping 27 matching lines @@
 class MockSystemLogDelegate : public SystemLogUploader::Delegate {
  public:
   MockSystemLogDelegate(bool is_upload_error,
                         const SystemLogUploader::SystemLogs& system_logs)
       : is_upload_error_(is_upload_error), system_logs_(system_logs) {}
   ~MockSystemLogDelegate() override {}
 
   void LoadSystemLogs(const LogUploadCallback& upload_callback) override {
     EXPECT_TRUE(is_upload_allowed_);
     upload_callback.Run(
-        make_scoped_ptr(new SystemLogUploader::SystemLogs(system_logs_)));
+        base::WrapUnique(new SystemLogUploader::SystemLogs(system_logs_)));
   }
 
-  scoped_ptr<UploadJob> CreateUploadJob(
+  std::unique_ptr<UploadJob> CreateUploadJob(
       const GURL& url,
       UploadJob::Delegate* delegate) override {
-    return make_scoped_ptr(new MockUploadJob(url, delegate, is_upload_error_,
-                                             system_logs_.size()));
+    return base::WrapUnique(new MockUploadJob(url, delegate, is_upload_error_,
+                                              system_logs_.size()));
   }
 
   void set_upload_allowed(bool is_upload_allowed) {
     is_upload_allowed_ = is_upload_allowed;
   }
 
  private:
   bool is_upload_allowed_;
   bool is_upload_error_;
   SystemLogUploader::SystemLogs system_logs_;
@@ skipping 41 matching lines @@
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
   chromeos::ScopedCrosSettingsTestHelper settings_helper_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
 };
 
 // Check disabled system log uploads by default.
 TEST_F(SystemLogUploaderTest, Basic) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
-  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+  std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
       new MockSystemLogDelegate(false, SystemLogUploader::SystemLogs()));
   syslog_delegate->set_upload_allowed(false);
   SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);
 
   task_runner_->RunPendingTasks();
 }
 
 // One success task pending.
 TEST_F(SystemLogUploaderTest, SuccessTest) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
-  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+  std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
       new MockSystemLogDelegate(false, SystemLogUploader::SystemLogs()));
   syslog_delegate->set_upload_allowed(true);
   settings_helper_.SetBoolean(chromeos::kSystemLogUploadEnabled, true);
   SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);
 
   EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
 
   RunPendingUploadTaskAndCheckNext(
       uploader, base::TimeDelta::FromMilliseconds(
                     SystemLogUploader::kDefaultUploadDelayMs));
 }
 
 // Three failed responses recieved.
 TEST_F(SystemLogUploaderTest, ThreeFailureTest) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
-  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+  std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
       new MockSystemLogDelegate(true, SystemLogUploader::SystemLogs()));
   syslog_delegate->set_upload_allowed(true);
   settings_helper_.SetBoolean(chromeos::kSystemLogUploadEnabled, true);
   SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);
 
   EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
 
   // Do not retry two times consequentially.
   RunPendingUploadTaskAndCheckNext(uploader,
                                    base::TimeDelta::FromMilliseconds(
                                        SystemLogUploader::kErrorUploadDelayMs));
   // We are using the kDefaultUploadDelayMs and not the kErrorUploadDelayMs here
   // because there's just one retry.
   RunPendingUploadTaskAndCheckNext(
       uploader, base::TimeDelta::FromMilliseconds(
                     SystemLogUploader::kDefaultUploadDelayMs));
   RunPendingUploadTaskAndCheckNext(uploader,
                                    base::TimeDelta::FromMilliseconds(
                                        SystemLogUploader::kErrorUploadDelayMs));
 }
 
 // Check header fields of system log files to upload.
 TEST_F(SystemLogUploaderTest, CheckHeaders) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
   SystemLogUploader::SystemLogs system_logs = GenerateTestSystemLogFiles();
-  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+  std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
       new MockSystemLogDelegate(false, system_logs));
   syslog_delegate->set_upload_allowed(true);
   settings_helper_.SetBoolean(chromeos::kSystemLogUploadEnabled, true);
   SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);
 
   EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
 
   RunPendingUploadTaskAndCheckNext(
       uploader, base::TimeDelta::FromMilliseconds(
                     SystemLogUploader::kDefaultUploadDelayMs));
 }
 
 // Disable system log uploads after one failed log upload.
 TEST_F(SystemLogUploaderTest, DisableLogUpload) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
-  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+  std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
       new MockSystemLogDelegate(true, SystemLogUploader::SystemLogs()));
   MockSystemLogDelegate* mock_delegate = syslog_delegate.get();
   settings_helper_.SetBoolean(chromeos::kSystemLogUploadEnabled, true);
   mock_delegate->set_upload_allowed(true);
   SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);
 
   EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
   RunPendingUploadTaskAndCheckNext(uploader,
                                    base::TimeDelta::FromMilliseconds(
                                        SystemLogUploader::kErrorUploadDelayMs));
@@ skipping 35 matching lines @@
       "<IPv4: 1>55\n"
       "aaaa<IPv4: 2>aaa\n"
       "11:11;<IPv6: 1>\n"
       "<IPv6: 1>\n"
       "11:11:abcdef:0:0:0:0:0\n"
       "aa:aa:aa:00:00:01";
   EXPECT_EQ(result, SystemLogUploader::RemoveSensitiveData(&anonymizer, data));
 }
 
 }  // namespace policy