Convert //base to use std::unique_ptr

base/test/trace_event_analyzer.cc

 // Copyright (c) 2012 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 "base/test/trace_event_analyzer.h"
 
 #include <math.h>
 
 #include <algorithm>
+#include <memory>
 #include <set>
 
 #include "base/json/json_reader.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/pattern.h"
 #include "base/values.h"
 
 namespace trace_analyzer {
 
 // TraceEvent
 
 TraceEvent::TraceEvent()
     : thread(0, 0),
       timestamp(0),
@@ skipping 113 matching lines @@
                                 double* arg) const {
   const auto it = arg_numbers.find(name);
   if (it != arg_numbers.end()) {
     *arg = it->second;
     return true;
   }
   return false;
 }
 
 bool TraceEvent::GetArgAsValue(const std::string& name,
-                               scoped_ptr<base::Value>* arg) const {
+                               std::unique_ptr<base::Value>* arg) const {
   const auto it = arg_values.find(name);
   if (it != arg_values.end()) {
     *arg = it->second->CreateDeepCopy();
     return true;
   }
   return false;
 }
 
 bool TraceEvent::HasStringArg(const std::string& name) const {
   return (arg_strings.find(name) != arg_strings.end());
@@ skipping 28 matching lines @@
   return static_cast<int>(arg_double);
 }
 
 bool TraceEvent::GetKnownArgAsBool(const std::string& name) const {
   double arg_double = 0;
   bool result = GetArgAsNumber(name, &arg_double);
   DCHECK(result);
   return (arg_double != 0.0);
 }
 
-scoped_ptr<base::Value> TraceEvent::GetKnownArgAsValue(
+std::unique_ptr<base::Value> TraceEvent::GetKnownArgAsValue(
     const std::string& name) const {
-  scoped_ptr<base::Value> arg_value;
+  std::unique_ptr<base::Value> arg_value;
   bool result = GetArgAsValue(name, &arg_value);
   DCHECK(result);
   return arg_value;
 }
 
 // QueryNode
 
 QueryNode::QueryNode(const Query& query) : query_(query) {
 }
 
@@ skipping 463 matching lines @@
     if (ignore_metadata_events && events[i].phase == TRACE_EVENT_PHASE_METADATA)
       continue;
     if (query.Evaluate(events[i]))
       output->push_back(&events[i]);
   }
   return output->size();
 }
 
 bool ParseEventsFromJson(const std::string& json,
                          std::vector<TraceEvent>* output) {
-  scoped_ptr<base::Value> root = base::JSONReader::Read(json);
+  std::unique_ptr<base::Value> root = base::JSONReader::Read(json);
 
   base::ListValue* root_list = NULL;
   if (!root.get() || !root->GetAsList(&root_list))
     return false;
 
   for (size_t i = 0; i < root_list->GetSize(); ++i) {
     base::Value* item = NULL;
     if (root_list->Get(i, &item)) {
       TraceEvent event;
       if (event.SetFromJSON(item))
@@ skipping 12 matching lines @@
 
 TraceAnalyzer::TraceAnalyzer()
     : ignore_metadata_events_(false),
       allow_assocation_changes_(true) {}
 
 TraceAnalyzer::~TraceAnalyzer() {
 }
 
 // static
 TraceAnalyzer* TraceAnalyzer::Create(const std::string& json_events) {
-  scoped_ptr<TraceAnalyzer> analyzer(new TraceAnalyzer());
+  std::unique_ptr<TraceAnalyzer> analyzer(new TraceAnalyzer());
   if (analyzer->SetEvents(json_events))
     return analyzer.release();
   return NULL;
 }
 
 bool TraceAnalyzer::SetEvents(const std::string& json_events) {
   raw_events_.clear();
   if (!ParseEventsFromJson(json_events, &raw_events_))
     return false;
   std::stable_sort(raw_events_.begin(), raw_events_.end());
@@ skipping 264 matching lines @@
   end_position = (end_position < events.size()) ? end_position : events.size();
   size_t count = 0u;
   for (size_t i = begin_position; i < end_position; ++i) {
     if (query.Evaluate(*events.at(i)))
       ++count;
   }
   return count;
 }
 
 }  // namespace trace_analyzer