Convert //base to use std::unique_ptr

base/trace_event/trace_event_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/trace_event/trace_event.h"
+
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cstdlib>
+#include <memory>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/process/process_handle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/pattern.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_buffer.h"
-#include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "base/values.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
@@ skipping 135 matching lines @@
   num_flush_callbacks_++;
   if (num_flush_callbacks_ > 1) {
     EXPECT_FALSE(events_str->data().empty());
   }
   AutoLock lock(lock_);
   json_output_.json_output.clear();
   trace_buffer_.Start();
   trace_buffer_.AddFragment(events_str->data());
   trace_buffer_.Finish();
 
-  scoped_ptr<Value> root = base::JSONReader::Read(
+  std::unique_ptr<Value> root = base::JSONReader::Read(
       json_output_.json_output, JSON_PARSE_RFC | JSON_DETACHABLE_CHILDREN);
 
   if (!root.get()) {
     LOG(ERROR) << json_output_.json_output;
   }
 
   ListValue* root_list = NULL;
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->GetAsList(&root_list));
 
   // Move items into our aggregate collection
   while (root_list->GetSize()) {
-    scoped_ptr<Value> item;
+    std::unique_ptr<Value> item;
     root_list->Remove(0, &item);
     trace_parsed_.Append(item.release());
   }
 
   if (!has_more_events)
     flush_complete_event->Signal();
 }
 
 static bool CompareJsonValues(const std::string& lhs,
                               const std::string& rhs,
@@ skipping 49 matching lines @@
       continue;
     DictionaryValue* dict = static_cast<DictionaryValue*>(value);
 
     if (IsAllKeyValueInDict(key_values, dict))
       return dict;
   }
   return NULL;
 }
 
 void TraceEventTestFixture::DropTracedMetadataRecords() {
-  scoped_ptr<ListValue> old_trace_parsed(trace_parsed_.DeepCopy());
+  std::unique_ptr<ListValue> old_trace_parsed(trace_parsed_.DeepCopy());
   size_t old_trace_parsed_size = old_trace_parsed->GetSize();
   trace_parsed_.Clear();
 
   for (size_t i = 0; i < old_trace_parsed_size; i++) {
     Value* value = NULL;
     old_trace_parsed->Get(i, &value);
     if (!value || value->GetType() != Value::TYPE_DICTIONARY) {
       trace_parsed_.Append(value->DeepCopy());
       continue;
     }
@@ skipping 960 matching lines @@
     ~Convertable() override {}
     void AppendAsTraceFormat(std::string* out) const override {
       (*num_calls_)++;
       out->append("\"metadata_value\"");
     }
 
    private:
     int* num_calls_;
   };
 
-  scoped_ptr<ConvertableToTraceFormat> conv1(new Convertable(&num_calls));
-  scoped_ptr<Convertable> conv2(new Convertable(&num_calls));
+  std::unique_ptr<ConvertableToTraceFormat> conv1(new Convertable(&num_calls));
+  std::unique_ptr<Convertable> conv2(new Convertable(&num_calls));
 
   BeginTrace();
   TRACE_EVENT_API_ADD_METADATA_EVENT(
       TraceLog::GetCategoryGroupEnabled("__metadata"), "metadata_event_1",
       "metadata_arg_name", std::move(conv1));
   TRACE_EVENT_API_ADD_METADATA_EVENT(
       TraceLog::GetCategoryGroupEnabled("__metadata"), "metadata_event_2",
       "metadata_arg_name", std::move(conv2));
   // |AppendAsTraceFormat| should only be called on flush, not when the event
   // is added.
@@ skipping 785 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MyData);
 };
 
 TEST_F(TraceEventTestFixture, ConvertableTypes) {
   TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
                                       TraceLog::RECORDING_MODE);
 
-  scoped_ptr<ConvertableToTraceFormat> data(new MyData());
-  scoped_ptr<ConvertableToTraceFormat> data1(new MyData());
-  scoped_ptr<ConvertableToTraceFormat> data2(new MyData());
+  std::unique_ptr<ConvertableToTraceFormat> data(new MyData());
+  std::unique_ptr<ConvertableToTraceFormat> data1(new MyData());
+  std::unique_ptr<ConvertableToTraceFormat> data2(new MyData());
   TRACE_EVENT1("foo", "bar", "data", std::move(data));
   TRACE_EVENT2("foo", "baz", "data1", std::move(data1), "data2",
                std::move(data2));
 
