Change scoped_ptr to std::unique_ptr in //net.

net/log/net_log_unittest.cc

 // Copyright (c) 2013 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 "net/log/net_log.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/simple_thread.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 
 namespace net {
 
@@ skipping 10 matching lines @@
     return 0;
   if (capture_mode == NetLogCaptureMode::IncludeCookiesAndCredentials())
     return 1;
   if (capture_mode == NetLogCaptureMode::IncludeSocketBytes())
     return 2;
 
   ADD_FAILURE() << "Unknown capture mode";
   return -1;
 }
 
-scoped_ptr<base::Value> CaptureModeToValue(NetLogCaptureMode capture_mode) {
-  return make_scoped_ptr(
+std::unique_ptr<base::Value> CaptureModeToValue(
+    NetLogCaptureMode capture_mode) {
+  return base::WrapUnique(
       new base::FundamentalValue(CaptureModeToInt(capture_mode)));
 }
 
-scoped_ptr<base::Value> NetCaptureModeCallback(NetLogCaptureMode capture_mode) {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+std::unique_ptr<base::Value> NetCaptureModeCallback(
+    NetLogCaptureMode capture_mode) {
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->Set("capture_mode", CaptureModeToValue(capture_mode));
   return std::move(dict);
 }
 
 TEST(NetLogTest, Basic) {
   TestNetLog net_log;
   TestNetLogEntry::List entries;
   net_log.GetEntries(&entries);
   EXPECT_EQ(0u, entries.size());
 
@@ skipping 65 matching lines @@
 class LoggingObserver : public NetLog::ThreadSafeObserver {
  public:
   LoggingObserver() {}
 
   ~LoggingObserver() override {
     if (net_log())
       net_log()->DeprecatedRemoveObserver(this);
   }
 
   void OnAddEntry(const NetLog::Entry& entry) override {
-    scoped_ptr<base::DictionaryValue> dict =
-        base::DictionaryValue::From(make_scoped_ptr(entry.ToValue()));
+    std::unique_ptr<base::DictionaryValue> dict =
+        base::DictionaryValue::From(base::WrapUnique(entry.ToValue()));
     ASSERT_TRUE(dict);
     values_.push_back(std::move(dict));
   }
 
   size_t GetNumValues() const { return values_.size(); }
   base::DictionaryValue* GetValue(size_t index) const {
     return values_[index].get();
   }
 
  private:
-  std::vector<scoped_ptr<base::DictionaryValue>> values_;
+  std::vector<std::unique_ptr<base::DictionaryValue>> values_;
 };
 
 void AddEvent(NetLog* net_log) {
   net_log->AddGlobalEntry(NetLog::TYPE_CANCELLED,
                           base::Bind(CaptureModeToValue));
 }
 
 // A thread that waits until an event has been signalled before calling
 // RunTestThread.
 class NetLogTestThread : public base::SimpleThread {
@@ skipping 235 matching lines @@
   NetLog net_log;
 
   // Run a bunch of threads to completion, each of which will repeatedly add
   // and remove an observer, and set its logging level.
   RunTestThreads<AddRemoveObserverTestThread>(&net_log);
 }
 
 }  // namespace
 
 }  // namespace net