Convert //base to use std::unique_ptr

base/test/trace_event_analyzer_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/test/trace_event_analyzer.h"
 #include "base/threading/platform_thread.h"
 #include "base/trace_event/trace_buffer.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace trace_analyzer {
 
 namespace {
 
@@ skipping 47 matching lines @@
 
 }  // namespace
 
 TEST_F(TraceEventAnalyzerTest, NoEvents) {
   ManualSetUp();
 
   // Create an empty JSON event string:
   buffer_.Start();
   buffer_.Finish();
 
-  scoped_ptr<TraceAnalyzer>
-      analyzer(TraceAnalyzer::Create(output_.json_output));
+  std::unique_ptr<TraceAnalyzer> analyzer(
+      TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
 
   // Search for all events and verify that nothing is returned.
   TraceEventVector found;
   analyzer->FindEvents(Query::Bool(true), &found);
   EXPECT_EQ(0u, found.size());
 }
 
 TEST_F(TraceEventAnalyzerTest, TraceEvent) {
   ManualSetUp();
 
   int int_num = 2;
   double double_num = 3.5;
   const char str[] = "the string";
 
   TraceEvent event;
   event.arg_numbers["false"] = 0.0;
   event.arg_numbers["true"] = 1.0;
   event.arg_numbers["int"] = static_cast<double>(int_num);
   event.arg_numbers["double"] = double_num;
   event.arg_strings["string"] = str;
-  event.arg_values["dict"] = make_scoped_ptr(new base::DictionaryValue());
+  event.arg_values["dict"] = base::WrapUnique(new base::DictionaryValue());
 
   ASSERT_TRUE(event.HasNumberArg("false"));
   ASSERT_TRUE(event.HasNumberArg("true"));
   ASSERT_TRUE(event.HasNumberArg("int"));
   ASSERT_TRUE(event.HasNumberArg("double"));
   ASSERT_TRUE(event.HasStringArg("string"));
   ASSERT_FALSE(event.HasNumberArg("notfound"));
   ASSERT_FALSE(event.HasStringArg("notfound"));
   ASSERT_TRUE(event.HasArg("dict"));
   ASSERT_FALSE(event.HasArg("notfound"));
 
   EXPECT_FALSE(event.GetKnownArgAsBool("false"));
   EXPECT_TRUE(event.GetKnownArgAsBool("true"));
   EXPECT_EQ(int_num, event.GetKnownArgAsInt("int"));
   EXPECT_EQ(double_num, event.GetKnownArgAsDouble("double"));
   EXPECT_STREQ(str, event.GetKnownArgAsString("string").c_str());
 
-  scoped_ptr<base::Value> arg;
+  std::unique_ptr<base::Value> arg;
   EXPECT_TRUE(event.GetArgAsValue("dict", &arg));
   EXPECT_EQ(base::Value::TYPE_DICTIONARY, arg->GetType());
 }
 
 TEST_F(TraceEventAnalyzerTest, QueryEventMember) {
   ManualSetUp();
 
   TraceEvent event;
   event.thread.process_id = 3;
   event.thread.thread_id = 4;
@@ skipping 97 matching lines @@
 
   BeginTracing();
   {
     TRACE_EVENT_INSTANT1("cat1", "name1", TRACE_EVENT_SCOPE_THREAD, "num", 1);
     TRACE_EVENT_INSTANT1("cat1", "name2", TRACE_EVENT_SCOPE_THREAD, "num", 2);
     TRACE_EVENT_INSTANT1("cat2", "name3", TRACE_EVENT_SCOPE_THREAD, "num", 3);
     TRACE_EVENT_INSTANT1("cat2", "name4", TRACE_EVENT_SCOPE_THREAD, "num", 4);
   }
   EndTracing();
 
-  scoped_ptr<TraceAnalyzer>
-      analyzer(TraceAnalyzer::Create(output_.json_output));
+  std::unique_ptr<TraceAnalyzer> analyzer(
+      TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer);
   analyzer->SetIgnoreMetadataEvents(true);
 
   TraceEventVector found;
 
   // ==
 
   analyzer->FindEvents(Query::EventCategory() == Query::String("cat1"), &found);
   ASSERT_EQ(2u, found.size());
   EXPECT_STREQ("name1", found[0]->name.c_str());
@@ skipping 69 matching lines @@
     TRACE_EVENT_INSTANT2("cat1", "math2", TRACE_EVENT_SCOPE_THREAD,
                          "a", 10, "b", 10);
     // Extra events that never match, for noise:
     TRACE_EVENT_INSTANT2("noise", "math3", TRACE_EVENT_SCOPE_THREAD,
                          "a", 1,  "b", 3);
     TRACE_EVENT_INSTANT2("noise", "math4", TRACE_EVENT_SCOPE_THREAD,
                          "c", 10, "d", 5);
   }
   EndTracing();
 
-  scoped_ptr<TraceAnalyzer>
-      analyzer(TraceAnalyzer::Create(output_.json_output));
+  std::unique_ptr<TraceAnalyzer> analyzer(
+      TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
 
   TraceEventVector found;
 
   // Verify that arithmetic operators function:
 
   // +
   analyzer->FindEvents(Query::EventArg("a") + Query::EventArg("b") ==
                        Query::Int(20), &found);
   EXPECT_EQ(1u, found.size());
@@ skipping 33 matching lines @@
 
   BeginTracing();
   {
     TRACE_EVENT_INSTANT0("cat1", "name1", TRACE_EVENT_SCOPE_THREAD);
     TRACE_EVENT_INSTANT0("cat1", "name2", TRACE_EVENT_SCOPE_THREAD);
     TRACE_EVENT_INSTANT0("cat1", "no match", TRACE_EVENT_SCOPE_THREAD);
     TRACE_EVENT_INSTANT0("cat1", "name3x", TRACE_EVENT_SCOPE_THREAD);
   }
   EndTracing();
 
-  scoped_ptr<TraceAnalyzer>
-      analyzer(TraceAnalyzer::Create(output_.json_output));
+  std::unique_ptr<TraceAnalyzer> analyzer(
+      TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
   analyzer->SetIgnoreMetadataEvents(true);
 
   TraceEventVector found;
 
   analyzer->FindEvents(Query::EventName() == Query::Pattern("name?"), &found);
   ASSERT_EQ(2u, found.size());
   EXPECT_STREQ("name1", found[0]->name.c_str());
   EXPECT_STREQ("name2", found[1]->name.c_str());
 
@@ skipping 28 matching lines @@
       base::PlatformThread::Sleep(kSleepTime);
       TRACE_EVENT_BEGIN0("cat2", "name5"); // not found (duration too short)
       TRACE_EVENT_END0("cat2", "name5"); // not found (duration too short)
       TRACE_EVENT_END0("cat2", "name3"); // found by duration query
     }
     TRACE_EVENT_END0("noise", "name2"); // not searched for, just noise
     TRACE_EVENT_END0("cat1", "name1"); // found by duration query
   }
   EndTracing();
 
-  scoped_ptr<TraceAnalyzer>
-      analyzer(TraceAnalyzer::Create(output_.json_output));
+  std::unique_ptr<TraceAnalyzer> analyzer(
+      TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
   analyzer->AssociateBeginEndEvents();
 
   TraceEventVector found;
   analyzer->FindEvents(
       Query::MatchBeginWithEnd() &&
       Query::EventDuration() >
           Query::Int(static_cast<int>(duration_cutoff_us)) &&
       (Query::EventCategory() == Query::String("cat1") ||
        Query::EventCategory() == Query::String("cat2") ||
@@ skipping 20 matching lines @@
     {
       TRACE_EVENT0("cat2", "name3"); // found by duration query
       // next event not searched for, just noise
       TRACE_EVENT_INSTANT0("noise", "name4", TRACE_EVENT_SCOPE_THREAD);
       base::PlatformThread::Sleep(kSleepTime);
       TRACE_EVENT0("cat2", "name5"); // not found (duration too short)
     }
   }
   EndTracing();
 
-  scoped_ptr<TraceAnalyzer>
-      analyzer(TraceAnalyzer::Create(output_.json_output));
+  std::unique_ptr<TraceAnalyzer> analyzer(
+      TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
   analyzer->AssociateBeginEndEvents();
 
   TraceEventVector found;
   analyzer->FindEvents(
       Query::EventCompleteDuration() >
           Query::Int(static_cast<int>(duration_cutoff_us)) &&
       (Query::EventCategory() == Query::String("cat1") ||
        Query::EventCategory() == Query::String("cat2") ||
        Query::EventCategory() == Query::String("cat3")),
@@ skipping 10 matching lines @@
   BeginTracing();
   {
     TRACE_EVENT_END0("cat1", "name1"); // does not match out of order begin
     TRACE_EVENT_BEGIN0("cat1", "name2");
     TRACE_EVENT_INSTANT0("cat1", "name3", TRACE_EVENT_SCOPE_THREAD);
     TRACE_EVENT_BEGIN0("cat1", "name1");
     TRACE_EVENT_END0("cat1", "name2");
   }
   EndTracing();
 
-  scoped_ptr<TraceAnalyzer>
-      analyzer(TraceAnalyzer::Create(output_.json_output));
+  std::unique_ptr<TraceAnalyzer> analyzer(
+      TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
   analyzer->AssociateBeginEndEvents();
 
   TraceEventVector found;
   analyzer->FindEvents(Query::MatchBeginWithEnd(), &found);
   ASSERT_EQ(1u, found.size());
   EXPECT_STREQ("name2", found[0]->name.c_str());
 }
 
 // Test MergeAssociatedEventArgs
 TEST_F(TraceEventAnalyzerTest, MergeAssociatedEventArgs) {
   ManualSetUp();
 
   const char arg_string[] = "arg_string";
   BeginTracing();
   {
     TRACE_EVENT_BEGIN0("cat1", "name1");
     TRACE_EVENT_END1("cat1", "name1", "arg", arg_string);
   }
   EndTracing();
 
-  scoped_ptr<TraceAnalyzer>
-      analyzer(TraceAnalyzer::Create(output_.json_output));
+  std::unique_ptr<TraceAnalyzer> analyzer(
+      TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
   analyzer->AssociateBeginEndEvents();
 
   TraceEventVector found;
   analyzer->FindEvents(Query::MatchBeginName("name1"), &found);
   ASSERT_EQ(1u, found.size());
   std::string arg_actual;
   EXPECT_FALSE(found[0]->GetArgAsString("arg", &arg_actual));
 
   analyzer->MergeAssociatedEventArgs();
@@ skipping 11 matching lines @@
     TRACE_EVENT_ASYNC_BEGIN0("cat1", "name1", 0xB);
     TRACE_EVENT_ASYNC_BEGIN0("cat1", "name1", 0xC);
     TRACE_EVENT_INSTANT0("cat1", "name1", TRACE_EVENT_SCOPE_THREAD); // noise
     TRACE_EVENT0("cat1", "name1"); // noise
     TRACE_EVENT_ASYNC_END0("cat1", "name1", 0xB);
     TRACE_EVENT_ASYNC_END0("cat1", "name1", 0xC);
     TRACE_EVENT_ASYNC_BEGIN0("cat1", "name1", 0xA); // no match / out of order
   }
   EndTracing();
 
-  scoped_ptr<TraceAnalyzer>
-      analyzer(TraceAnalyzer::Create(output_.json_output));
+  std::unique_ptr<TraceAnalyzer> analyzer(
+      TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
   analyzer->AssociateAsyncBeginEndEvents();
 
   TraceEventVector found;
   analyzer->FindEvents(Query::MatchAsyncBeginWithNext(), &found);
   ASSERT_EQ(2u, found.size());
   EXPECT_STRCASEEQ("0xb", found[0]->id.c_str());
   EXPECT_STRCASEEQ("0xc", found[1]->id.c_str());
 }
 
@@ skipping 10 matching lines @@
     TRACE_EVENT_ASYNC_STEP_PAST0("c", "n", 0xB, "s1");
     TRACE_EVENT_ASYNC_STEP_INTO0("c", "n", 0xC, "s1");
     TRACE_EVENT_ASYNC_STEP_INTO1("c", "n", 0xC, "s2", "a", 1);
     TRACE_EVENT_ASYNC_END0("c", "n", 0xB);
     TRACE_EVENT_ASYNC_END0("c", "n", 0xC);
     TRACE_EVENT_ASYNC_BEGIN0("c", "n", 0xA);
     TRACE_EVENT_ASYNC_STEP_INTO0("c", "n", 0xA, "s2");
   }
   EndTracing();
 
-  scoped_ptr<TraceAnalyzer>
-      analyzer(TraceAnalyzer::Create(output_.json_output));
+  std::unique_ptr<TraceAnalyzer> analyzer(
+      TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
   analyzer->AssociateAsyncBeginEndEvents();
 
   TraceEventVector found;
   analyzer->FindEvents(Query::MatchAsyncBeginWithNext(), &found);
   ASSERT_EQ(3u, found.size());
 
   EXPECT_STRCASEEQ("0xb", found[0]->id.c_str());
   EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_STEP_PAST, found[0]->other_event->phase);
   EXPECT_TRUE(found[0]->other_event->other_event);
@@ skipping 31 matching lines @@
     TRACE_EVENT_INSTANT1("cat2", "begin", TRACE_EVENT_SCOPE_THREAD, "id", 2);
     // end is cat5
     TRACE_EVENT_INSTANT1("cat3", "begin", TRACE_EVENT_SCOPE_THREAD, "id", 3);
     TRACE_EVENT_INSTANT1("cat4", "end", TRACE_EVENT_SCOPE_THREAD, "id", 2);
     TRACE_EVENT_INSTANT1("cat5", "end", TRACE_EVENT_SCOPE_THREAD, "id", 3);
     // no end match
     TRACE_EVENT_INSTANT1("cat6", "begin", TRACE_EVENT_SCOPE_THREAD, "id", 1);
   }
   EndTracing();
 
-  scoped_ptr<TraceAnalyzer>
-      analyzer(TraceAnalyzer::Create(output_.json_output));
+  std::unique_ptr<TraceAnalyzer> analyzer(
+      TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
 
   // begin, end, and match queries to find proper begin/end pairs.
   Query begin(Query::EventName() == Query::String("begin"));
   Query end(Query::EventName() == Query::String("end"));
   Query match(Query::EventArg("id") == Query::OtherArg("id"));
   analyzer->AssociateEvents(begin, end, match);
 
   TraceEventVector found;
 
@@ skipping 252 matching lines @@
   EXPECT_EQ(1u, CountMatches(event_ptrs, query_one));
   EXPECT_EQ(num_events - 1, CountMatches(event_ptrs, !query_one));
   EXPECT_EQ(num_named, CountMatches(event_ptrs, query_named));
 }
 
 TEST_F(TraceEventAnalyzerTest, ComplexArgument) {
   ManualSetUp();
 
   BeginTracing();
   {
-    scoped_ptr<base::trace_event::TracedValue> value(
+    std::unique_ptr<base::trace_event::TracedValue> value(
         new base::trace_event::TracedValue);
     value->SetString("property", "value");
     TRACE_EVENT1("cat", "name", "arg", std::move(value));
   }
   EndTracing();
 
-  scoped_ptr<TraceAnalyzer> analyzer(
+  std::unique_ptr<TraceAnalyzer> analyzer(
       TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
 
   TraceEventVector events;
   analyzer->FindEvents(Query::EventName() == Query::String("name"), &events);
 
   EXPECT_EQ(1u, events.size());
   EXPECT_EQ("cat", events[0]->category);
   EXPECT_EQ("name", events[0]->name);
   EXPECT_TRUE(events[0]->HasArg("arg"));
 
-  scoped_ptr<base::Value> arg;
+  std::unique_ptr<base::Value> arg;
   events[0]->GetArgAsValue("arg", &arg);
   base::DictionaryValue* arg_dict;
   EXPECT_TRUE(arg->GetAsDictionary(&arg_dict));
   std::string property;
   EXPECT_TRUE(arg_dict->GetString("property", &property));
   EXPECT_EQ("value", property);
 }
 
 }  // namespace trace_analyzer