-  // Check that scoped_ptr<DerivedClassOfConvertable> are properly treated as
+  // Check that std::unique_ptr<DerivedClassOfConvertable> are properly treated
+  // as
   // convertable and not accidentally casted to bool.
-  scoped_ptr<MyData> convertData1(new MyData());
-  scoped_ptr<MyData> convertData2(new MyData());
-  scoped_ptr<MyData> convertData3(new MyData());
-  scoped_ptr<MyData> convertData4(new MyData());
+  std::unique_ptr<MyData> convertData1(new MyData());
+  std::unique_ptr<MyData> convertData2(new MyData());
+  std::unique_ptr<MyData> convertData3(new MyData());
+  std::unique_ptr<MyData> convertData4(new MyData());
   TRACE_EVENT2("foo", "string_first", "str", "string value 1", "convert",
                std::move(convertData1));
   TRACE_EVENT2("foo", "string_second", "convert", std::move(convertData2),
                "str", "string value 2");
   TRACE_EVENT2("foo", "both_conv", "convert1", std::move(convertData3),
                "convert2", std::move(convertData4));
   EndTraceAndFlush();
 
   // One arg version.
   DictionaryValue* dict = FindNamePhase("bar", "X");
@@ skipping 599 matching lines @@
   TraceLog::GetInstance()->SetEnabled(
       TraceConfig(kRecordAllCategoryFilter, RECORD_CONTINUOUSLY),
       TraceLog::RECORDING_MODE);
   TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
   size_t capacity = buffer->Capacity();
   size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize;
   uint32_t last_seq = 0;
   size_t chunk_index;
   EXPECT_EQ(0u, buffer->Size());
 
-  scoped_ptr<TraceBufferChunk*[]> chunks(new TraceBufferChunk*[num_chunks]);
+  std::unique_ptr<TraceBufferChunk* []> chunks(
+      new TraceBufferChunk*[num_chunks]);
   for (size_t i = 0; i < num_chunks; ++i) {
     chunks[i] = buffer->GetChunk(&chunk_index).release();
     EXPECT_TRUE(chunks[i]);
     EXPECT_EQ(i, chunk_index);
     EXPECT_GT(chunks[i]->seq(), last_seq);
     EXPECT_EQ((i + 1) * TraceBufferChunk::kTraceBufferChunkSize,
               buffer->Size());
     last_seq = chunks[i]->seq();
   }
 
   // Ring buffer is never full.
   EXPECT_FALSE(buffer->IsFull());
 
   // Return all chunks in original order.
   for (size_t i = 0; i < num_chunks; ++i)
-    buffer->ReturnChunk(i, scoped_ptr<TraceBufferChunk>(chunks[i]));
+    buffer->ReturnChunk(i, std::unique_ptr<TraceBufferChunk>(chunks[i]));
 
   // Should recycle the chunks in the returned order.
   for (size_t i = 0; i < num_chunks; ++i) {
     chunks[i] = buffer->GetChunk(&chunk_index).release();
     EXPECT_TRUE(chunks[i]);
     EXPECT_EQ(i, chunk_index);
     EXPECT_GT(chunks[i]->seq(), last_seq);
     last_seq = chunks[i]->seq();
   }
 
   // Return all chunks in reverse order.
   for (size_t i = 0; i < num_chunks; ++i) {
-    buffer->ReturnChunk(
-        num_chunks - i - 1,
-        scoped_ptr<TraceBufferChunk>(chunks[num_chunks - i - 1]));
+    buffer->ReturnChunk(num_chunks - i - 1, std::unique_ptr<TraceBufferChunk>(
+                                                chunks[num_chunks - i - 1]));
   }
 
   // Should recycle the chunks in the returned order.
   for (size_t i = 0; i < num_chunks; ++i) {
     chunks[i] = buffer->GetChunk(&chunk_index).release();
     EXPECT_TRUE(chunks[i]);
     EXPECT_EQ(num_chunks - i - 1, chunk_index);
     EXPECT_GT(chunks[i]->seq(), last_seq);
     last_seq = chunks[i]->seq();
   }
 
   for (size_t i = 0; i < num_chunks; ++i)
