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

net/log/trace_net_log_observer_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 "net/log/trace_net_log_observer.h"
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_buffer.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_impl.h"
 #include "base/values.h"
 #include "net/log/net_log.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 43 matching lines @@
 
   void OnTraceDataCollected(
       base::RunLoop* run_loop,
       const scoped_refptr<base::RefCountedString>& events_str,
       bool has_more_events) {
     DCHECK(trace_events_->empty());
     trace_buffer_.Start();
     trace_buffer_.AddFragment(events_str->data());
     trace_buffer_.Finish();
 
-    scoped_ptr<base::Value> trace_value;
+    std::unique_ptr<base::Value> trace_value;
     trace_value = base::JSONReader::Read(
         json_output_.json_output,
         base::JSON_PARSE_RFC | base::JSON_DETACHABLE_CHILDREN);
 
     ASSERT_TRUE(trace_value) << json_output_.json_output;
     base::ListValue* trace_events = NULL;
     ASSERT_TRUE(trace_value->GetAsList(&trace_events));
 
     trace_events_ = FilterNetLogTraceEvents(*trace_events);
 
@@ skipping 13 matching lines @@
     TraceLog::GetInstance()->Flush(
         base::Bind(&TraceNetLogObserverTest::OnTraceDataCollected,
                    base::Unretained(this), base::Unretained(&run_loop)));
     run_loop.Run();
   }
 
   void set_trace_net_log_observer(TraceNetLogObserver* trace_net_log_observer) {
     trace_net_log_observer_.reset(trace_net_log_observer);
   }
 
-  static scoped_ptr<base::ListValue> FilterNetLogTraceEvents(
+  static std::unique_ptr<base::ListValue> FilterNetLogTraceEvents(
       const base::ListValue& trace_events) {
-    scoped_ptr<base::ListValue> filtered_trace_events(new base::ListValue());
+    std::unique_ptr<base::ListValue> filtered_trace_events(
+        new base::ListValue());
     for (size_t i = 0; i < trace_events.GetSize(); i++) {
       const base::DictionaryValue* dict = NULL;
       if (!trace_events.GetDictionary(i, &dict)) {
         ADD_FAILURE() << "Unexpected non-dictionary event in trace_events";
         continue;
       }
       std::string category;
       if (!dict->GetString("cat", &category)) {
         ADD_FAILURE()
             << "Unexpected item without a category field in trace_events";
         continue;
       }
       if (category != kNetLogTracingCategory)
         continue;
       filtered_trace_events->Append(dict->DeepCopy());
     }
     return filtered_trace_events;
   }
 
   base::ListValue* trace_events() const { return trace_events_.get(); }
 
   TestNetLog* net_log() { return &net_log_; }
 
   TraceNetLogObserver* trace_net_log_observer() const {
     return trace_net_log_observer_.get();
   }
 
  private:
-  scoped_ptr<base::ListValue> trace_events_;
+  std::unique_ptr<base::ListValue> trace_events_;
   base::trace_event::TraceResultBuffer trace_buffer_;
   base::trace_event::TraceResultBuffer::SimpleOutput json_output_;
   TestNetLog net_log_;
-  scoped_ptr<TraceNetLogObserver> trace_net_log_observer_;
+  std::unique_ptr<TraceNetLogObserver> trace_net_log_observer_;
 };
 
 TEST_F(TraceNetLogObserverTest, TracingNotEnabled) {
   trace_net_log_observer()->WatchForTraceStart(net_log());
   net_log()->AddGlobalEntry(NetLog::TYPE_REQUEST_ALIVE);
 
   EndTraceAndFlush();
   trace_net_log_observer()->StopWatchForTraceStart();
 
   EXPECT_EQ(0u, trace_events()->GetSize());
@@ skipping 207 matching lines @@
   EXPECT_TRUE(item1->GetString("args.params.foo", &item1_params));
   EXPECT_EQ("bar", item1_params);
 
   EXPECT_TRUE(item2->GetString("args.params", &item2_params));
   EXPECT_TRUE(item2_params.empty());
 }
 
 }  // namespace
 
 }  // namespace net