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

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

 /*
  * Copyright (c) 2010-2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 51 matching lines @@
 
 v8::MaybeLocal<v8::Value> V8DebuggerImpl::callDebuggerMethod(const char* functionName, int argc, v8::Local<v8::Value> argv[])
 {
     v8::MicrotasksScope microtasks(m_isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
     v8::Local<v8::Object> debuggerScript = m_debuggerScript.Get(m_isolate);
     v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8InternalizedString(functionName)));
     DCHECK(m_isolate->InContext());
     return function->Call(m_isolate->GetCurrentContext(), debuggerScript, argc, argv);
 }
 
-PassOwnPtr<V8Debugger> V8Debugger::create(v8::Isolate* isolate, V8DebuggerClient* client)
+std::unique_ptr<V8Debugger> V8Debugger::create(v8::Isolate* isolate, V8DebuggerClient* client)
 {
-    return adoptPtr(new V8DebuggerImpl(isolate, client));
+    return wrapUnique(new V8DebuggerImpl(isolate, client));
 }
 
 V8DebuggerImpl::V8DebuggerImpl(v8::Isolate* isolate, V8DebuggerClient* client)
     : m_isolate(isolate)
     , m_client(client)
     , m_enabledAgentsCount(0)
     , m_breakpointsActivated(true)
     , m_runningNestedMessageLoop(false)
 {
 }
@@ skipping 280 matching lines @@
             v8::Debug::SetLiveEditEnabled(m_isolate, false);
             inLiveEditScope = false;
         }
     private:
         v8::Isolate* m_isolate;
     };
 
     DCHECK(enabled());
     v8::HandleScope scope(m_isolate);
 
-    OwnPtr<v8::Context::Scope> contextScope;
+    std::unique_ptr<v8::Context::Scope> contextScope;
     if (!isPaused())
-        contextScope = adoptPtr(new v8::Context::Scope(debuggerContext()));
+        contextScope = wrapUnique(new v8::Context::Scope(debuggerContext()));
 
     v8::Local<v8::Value> argv[] = { toV8String(m_isolate, sourceID), toV8String(m_isolate, newContent), v8Boolean(preview, m_isolate) };
 
     v8::Local<v8::Value> v8result;
     {
         EnableLiveEditScope enableLiveEditScope(m_isolate);
         v8::TryCatch tryCatch(m_isolate);
         tryCatch.SetVerbose(false);
         v8::MaybeLocal<v8::Value> maybeResult = callDebuggerMethod("liveEditScriptSource", 3, argv);
         if (tryCatch.HasCaught()) {
@@ skipping 330 matching lines @@
         v8::True(m_isolate), // internal
         toV8String(m_isolate, String16()), // sourceMap
         v8::True(m_isolate)); // opaqueresource
     v8::ScriptCompiler::Source source(code, origin);
     v8::Local<v8::Script> script;
     if (!v8::ScriptCompiler::Compile(context, &source, v8::ScriptCompiler::kNoCompileOptions).ToLocal(&script))
         return v8::Local<v8::Script>();
     return script;
 }
 
-PassOwnPtr<V8StackTrace> V8DebuggerImpl::createStackTrace(v8::Local<v8::StackTrace> stackTrace, size_t maxStackSize)
+std::unique_ptr<V8StackTrace> V8DebuggerImpl::createStackTrace(v8::Local<v8::StackTrace> stackTrace, size_t maxStackSize)
 {
     V8DebuggerAgentImpl* agent = findEnabledDebuggerAgent(m_isolate->GetCurrentContext());
     return V8StackTraceImpl::create(agent, stackTrace, maxStackSize);
 }
 
-PassOwnPtr<V8InspectorSession> V8DebuggerImpl::connect(int contextGroupId, V8InspectorSessionClient* client, const String16* state)
+std::unique_ptr<V8InspectorSession> V8DebuggerImpl::connect(int contextGroupId, V8InspectorSessionClient* client, const String16* state)
 {
     DCHECK(!m_sessions.contains(contextGroupId));
-    OwnPtr<V8InspectorSessionImpl> session = V8InspectorSessionImpl::create(this, contextGroupId, client, state);
+    std::unique_ptr<V8InspectorSessionImpl> session = V8InspectorSessionImpl::create(this, contextGroupId, client, state);
     m_sessions.set(contextGroupId, session.get());
     return std::move(session);
 }
 
 void V8DebuggerImpl::disconnect(V8InspectorSessionImpl* session)
 {
     DCHECK(m_sessions.contains(session->contextGroupId()));
     m_sessions.remove(session->contextGroupId());
 }
 
 void V8DebuggerImpl::contextCreated(const V8ContextInfo& info)
 {
     DCHECK(info.context->GetIsolate() == m_isolate);
     // TODO(dgozman): make s_lastContextId non-static.
     int contextId = atomicIncrement(&s_lastContextId);
     String16 debugData = String16::number(info.contextGroupId) + "," + String16::number(contextId) + "," + (info.isDefault ? "default" : "nondefault");
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(info.context);
     info.context->SetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex), toV8String(m_isolate, debugData));
 
     if (!m_contexts.contains(info.contextGroupId))
-        m_contexts.set(info.contextGroupId, adoptPtr(new ContextByIdMap()));
+        m_contexts.set(info.contextGroupId, wrapUnique(new ContextByIdMap()));
     DCHECK(!m_contexts.get(info.contextGroupId)->contains(contextId));
 
-    OwnPtr<InspectedContext> contextOwner = adoptPtr(new InspectedContext(this, info, contextId));
+    std::unique_ptr<InspectedContext> contextOwner(new InspectedContext(this, info, contextId));
     InspectedContext* inspectedContext = contextOwner.get();
     m_contexts.get(info.contextGroupId)->set(contextId, std::move(contextOwner));
 
     if (V8InspectorSessionImpl* session = m_sessions.get(info.contextGroupId))
         session->runtimeAgent()->reportExecutionContextCreated(inspectedContext);
 }
 
 void V8DebuggerImpl::contextDestroyed(v8::Local<v8::Context> context)
 {
     int contextId = V8Debugger::contextId(context);
@@ skipping 32 matching lines @@
 void V8DebuggerImpl::idleStarted()
 {
     m_isolate->GetCpuProfiler()->SetIdle(true);
 }
 
 void V8DebuggerImpl::idleFinished()
 {
     m_isolate->GetCpuProfiler()->SetIdle(false);
 }
 
-PassOwnPtr<V8StackTrace> V8DebuggerImpl::captureStackTrace(size_t maxStackSize)
+std::unique_ptr<V8StackTrace> V8DebuggerImpl::captureStackTrace(size_t maxStackSize)
 {
     V8DebuggerAgentImpl* agent = findEnabledDebuggerAgent(m_isolate->GetCurrentContext());
     return V8StackTraceImpl::capture(agent, maxStackSize);
 }
 
 v8::Local<v8::Context> V8DebuggerImpl::regexContext()
 {
     if (m_regexContext.IsEmpty())
         m_regexContext.Reset(m_isolate, v8::Context::New(m_isolate));
     return m_regexContext.Get(m_isolate);
@@ skipping 14 matching lines @@
         return nullptr;
     return m_contexts.get(contextGroupId);
 }
 
 V8InspectorSessionImpl* V8DebuggerImpl::sessionForContextGroup(int contextGroupId)
 {
     return contextGroupId ? m_sessions.get(contextGroupId) : nullptr;
 }
 
 } // namespace blink