DevTools: migrate from OwnPtr to std::unique_ptr for inspector protocol classes.

third_party/WebKit/Source/platform/v8_inspector/V8HeapProfilerAgentImpl.cpp

 // Copyright 2016 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 "platform/v8_inspector/V8HeapProfilerAgentImpl.h"
 
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
@@ skipping 115 matching lines @@
 
     WriteResult WriteAsciiChunk(char* data, int size) override
     {
         DCHECK(false);
         return kAbort;
     }
 
     WriteResult WriteHeapStatsChunk(v8::HeapStatsUpdate* updateData, int count) override
     {
         DCHECK_GT(count, 0);
-        OwnPtr<protocol::Array<int>> statsDiff = protocol::Array<int>::create();
+        std::unique_ptr<protocol::Array<int>> statsDiff = protocol::Array<int>::create();
         for (int i = 0; i < count; ++i) {
             statsDiff->addItem(updateData[i].index);
             statsDiff->addItem(updateData[i].count);
             statsDiff->addItem(updateData[i].size);
         }
         m_frontend->heapStatsUpdate(std::move(statsDiff));
         return kContinue;
     }
 
 private:
@@ skipping 70 matching lines @@
     m_state->setBoolean(HeapProfilerAgentState::heapProfilerEnabled, false);
 }
 
 void V8HeapProfilerAgentImpl::takeHeapSnapshot(ErrorString* errorString, const protocol::Maybe<bool>& reportProgress)
 {
     v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();
     if (!profiler) {
         *errorString = "Cannot access v8 heap profiler";
         return;
     }
-    OwnPtr<HeapSnapshotProgress> progress;
+    std::unique_ptr<HeapSnapshotProgress> progress;
     if (reportProgress.fromMaybe(false))
-        progress = adoptPtr(new HeapSnapshotProgress(m_frontend));
+        progress = wrapUnique(new HeapSnapshotProgress(m_frontend));
 
     GlobalObjectNameResolver resolver(m_session);
     const v8::HeapSnapshot* snapshot = profiler->TakeHeapSnapshot(progress.get(), &resolver);
     if (!snapshot) {
         *errorString = "Failed to take heap snapshot";
         return;
     }
     HeapSnapshotOutputStream stream(m_frontend);
     snapshot->Serialize(&stream);
     const_cast<v8::HeapSnapshot*>(snapshot)->Delete();
 }
 
-void V8HeapProfilerAgentImpl::getObjectByHeapObjectId(ErrorString* error, const String16& heapSnapshotObjectId, const protocol::Maybe<String16>& objectGroup, OwnPtr<protocol::Runtime::RemoteObject>* result)
+void V8HeapProfilerAgentImpl::getObjectByHeapObjectId(ErrorString* error, const String16& heapSnapshotObjectId, const protocol::Maybe<String16>& objectGroup, std::unique_ptr<protocol::Runtime::RemoteObject>* result)
 {
     bool ok;
     int id = heapSnapshotObjectId.toInt(&ok);
     if (!ok) {
         *error = "Invalid heap snapshot object id";
         return;
     }
 
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Object> heapObject = objectByHeapObjectId(m_isolate, id);
@@ skipping 26 matching lines @@
     if (heapObject.IsEmpty()) {
         *errorString = "Object is not available";
         return;
     }
 
     if (!m_session->debugger()->client()->isInspectableHeapObject(heapObject)) {
         *errorString = "Object is not available";
         return;
     }
 
-    m_session->addInspectedObject(adoptPtr(new InspectableHeapObject(id)));
+    m_session->addInspectedObject(wrapUnique(new InspectableHeapObject(id)));
 }
 
 void V8HeapProfilerAgentImpl::getHeapObjectId(ErrorString* errorString, const String16& objectId, String16* heapSnapshotObjectId)
 {
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Value> value = m_session->findObject(errorString, objectId);
     if (value.IsEmpty() || value->IsUndefined())
         return;
 
     v8::SnapshotObjectId id = m_isolate->GetHeapProfiler()->GetObjectId(value);
@@ skipping 50 matching lines @@
 #if V8_MAJOR_VERSION * 1000 + V8_MINOR_VERSION >= 5002
     profiler->StartSamplingHeapProfiler(static_cast<uint64_t>(samplingIntervalValue), 128, v8::HeapProfiler::kSamplingForceGC);
 #else
     profiler->StartSamplingHeapProfiler(static_cast<uint64_t>(samplingIntervalValue), 128);
 #endif
 #endif
 }
 
 #if V8_MAJOR_VERSION >= 5
 namespace {
-PassOwnPtr<protocol::HeapProfiler::SamplingHeapProfileNode> buildSampingHeapProfileNode(const v8::AllocationProfile::Node* node)
+std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfileNode> buildSampingHeapProfileNode(const v8::AllocationProfile::Node* node)
 {
     auto children = protocol::Array<protocol::HeapProfiler::SamplingHeapProfileNode>::create();
     for (const auto* child : node->children)
         children->addItem(buildSampingHeapProfileNode(child));
     size_t selfSize = 0;
     for (const auto& allocation : node->allocations)
         selfSize += allocation.size * allocation.count;
-    OwnPtr<protocol::HeapProfiler::SamplingHeapProfileNode> result = protocol::HeapProfiler::SamplingHeapProfileNode::create()
+    std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfileNode> result = protocol::HeapProfiler::SamplingHeapProfileNode::create()
         .setFunctionName(toProtocolString(node->name))
         .setScriptId(String16::number(node->script_id))
         .setUrl(toProtocolString(node->script_name))
         .setLineNumber(node->line_number)
         .setColumnNumber(node->column_number)
         .setSelfSize(selfSize)
         .setChildren(std::move(children)).build();
     return result;
 }
 } // namespace
 #endif
 
-void V8HeapProfilerAgentImpl::stopSampling(ErrorString* errorString, OwnPtr<protocol::HeapProfiler::SamplingHeapProfile>* profile)
+void V8HeapProfilerAgentImpl::stopSampling(ErrorString* errorString, std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfile>* profile)
 {
 #if V8_MAJOR_VERSION >= 5
     v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();
     if (!profiler) {
         *errorString = "Cannot access v8 heap profiler";
         return;
     }
     v8::HandleScope scope(m_isolate); // Allocation profile contains Local handles.
-    OwnPtr<v8::AllocationProfile> v8Profile = adoptPtr(profiler->GetAllocationProfile());
+    std::unique_ptr<v8::AllocationProfile> v8Profile(profiler->GetAllocationProfile());
     profiler->StopSamplingHeapProfiler();
     m_state->setBoolean(HeapProfilerAgentState::samplingHeapProfilerEnabled, false);
     if (!v8Profile) {
         *errorString = "Cannot access v8 sampled heap profile.";
         return;
     }
     v8::AllocationProfile::Node* root = v8Profile->GetRootNode();
     *profile = protocol::HeapProfiler::SamplingHeapProfile::create()
         .setHead(buildSampingHeapProfileNode(root)).build();
 #endif
 }
 
 } // namespace blink