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

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

 /*
  * Copyright (C) 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 61 matching lines @@
 void V8RuntimeAgentImpl::evaluate(
     ErrorString* errorString,
     const String16& expression,
     const Maybe<String16>& objectGroup,
     const Maybe<bool>& includeCommandLineAPI,
     const Maybe<bool>& doNotPauseOnExceptionsAndMuteConsole,
     const Maybe<int>& executionContextId,
     const Maybe<bool>& returnByValue,
     const Maybe<bool>& generatePreview,
     const Maybe<bool>& userGesture,
-    OwnPtr<RemoteObject>* result,
+    std::unique_ptr<RemoteObject>* result,
     Maybe<bool>* wasThrown,
     Maybe<ExceptionDetails>* exceptionDetails)
 {
     int contextId;
     if (executionContextId.isJust()) {
         contextId = executionContextId.fromJust();
     } else {
         contextId = m_debugger->client()->ensureDefaultContextInGroup(m_session->contextGroupId());
         if (!contextId) {
             *errorString = "Cannot find default execution context";
@@ skipping 41 matching lines @@
 }
 
 void V8RuntimeAgentImpl::callFunctionOn(ErrorString* errorString,
     const String16& objectId,
     const String16& expression,
     const Maybe<protocol::Array<protocol::Runtime::CallArgument>>& optionalArguments,
     const Maybe<bool>& doNotPauseOnExceptionsAndMuteConsole,
     const Maybe<bool>& returnByValue,
     const Maybe<bool>& generatePreview,
     const Maybe<bool>& userGesture,
-    OwnPtr<RemoteObject>* result,
+    std::unique_ptr<RemoteObject>* result,
     Maybe<bool>* wasThrown)
 {
     InjectedScript::ObjectScope scope(errorString, m_debugger, m_session->contextGroupId(), objectId);
     if (!scope.initialize())
         return;
 
-    OwnPtr<v8::Local<v8::Value>[]> argv = nullptr;
+    std::unique_ptr<v8::Local<v8::Value>[]> argv = nullptr;
     int argc = 0;
     if (optionalArguments.isJust()) {
         protocol::Array<protocol::Runtime::CallArgument>* arguments = optionalArguments.fromJust();
         argc = arguments->length();
-        argv = adoptArrayPtr(new v8::Local<v8::Value>[argc]);
+        argv.reset(new v8::Local<v8::Value>[argc]);
         for (int i = 0; i < argc; ++i) {
             v8::Local<v8::Value> argumentValue;
             if (!scope.injectedScript()->resolveCallArgument(errorString, arguments->get(i)).ToLocal(&argumentValue))
                 return;
             argv[i] = argumentValue;
         }
     }
 
     if (doNotPauseOnExceptionsAndMuteConsole.fromMaybe(false))
         scope.ignoreExceptionsAndMuteConsole();
@@ skipping 23 matching lines @@
 
     scope.injectedScript()->wrapEvaluateResult(errorString, maybeResultValue, scope.tryCatch(), scope.objectGroupName(), returnByValue.fromMaybe(false), generatePreview.fromMaybe(false), result, wasThrown, nullptr);
 }
 
 void V8RuntimeAgentImpl::getProperties(
     ErrorString* errorString,
     const String16& objectId,
     const Maybe<bool>& ownProperties,
     const Maybe<bool>& accessorPropertiesOnly,
     const Maybe<bool>& generatePreview,
-    OwnPtr<protocol::Array<protocol::Runtime::PropertyDescriptor>>* result,
+    std::unique_ptr<protocol::Array<protocol::Runtime::PropertyDescriptor>>* result,
     Maybe<protocol::Array<protocol::Runtime::InternalPropertyDescriptor>>* internalProperties,
     Maybe<ExceptionDetails>* exceptionDetails)
 {
     using protocol::Runtime::InternalPropertyDescriptor;
 
     InjectedScript::ObjectScope scope(errorString, m_debugger, m_session->contextGroupId(), objectId);
     if (!scope.initialize())
         return;
 
     scope.ignoreExceptionsAndMuteConsole();
     if (!scope.object()->IsObject()) {
         *errorString = "Value with given id is not an object";
         return;
     }
 
     v8::Local<v8::Object> object = scope.object().As<v8::Object>();
     scope.injectedScript()->getProperties(errorString, object, scope.objectGroupName(), ownProperties.fromMaybe(false), accessorPropertiesOnly.fromMaybe(false), generatePreview.fromMaybe(false), result, exceptionDetails);
     if (!errorString->isEmpty() || exceptionDetails->isJust() || accessorPropertiesOnly.fromMaybe(false))
         return;
     v8::Local<v8::Array> propertiesArray;
     if (hasInternalError(errorString, !v8::Debug::GetInternalProperties(m_debugger->isolate(), scope.object()).ToLocal(&propertiesArray)))
         return;
-    OwnPtr<protocol::Array<InternalPropertyDescriptor>> propertiesProtocolArray = protocol::Array<InternalPropertyDescriptor>::create();
+    std::unique_ptr<protocol::Array<InternalPropertyDescriptor>> propertiesProtocolArray = protocol::Array<InternalPropertyDescriptor>::create();
     for (uint32_t i = 0; i < propertiesArray->Length(); i += 2) {
         v8::Local<v8::Value> name;
         if (hasInternalError(errorString, !propertiesArray->Get(scope.context(), i).ToLocal(&name)) || !name->IsString())
             return;
         v8::Local<v8::Value> value;
         if (hasInternalError(errorString, !propertiesArray->Get(scope.context(), i + 1).ToLocal(&value)))
             return;
-        OwnPtr<RemoteObject> wrappedValue = scope.injectedScript()->wrapObject(errorString, value, scope.objectGroupName());
+        std::unique_ptr<RemoteObject> wrappedValue = scope.injectedScript()->wrapObject(errorString, value, scope.objectGroupName());
         if (!wrappedValue)
             return;
         propertiesProtocolArray->addItem(InternalPropertyDescriptor::create()
             .setName(toProtocolString(name.As<v8::String>()))
             .setValue(std::move(wrappedValue)).build());
     }
     if (!propertiesProtocolArray->length())
         return;
     *internalProperties = std::move(propertiesProtocolArray);
 }
@@ skipping 45 matching lines @@
             *exceptionDetails = scope.injectedScript()->createExceptionDetails(message);
         else
             *errorString = "Script compilation failed";
         return;
     }
 
     if (!persistScript)
         return;
 
     String16 scriptValueId = String16::number(script->GetUnboundScript()->GetId());
-    OwnPtr<v8::Global<v8::Script>> global = adoptPtr(new v8::Global<v8::Script>(m_debugger->isolate(), script));
+    std::unique_ptr<v8::Global<v8::Script>> global(new v8::Global<v8::Script>(m_debugger->isolate(), script));
     m_compiledScripts.set(scriptValueId, std::move(global));
     *scriptId = scriptValueId;
 }
 
 void V8RuntimeAgentImpl::runScript(ErrorString* errorString,
     const String16& scriptId,
     int executionContextId,
     const Maybe<String16>& objectGroup,
     const Maybe<bool>& doNotPauseOnExceptionsAndMuteConsole,
     const Maybe<bool>& includeCommandLineAPI,
-    OwnPtr<RemoteObject>* result,
+    std::unique_ptr<RemoteObject>* result,
     Maybe<ExceptionDetails>* exceptionDetails)
 {
     if (!m_enabled) {
         *errorString = "Runtime agent is not enabled";
         return;
     }
 
     if (!m_compiledScripts.contains(scriptId)) {
         *errorString = "Script execution failed";
         return;
     }
 
     InjectedScript::ContextScope scope(errorString, m_debugger, m_session->contextGroupId(), executionContextId);
     if (!scope.initialize())
         return;
 
     if (doNotPauseOnExceptionsAndMuteConsole.fromMaybe(false))
         scope.ignoreExceptionsAndMuteConsole();
 
-    OwnPtr<v8::Global<v8::Script>> scriptWrapper = m_compiledScripts.take(scriptId);
+    std::unique_ptr<v8::Global<v8::Script>> scriptWrapper = m_compiledScripts.take(scriptId);
     v8::Local<v8::Script> script = scriptWrapper->Get(m_debugger->isolate());
     if (script.IsEmpty()) {
         *errorString = "Script execution failed";
         return;
     }
 
     if (includeCommandLineAPI.fromMaybe(false) && !scope.installCommandLineAPI())
         return;
 
     v8::MaybeLocal<v8::Value> maybeResultValue = m_debugger->runCompiledScript(scope.context(), script);
@@ skipping 47 matching lines @@
         }
         m_frontend->executionContextsCleared();
     }
 }
 
 void V8RuntimeAgentImpl::reportExecutionContextCreated(InspectedContext* context)
 {
     if (!m_enabled)
         return;
     context->setReported(true);
-    OwnPtr<protocol::Runtime::ExecutionContextDescription> description = protocol::Runtime::ExecutionContextDescription::create()
+    std::unique_ptr<protocol::Runtime::ExecutionContextDescription> description = protocol::Runtime::ExecutionContextDescription::create()
         .setId(context->contextId())
         .setIsDefault(context->isDefault())
         .setName(context->humanReadableName())
         .setOrigin(context->origin())
         .setFrameId(context->frameId()).build();
     m_frontend->executionContextCreated(std::move(description));
 }
 
 void V8RuntimeAgentImpl::reportExecutionContextDestroyed(InspectedContext* context)
 {
     if (m_enabled && context->isReported()) {
         context->setReported(false);
         m_frontend->executionContextDestroyed(context->contextId());
     }
 }
 
-void V8RuntimeAgentImpl::inspect(PassOwnPtr<protocol::Runtime::RemoteObject> objectToInspect, PassOwnPtr<protocol::DictionaryValue> hints)
+void V8RuntimeAgentImpl::inspect(std::unique_ptr<protocol::Runtime::RemoteObject> objectToInspect, std::unique_ptr<protocol::DictionaryValue> hints)
 {
     if (m_enabled)
         m_frontend->inspectRequested(std::move(objectToInspect), std::move(hints));
 }
 
 } // namespace blink