-    buffer->ReturnChunk(i, scoped_ptr<TraceBufferChunk>(chunks[i]));
+    buffer->ReturnChunk(i, std::unique_ptr<TraceBufferChunk>(chunks[i]));
 
   TraceLog::GetInstance()->SetDisabled();
 }
 
 TEST_F(TraceEventTestFixture, TraceBufferRingBufferHalfIteration) {
   TraceLog::GetInstance()->SetEnabled(
       TraceConfig(kRecordAllCategoryFilter, RECORD_CONTINUOUSLY),
       TraceLog::RECORDING_MODE);
   TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
   size_t capacity = buffer->Capacity();
   size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize;
   size_t chunk_index;
   EXPECT_EQ(0u, buffer->Size());
   EXPECT_FALSE(buffer->NextChunk());
 
   size_t half_chunks = num_chunks / 2;
-  scoped_ptr<TraceBufferChunk*[]> chunks(new TraceBufferChunk*[half_chunks]);
+  std::unique_ptr<TraceBufferChunk* []> chunks(
+      new TraceBufferChunk*[half_chunks]);
 
   for (size_t i = 0; i < half_chunks; ++i) {
     chunks[i] = buffer->GetChunk(&chunk_index).release();
     EXPECT_TRUE(chunks[i]);
     EXPECT_EQ(i, chunk_index);
   }
   for (size_t i = 0; i < half_chunks; ++i)
-    buffer->ReturnChunk(i, scoped_ptr<TraceBufferChunk>(chunks[i]));
+    buffer->ReturnChunk(i, std::unique_ptr<TraceBufferChunk>(chunks[i]));
 
   for (size_t i = 0; i < half_chunks; ++i)
     EXPECT_EQ(chunks[i], buffer->NextChunk());
   EXPECT_FALSE(buffer->NextChunk());
   TraceLog::GetInstance()->SetDisabled();
 }
 
 TEST_F(TraceEventTestFixture, TraceBufferRingBufferFullIteration) {
   TraceLog::GetInstance()->SetEnabled(
       TraceConfig(kRecordAllCategoryFilter, RECORD_CONTINUOUSLY),
       TraceLog::RECORDING_MODE);
   TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
   size_t capacity = buffer->Capacity();
   size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize;
   size_t chunk_index;
   EXPECT_EQ(0u, buffer->Size());
   EXPECT_FALSE(buffer->NextChunk());
 
-  scoped_ptr<TraceBufferChunk*[]> chunks(new TraceBufferChunk*[num_chunks]);
+  std::unique_ptr<TraceBufferChunk* []> chunks(
+      new TraceBufferChunk*[num_chunks]);
 
   for (size_t i = 0; i < num_chunks; ++i) {
     chunks[i] = buffer->GetChunk(&chunk_index).release();
     EXPECT_TRUE(chunks[i]);
     EXPECT_EQ(i, chunk_index);
   }
   for (size_t i = 0; i < num_chunks; ++i)
-    buffer->ReturnChunk(i, scoped_ptr<TraceBufferChunk>(chunks[i]));
+    buffer->ReturnChunk(i, std::unique_ptr<TraceBufferChunk>(chunks[i]));
 
   for (size_t i = 0; i < num_chunks; ++i)
     EXPECT_TRUE(chunks[i] == buffer->NextChunk());
   EXPECT_FALSE(buffer->NextChunk());
   TraceLog::GetInstance()->SetDisabled();
 }
 
 TEST_F(TraceEventTestFixture, TraceRecordAsMuchAsPossibleMode) {
   TraceLog::GetInstance()->SetEnabled(
     TraceConfig(kRecordAllCategoryFilter, RECORD_AS_MUCH_AS_POSSIBLE),
@@ skipping 284 matching lines @@
 }
 
 TEST_F(TraceEventTestFixture, SyntheticDelayConfigurationToString) {
   const char filter[] = "DELAY(test.Delay;16;oneshot)";
   TraceConfig config(filter, "");
   EXPECT_EQ(filter, config.ToCategoryFilterString());
 }
 
 }  // namespace trace_event
 }  // namespace base