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

chrome/browser/safe_browsing/incident_reporting/delayed_callback_runner_unittest.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/safe_browsing/incident_reporting/delayed_callback_runner.h"
 
 #include <map>
+#include <memory>
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // A class of objects that invoke a callback upon destruction. This is used as
 // an owned argument on callbacks given to a DelayedCallbackRunner under test.
 class CallbackArgument {
  public:
@@ skipping 38 matching lines @@
     callbacks_[name].run = true;
   }
 
   void OnDelete(const std::string& name) {
     EXPECT_FALSE(callbacks_[name].deleted);
     callbacks_[name].deleted = true;
   }
 
   // Returns a callback argument that calls the test fixture's OnDelete method
   // on behalf of the given callback name.
-  scoped_ptr<CallbackArgument> MakeCallbackArgument(const std::string& name) {
-    return make_scoped_ptr(new CallbackArgument(base::Bind(
+  std::unique_ptr<CallbackArgument> MakeCallbackArgument(
+      const std::string& name) {
+    return base::WrapUnique(new CallbackArgument(base::Bind(
         &DelayedCallbackRunnerTest::OnDelete, base::Unretained(this), name)));
   }
 
   // Returns a closure that calls |OnRun| when run and |OnDelete| when deleted
   // on behalf of the given callback name.
   base::Closure MakeCallback(const std::string& name) {
     return base::Bind(&DelayedCallbackRunnerTest::OnRun,
                       base::Unretained(this),
                       name,
                       base::Owned(MakeCallbackArgument(name).release()));
   }
 
   bool CallbackWasRun(const std::string& name) { return callbacks_[name].run; }
 
   bool CallbackWasDeleted(const std::string& name) {
     return callbacks_[name].deleted;
   }
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle thread_task_runner_handle_;
-  scoped_ptr<safe_browsing::DelayedCallbackRunner> instance_;
+  std::unique_ptr<safe_browsing::DelayedCallbackRunner> instance_;
 
  private:
   struct CallbackState {
     CallbackState() : run(), deleted() {}
     bool run;
     bool deleted;
   };
 
   std::map<std::string, CallbackState> callbacks_;
 };
@@ skipping 48 matching lines @@
   task_runner_->RunUntilIdle();
   EXPECT_TRUE(CallbackWasRun(name));
   EXPECT_TRUE(CallbackWasDeleted(name));
 
   RegisterTestCallback(name2);
   instance_->Start();
   task_runner_->RunUntilIdle();
   EXPECT_TRUE(CallbackWasRun(name2));
   EXPECT_TRUE(CallbackWasDeleted(name2));
 }