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

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

 // Copyright 2015 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/V8DebuggerAgentImpl.h"
 
 #include "platform/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InspectedContext.h"
@@ skipping 129 matching lines @@
     return hash.toString();
 }
 
 static bool hasInternalError(ErrorString* errorString, bool hasError)
 {
     if (hasError)
         *errorString = "Internal error";
     return hasError;
 }
 
-static PassOwnPtr<protocol::Debugger::Location> buildProtocolLocation(const String16& scriptId, int lineNumber, int columnNumber)
+static std::unique_ptr<protocol::Debugger::Location> buildProtocolLocation(const String16& scriptId, int lineNumber, int columnNumber)
 {
     return protocol::Debugger::Location::create()
         .setScriptId(scriptId)
         .setLineNumber(lineNumber)
         .setColumnNumber(columnNumber).build();
 }
 
 V8DebuggerAgentImpl::V8DebuggerAgentImpl(V8InspectorSessionImpl* session, protocol::Frontend::Debugger* frontend, protocol::DictionaryValue* state)
     : m_debugger(session->debugger())
     , m_session(session)
@@ skipping 146 matching lines @@
         return;
     debugger().setBreakpointsActivated(active);
 }
 
 void V8DebuggerAgentImpl::setSkipAllPauses(ErrorString*, bool skipped)
 {
     m_skipAllPauses = skipped;
     m_state->setBoolean(DebuggerAgentState::skipAllPauses, m_skipAllPauses);
 }
 
-static PassOwnPtr<protocol::DictionaryValue> buildObjectForBreakpointCookie(const String16& url, int lineNumber, int columnNumber, const String16& condition, bool isRegex)
+static std::unique_ptr<protocol::DictionaryValue> buildObjectForBreakpointCookie(const String16& url, int lineNumber, int columnNumber, const String16& condition, bool isRegex)
 {
-    OwnPtr<protocol::DictionaryValue> breakpointObject = protocol::DictionaryValue::create();
+    std::unique_ptr<protocol::DictionaryValue> breakpointObject = protocol::DictionaryValue::create();
     breakpointObject->setString(DebuggerAgentState::url, url);
     breakpointObject->setNumber(DebuggerAgentState::lineNumber, lineNumber);
     breakpointObject->setNumber(DebuggerAgentState::columnNumber, columnNumber);
     breakpointObject->setString(DebuggerAgentState::condition, condition);
     breakpointObject->setBoolean(DebuggerAgentState::isRegex, isRegex);
     return breakpointObject;
 }
 
 static bool matches(V8DebuggerImpl* debugger, const String16& url, const String16& pattern, bool isRegex)
 {
     if (isRegex) {
         V8Regex regex(debugger, pattern, true);
         return regex.match(url) != -1;
     }
     return url == pattern;
 }
 
 void V8DebuggerAgentImpl::setBreakpointByUrl(ErrorString* errorString,
     int lineNumber,
     const Maybe<String16>& optionalURL,
     const Maybe<String16>& optionalURLRegex,
     const Maybe<int>& optionalColumnNumber,
     const Maybe<String16>& optionalCondition,
     String16* outBreakpointId,
-    OwnPtr<protocol::Array<protocol::Debugger::Location>>* locations)
+    std::unique_ptr<protocol::Array<protocol::Debugger::Location>>* locations)
 {
     *locations = Array<protocol::Debugger::Location>::create();
     if (optionalURL.isJust() == optionalURLRegex.isJust()) {
         *errorString = "Either url or urlRegex must be specified.";
         return;
     }
 
     String16 url = optionalURL.isJust() ? optionalURL.fromJust() : optionalURLRegex.fromJust();
     int columnNumber = 0;
     if (optionalColumnNumber.isJust()) {
         columnNumber = optionalColumnNumber.fromJust();
         if (columnNumber < 0) {
             *errorString = "Incorrect column number";
             return;
         }
     }
     String16 condition = optionalCondition.fromMaybe("");
     bool isRegex = optionalURLRegex.isJust();
 
     String16 breakpointId = (isRegex ? "/" + url + "/" : url) + ":" + String16::number(lineNumber) + ":" + String16::number(columnNumber);
     protocol::DictionaryValue* breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (!breakpointsCookie) {
-        OwnPtr<protocol::DictionaryValue> newValue = protocol::DictionaryValue::create();
+        std::unique_ptr<protocol::DictionaryValue> newValue = protocol::DictionaryValue::create();
         breakpointsCookie = newValue.get();
         m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, std::move(newValue));
     }
     if (breakpointsCookie->get(breakpointId)) {
         *errorString = "Breakpoint at specified location already exists.";
         return;
     }
 
     breakpointsCookie->setObject(breakpointId, buildObjectForBreakpointCookie(url, lineNumber, columnNumber, condition, isRegex));
 
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
     for (auto& script : m_scripts) {
         if (!matches(m_debugger, script.second->sourceURL(), url, isRegex))
             continue;
-        OwnPtr<protocol::Debugger::Location> location = resolveBreakpoint(breakpointId, script.first, breakpoint, UserBreakpointSource);
+        std::unique_ptr<protocol::Debugger::Location> location = resolveBreakpoint(breakpointId, script.first, breakpoint, UserBreakpointSource);
         if (location)
             (*locations)->addItem(std::move(location));
     }
 
     *outBreakpointId = breakpointId;
 }
 
-static bool parseLocation(ErrorString* errorString, PassOwnPtr<protocol::Debugger::Location> location, String16* scriptId, int* lineNumber, int* columnNumber)
+static bool parseLocation(ErrorString* errorString, std::unique_ptr<protocol::Debugger::Location> location, String16* scriptId, int* lineNumber, int* columnNumber)
 {
     *scriptId = location->getScriptId();
     *lineNumber = location->getLineNumber();
     *columnNumber = location->getColumnNumber(0);
     return true;
 }
 
 void V8DebuggerAgentImpl::setBreakpoint(ErrorString* errorString,
-    PassOwnPtr<protocol::Debugger::Location> location,
+    std::unique_ptr<protocol::Debugger::Location> location,
     const Maybe<String16>& optionalCondition,
     String16* outBreakpointId,
-    OwnPtr<protocol::Debugger::Location>* actualLocation)
+    std::unique_ptr<protocol::Debugger::Location>* actualLocation)
 {
     String16 scriptId;
     int lineNumber;
     int columnNumber;
 
     if (!parseLocation(errorString, std::move(location), &scriptId, &lineNumber, &columnNumber))
         return;
 
     String16 condition = optionalCondition.fromMaybe("");
 
@@ skipping 30 matching lines @@
     for (size_t i = 0; i < ids->size(); ++i) {
         const String16& debuggerBreakpointId = ids->at(i);
 
         debugger().removeBreakpoint(debuggerBreakpointId);
         m_serverBreakpoints.remove(debuggerBreakpointId);
     }
     m_breakpointIdToDebuggerBreakpointIds.remove(breakpointId);
 }
 
 void V8DebuggerAgentImpl::continueToLocation(ErrorString* errorString,
-    PassOwnPtr<protocol::Debugger::Location> location,
+    std::unique_ptr<protocol::Debugger::Location> location,
     const protocol::Maybe<bool>& interstateLocationOpt)
 {
     if (!checkEnabled(errorString))
         return;
     if (!m_continueToLocationBreakpointId.isEmpty()) {
         debugger().removeBreakpoint(m_continueToLocationBreakpointId);
         m_continueToLocationBreakpointId = "";
     }
 
     String16 scriptId;
     int lineNumber;
     int columnNumber;
 
     if (!parseLocation(errorString, std::move(location), &scriptId, &lineNumber, &columnNumber))
         return;
 
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, "");
     m_continueToLocationBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &lineNumber, &columnNumber, interstateLocationOpt.fromMaybe(false));
     resume(errorString);
 }
 
-void V8DebuggerAgentImpl::getBacktrace(ErrorString* errorString, OwnPtr<Array<CallFrame>>* callFrames, Maybe<StackTrace>* asyncStackTrace)
+void V8DebuggerAgentImpl::getBacktrace(ErrorString* errorString, std::unique_ptr<Array<CallFrame>>* callFrames, Maybe<StackTrace>* asyncStackTrace)
 {
     if (!assertPaused(errorString))
         return;
     m_pausedCallFrames.swap(debugger().currentCallFrames());
     *callFrames = currentCallFrames(errorString);
     if (!*callFrames)
         return;
     *asyncStackTrace = currentAsyncStackTrace();
 }
 
@@ skipping 65 matching lines @@
     if (m_skippedStepFrameCount >= maxSkipStepFrameCount)
         return RequestStepOut;
 
     if (!m_skippedStepFrameCount)
         m_recursionLevelForStepFrame = 1;
 
     ++m_skippedStepFrameCount;
     return RequestStepFrame;
 }
 
-PassOwnPtr<protocol::Debugger::Location> V8DebuggerAgentImpl::resolveBreakpoint(const String16& breakpointId, const String16& scriptId, const ScriptBreakpoint& breakpoint, BreakpointSource source)
+std::unique_ptr<protocol::Debugger::Location> V8DebuggerAgentImpl::resolveBreakpoint(const String16& breakpointId, const String16& scriptId, const ScriptBreakpoint& breakpoint, BreakpointSource source)
 {
     DCHECK(enabled());
     // FIXME: remove these checks once crbug.com/520702 is resolved.
     CHECK(!breakpointId.isEmpty());
     CHECK(!scriptId.isEmpty());
     ScriptsMap::iterator scriptIterator = m_scripts.find(scriptId);
     if (scriptIterator == m_scripts.end())
         return nullptr;
     V8DebuggerScript* script = scriptIterator->second;
     if (breakpoint.lineNumber < script->startLine() || script->endLine() < breakpoint.lineNumber)
@@ skipping 12 matching lines @@
 
     BreakpointIdToDebuggerBreakpointIdsMap::iterator debuggerBreakpointIdsIterator = m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
     debuggerBreakpointIdsIterator->second->append(debuggerBreakpointId);
 
     return buildProtocolLocation(scriptId, actualLineNumber, actualColumnNumber);
 }
 
 void V8DebuggerAgentImpl::searchInContent(ErrorString* error, const String16& scriptId, const String16& query,
     const Maybe<bool>& optionalCaseSensitive,
     const Maybe<bool>& optionalIsRegex,
-    OwnPtr<Array<protocol::Debugger::SearchMatch>>* results)
+    std::unique_ptr<Array<protocol::Debugger::SearchMatch>>* results)
 {
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it != m_scripts.end())
         *results = V8ContentSearchUtil::searchInTextByLines(m_session, it->second->source(), query, optionalCaseSensitive.fromMaybe(false), optionalIsRegex.fromMaybe(false));
     else
         *error = String16("No script for id: " + scriptId);
 }
 
 void V8DebuggerAgentImpl::setScriptSource(ErrorString* errorString,
     const String16& scriptId,
     const String16& newContent,
     const Maybe<bool>& preview,
     Maybe<protocol::Array<protocol::Debugger::CallFrame>>* newCallFrames,
     Maybe<bool>* stackChanged,
     Maybe<StackTrace>* asyncStackTrace,
     Maybe<protocol::Debugger::SetScriptSourceError>* optOutCompileError)
 {
     if (!checkEnabled(errorString))
         return;
     if (!debugger().setScriptSource(scriptId, newContent, preview.fromMaybe(false), errorString, optOutCompileError, &m_pausedCallFrames, stackChanged))
         return;
 
-    OwnPtr<Array<CallFrame>> callFrames = currentCallFrames(errorString);
+    std::unique_ptr<Array<CallFrame>> callFrames = currentCallFrames(errorString);
     if (!callFrames)
         return;
     *newCallFrames = std::move(callFrames);
     *asyncStackTrace = currentAsyncStackTrace();
 
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it == m_scripts.end())
         return;
     it->second->setSource(newContent);
 }
 
 void V8DebuggerAgentImpl::restartFrame(ErrorString* errorString,
     const String16& callFrameId,
-    OwnPtr<Array<CallFrame>>* newCallFrames,
+    std::unique_ptr<Array<CallFrame>>* newCallFrames,
     Maybe<StackTrace>* asyncStackTrace)
 {
     if (!assertPaused(errorString))
         return;
     InjectedScript::CallFrameScope scope(errorString, m_debugger, m_session->contextGroupId(), callFrameId);
     if (!scope.initialize())
         return;
     if (scope.frameOrdinal() >= m_pausedCallFrames.size()) {
         *errorString = "Could not find call frame with given id";
         return;
@@ skipping 18 matching lines @@
     if (!checkEnabled(error))
         return;
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it == m_scripts.end()) {
         *error = "No script for id: " + scriptId;
         return;
     }
     *scriptSource = it->second->source();
 }
 
-void V8DebuggerAgentImpl::getFunctionDetails(ErrorString* errorString, const String16& functionId, OwnPtr<FunctionDetails>* details)
+void V8DebuggerAgentImpl::getFunctionDetails(ErrorString* errorString, const String16& functionId, std::unique_ptr<FunctionDetails>* details)
 {
     if (!checkEnabled(errorString))
         return;
     InjectedScript::ObjectScope scope(errorString, m_debugger, m_session->contextGroupId(), functionId);
     if (!scope.initialize())
         return;
     if (!scope.object()->IsFunction()) {
         *errorString = "Value with given id is not a function";
         return;
     }
     v8::Local<v8::Function> function = scope.object().As<v8::Function>();
 
     v8::Local<v8::Value> scopesValue;
     v8::Local<v8::Array> scopes;
     if (m_debugger->functionScopes(function).ToLocal(&scopesValue) && scopesValue->IsArray()) {
         scopes = scopesValue.As<v8::Array>();
         if (!scope.injectedScript()->wrapPropertyInArray(errorString, scopes, toV8StringInternalized(m_isolate, "object"), scope.objectGroupName()))
             return;
     }
 
-    OwnPtr<FunctionDetails> functionDetails = FunctionDetails::create()
+    std::unique_ptr<FunctionDetails> functionDetails = FunctionDetails::create()
         .setLocation(buildProtocolLocation(String16::number(function->ScriptId()), function->GetScriptLineNumber(), function->GetScriptColumnNumber()))
         .setFunctionName(toProtocolStringWithTypeCheck(function->GetDebugName()))
         .setIsGenerator(function->IsGeneratorFunction()).build();
 
     if (!scopes.IsEmpty()) {
         protocol::ErrorSupport errorSupport;
-        OwnPtr<protocol::Array<protocol::Debugger::Scope>> scopeChain = protocol::Array<protocol::Debugger::Scope>::parse(toProtocolValue(scope.context(), scopes).get(), &errorSupport);
+        std::unique_ptr<protocol::Array<protocol::Debugger::Scope>> scopeChain = protocol::Array<protocol::Debugger::Scope>::parse(toProtocolValue(scope.context(), scopes).get(), &errorSupport);
         if (hasInternalError(errorString, errorSupport.hasErrors()))
             return;
         functionDetails->setScopeChain(std::move(scopeChain));
     }
 
     *details = std::move(functionDetails);
 }
 
-void V8DebuggerAgentImpl::getGeneratorObjectDetails(ErrorString* errorString, const String16& objectId, OwnPtr<GeneratorObjectDetails>* outDetails)
+void V8DebuggerAgentImpl::getGeneratorObjectDetails(ErrorString* errorString, const String16& objectId, std::unique_ptr<GeneratorObjectDetails>* outDetails)
 {
     if (!checkEnabled(errorString))
         return;
     InjectedScript::ObjectScope scope(errorString, m_debugger, m_session->contextGroupId(), objectId);
     if (!scope.initialize())
         return;
     if (!scope.object()->IsObject()) {
         *errorString = "Value with given id is not an Object";
         return;
     }
     v8::Local<v8::Object> object = scope.object().As<v8::Object>();
 
     v8::Local<v8::Object> detailsObject;
     v8::Local<v8::Value> detailsValue = debugger().generatorObjectDetails(object);
     if (hasInternalError(errorString, !detailsValue->IsObject() || !detailsValue->ToObject(scope.context()).ToLocal(&detailsObject)))
         return;
 
     if (!scope.injectedScript()->wrapObjectProperty(errorString, detailsObject, toV8StringInternalized(m_isolate, "function"), scope.objectGroupName()))
         return;
 
     protocol::ErrorSupport errors;
-    OwnPtr<GeneratorObjectDetails> protocolDetails = GeneratorObjectDetails::parse(toProtocolValue(scope.context(), detailsObject).get(), &errors);
+    std::unique_ptr<GeneratorObjectDetails> protocolDetails = GeneratorObjectDetails::parse(toProtocolValue(scope.context(), detailsObject).get(), &errors);
     if (hasInternalError(errorString, !protocolDetails))
         return;
     *outDetails = std::move(protocolDetails);
 }
 
-void V8DebuggerAgentImpl::getCollectionEntries(ErrorString* errorString, const String16& objectId, OwnPtr<protocol::Array<CollectionEntry>>* outEntries)
+void V8DebuggerAgentImpl::getCollectionEntries(ErrorString* errorString, const String16& objectId, std::unique_ptr<protocol::Array<CollectionEntry>>* outEntries)
 {
     if (!checkEnabled(errorString))
         return;
     InjectedScript::ObjectScope scope(errorString, m_debugger, m_session->contextGroupId(), objectId);
     if (!scope.initialize())
         return;
     if (!scope.object()->IsObject()) {
         *errorString = "Object with given id is not a collection";
         return;
     }
     v8::Local<v8::Object> object = scope.object().As<v8::Object>();
 
     v8::Local<v8::Value> entriesValue = m_debugger->collectionEntries(object);
     if (hasInternalError(errorString, entriesValue.IsEmpty()))
         return;
     if (entriesValue->IsUndefined()) {
         *errorString = "Object with given id is not a collection";
         return;
     }
     if (hasInternalError(errorString, !entriesValue->IsArray()))
         return;
     v8::Local<v8::Array> entriesArray = entriesValue.As<v8::Array>();
     if (!scope.injectedScript()->wrapPropertyInArray(errorString, entriesArray, toV8StringInternalized(m_isolate, "key"), scope.objectGroupName()))
         return;
     if (!scope.injectedScript()->wrapPropertyInArray(errorString, entriesArray, toV8StringInternalized(m_isolate, "value"), scope.objectGroupName()))
         return;
     protocol::ErrorSupport errors;
-    OwnPtr<protocol::Array<CollectionEntry>> entries = protocol::Array<CollectionEntry>::parse(toProtocolValue(scope.context(), entriesArray).get(), &errors);
+    std::unique_ptr<protocol::Array<CollectionEntry>> entries = protocol::Array<CollectionEntry>::parse(toProtocolValue(scope.context(), entriesArray).get(), &errors);
     if (hasInternalError(errorString, !entries))
         return;
     *outEntries = std::move(entries);
 }
 
-void V8DebuggerAgentImpl::schedulePauseOnNextStatement(const String16& breakReason, PassOwnPtr<protocol::DictionaryValue> data)
+void V8DebuggerAgentImpl::schedulePauseOnNextStatement(const String16& breakReason, std::unique_ptr<protocol::DictionaryValue> data)
 {
     if (!enabled() || m_scheduledDebuggerStep == StepInto || m_javaScriptPauseScheduled || debugger().isPaused() || !debugger().breakpointsActivated())
         return;
     m_breakReason = breakReason;
     m_breakAuxData = std::move(data);
     m_pausingOnNativeEvent = true;
     m_skipNextDebuggerStepOut = false;
     debugger().setPauseOnNextStatement(true);
 }
 
@@ skipping 128 matching lines @@
 }
 
 void V8DebuggerAgentImpl::evaluateOnCallFrame(ErrorString* errorString,
     const String16& callFrameId,
     const String16& expression,
     const Maybe<String16>& objectGroup,
     const Maybe<bool>& includeCommandLineAPI,
     const Maybe<bool>& doNotPauseOnExceptionsAndMuteConsole,
     const Maybe<bool>& returnByValue,
     const Maybe<bool>& generatePreview,
-    OwnPtr<RemoteObject>* result,
+    std::unique_ptr<RemoteObject>* result,
     Maybe<bool>* wasThrown,
     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     if (!assertPaused(errorString))
         return;
     InjectedScript::CallFrameScope scope(errorString, m_debugger, m_session->contextGroupId(), callFrameId);
     if (!scope.initialize())
         return;
     if (scope.frameOrdinal() >= m_pausedCallFrames.size()) {
         *errorString = "Could not find call frame with given id";
@@ skipping 17 matching lines @@
         returnByValue.fromMaybe(false),
         generatePreview.fromMaybe(false),
         result,
         wasThrown,
         exceptionDetails);
 }
 
 void V8DebuggerAgentImpl::setVariableValue(ErrorString* errorString,
     int scopeNumber,
     const String16& variableName,
-    PassOwnPtr<protocol::Runtime::CallArgument> newValueArgument,
+    std::unique_ptr<protocol::Runtime::CallArgument> newValueArgument,
     const String16& callFrameId)
 {
     if (!checkEnabled(errorString))
         return;
     if (!assertPaused(errorString))
         return;
     InjectedScript::CallFrameScope scope(errorString, m_debugger, m_session->contextGroupId(), callFrameId);
     if (!scope.initialize())
         return;
 
@@ skipping 18 matching lines @@
         return;
     m_state->setNumber(DebuggerAgentState::asyncCallStackDepth, depth);
     internalSetAsyncCallStackDepth(depth);
 }
 
 void V8DebuggerAgentImpl::asyncTaskScheduled(const String16& taskName, void* task, bool recurring)
 {
     if (!m_maxAsyncCallStackDepth)
         return;
     v8::HandleScope scope(m_isolate);
-    OwnPtr<V8StackTraceImpl> chain = V8StackTraceImpl::capture(this, V8StackTrace::maxCallStackSizeToCapture, taskName);
+    std::unique_ptr<V8StackTraceImpl> chain = V8StackTraceImpl::capture(this, V8StackTrace::maxCallStackSizeToCapture, taskName);
     if (chain) {
         m_asyncTaskStacks.set(task, std::move(chain));
         if (recurring)
             m_recurringTasks.add(task);
     }
 }
 
 void V8DebuggerAgentImpl::asyncTaskCanceled(void* task)
 {
     if (!m_maxAsyncCallStackDepth)
@@ skipping 45 matching lines @@
 {
     m_asyncTaskStacks.clear();
     m_recurringTasks.clear();
     m_currentStacks.clear();
 
 #if ENABLE(ASSERT)
     m_currentTasks.clear();
 #endif
 }
 
-void V8DebuggerAgentImpl::setBlackboxPatterns(ErrorString* errorString, PassOwnPtr<protocol::Array<String16>> patterns)
+void V8DebuggerAgentImpl::setBlackboxPatterns(ErrorString* errorString, std::unique_ptr<protocol::Array<String16>> patterns)
 {
     if (!patterns->length()) {
         m_blackboxPattern = nullptr;
         m_state->remove(DebuggerAgentState::blackboxPattern);
         return;
     }
 
     String16Builder patternBuilder;
     patternBuilder.append("(");
     for (size_t i = 0; i < patterns->length() - 1; ++i)
         patternBuilder.append(patterns->get(i) + "|");
     patternBuilder.append(patterns->get(patterns->length() - 1) + ")");
     String16 pattern = patternBuilder.toString();
     if (!setBlackboxPattern(errorString, pattern))
         return;
     m_state->setString(DebuggerAgentState::blackboxPattern, pattern);
 }
 
 bool V8DebuggerAgentImpl::setBlackboxPattern(ErrorString* errorString, const String16& pattern)
 {
-    OwnPtr<V8Regex> regex = adoptPtr(new V8Regex(m_debugger, pattern, true /** caseSensitive */, false /** multiline */));
+    std::unique_ptr<V8Regex> regex(new V8Regex(m_debugger, pattern, true /** caseSensitive */, false /** multiline */));
     if (!regex->isValid()) {
         *errorString = "Pattern parser error: " + regex->errorMessage();
         return false;
     }
     m_blackboxPattern = std::move(regex);
     return true;
 }
 
-void V8DebuggerAgentImpl::setBlackboxedRanges(ErrorString* error, const String16& scriptId, PassOwnPtr<protocol::Array<protocol::Debugger::ScriptPosition>> inPositions)
+void V8DebuggerAgentImpl::setBlackboxedRanges(ErrorString* error, const String16& scriptId, std::unique_ptr<protocol::Array<protocol::Debugger::ScriptPosition>> inPositions)
 {
     if (!m_scripts.contains(scriptId)) {
         *error = "No script with passed id.";
         return;
     }
 
     if (!inPositions->length()) {
         m_blackboxedPositions.remove(scriptId);
         return;
     }
@@ skipping 67 matching lines @@
             // from the old StepFrame.
             m_skippedStepFrameCount = 0;
             if (m_scheduledDebuggerStep == NoStep)
                 debugger().clearStepping();
             else if (m_scheduledDebuggerStep == StepOut)
                 m_skipNextDebuggerStepOut = true;
         }
     }
 }
 
-PassOwnPtr<Array<CallFrame>> V8DebuggerAgentImpl::currentCallFrames(ErrorString* errorString)
+std::unique_ptr<Array<CallFrame>> V8DebuggerAgentImpl::currentCallFrames(ErrorString* errorString)
 {
     if (m_pausedContext.IsEmpty() || !m_pausedCallFrames.size())
         return Array<CallFrame>::create();
     ErrorString ignored;
     InjectedScript* topFrameInjectedScript = m_session->findInjectedScript(&ignored, V8Debugger::contextId(m_pausedContext.Get(m_isolate)));
     if (!topFrameInjectedScript) {
         // Context has been reported as removed while on pause.
         return Array<CallFrame>::create();
     }
 
@@ skipping 31 matching lines @@
         if (details->Has(context, toV8StringInternalized(m_isolate, "returnValue")).FromMaybe(false)) {
             if (!injectedScript->wrapObjectProperty(errorString, details, toV8StringInternalized(m_isolate, "returnValue"), V8InspectorSession::backtraceObjectGroup))
                 return Array<CallFrame>::create();
         }
 
         if (hasInternalError(errorString, !objects->Set(context, frameOrdinal, details).FromMaybe(false)))
             return Array<CallFrame>::create();
     }
 
     protocol::ErrorSupport errorSupport;
-    OwnPtr<Array<CallFrame>> callFrames = Array<CallFrame>::parse(toProtocolValue(context, objects).get(), &errorSupport);
+    std::unique_ptr<Array<CallFrame>> callFrames = Array<CallFrame>::parse(toProtocolValue(context, objects).get(), &errorSupport);
     if (hasInternalError(errorString, !callFrames))
         return Array<CallFrame>::create();
     return callFrames;
 }
 
-PassOwnPtr<StackTrace> V8DebuggerAgentImpl::currentAsyncStackTrace()
+std::unique_ptr<StackTrace> V8DebuggerAgentImpl::currentAsyncStackTrace()
 {
     if (m_pausedContext.IsEmpty() || !m_maxAsyncCallStackDepth || !m_currentStacks.size() || !m_currentStacks.last())
         return nullptr;
 
     return m_currentStacks.last()->buildInspectorObjectForTail(this);
 }
 
 V8StackTraceImpl* V8DebuggerAgentImpl::currentAsyncCallChain()
 {
     if (!m_currentStacks.size())
@@ skipping 54 matching lines @@
         bool isRegex;
         breakpointObject->getBoolean(DebuggerAgentState::isRegex, &isRegex);
         String16 url;
         breakpointObject->getString(DebuggerAgentState::url, &url);
         if (!matches(m_debugger, scriptURL, url, isRegex))
             continue;
         ScriptBreakpoint breakpoint;
         breakpointObject->getNumber(DebuggerAgentState::lineNumber, &breakpoint.lineNumber);
         breakpointObject->getNumber(DebuggerAgentState::columnNumber, &breakpoint.columnNumber);
         breakpointObject->getString(DebuggerAgentState::condition, &breakpoint.condition);
-        OwnPtr<protocol::Debugger::Location> location = resolveBreakpoint(cookie.first, parsedScript.scriptId, breakpoint, UserBreakpointSource);
+        std::unique_ptr<protocol::Debugger::Location> location = resolveBreakpoint(cookie.first, parsedScript.scriptId, breakpoint, UserBreakpointSource);
         if (location)
             m_frontend->breakpointResolved(cookie.first, std::move(location));
     }
 }
 
 V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::didPause(v8::Local<v8::Context> context, v8::Local<v8::Value> exception, const protocol::Vector<String16>& hitBreakpoints, bool isPromiseRejection)
 {
     JavaScriptCallFrames callFrames = debugger().currentCallFrames(1);
     JavaScriptCallFrame* topCallFrame = callFrames.size() > 0 ? callFrames[0] : nullptr;
 
@@ skipping 26 matching lines @@
         InjectedScript* injectedScript = m_session->findInjectedScript(&ignored, V8Debugger::contextId(context));
         if (injectedScript) {
             m_breakReason = isPromiseRejection ? protocol::Debugger::Paused::ReasonEnum::PromiseRejection : protocol::Debugger::Paused::ReasonEnum::Exception;
             ErrorString errorString;
             auto obj = injectedScript->wrapObject(&errorString, exception, V8InspectorSession::backtraceObjectGroup);
             m_breakAuxData = obj ? obj->serialize() : nullptr;
             // m_breakAuxData might be null after this.
         }
     }
 
-    OwnPtr<Array<String16>> hitBreakpointIds = Array<String16>::create();
+    std::unique_ptr<Array<String16>> hitBreakpointIds = Array<String16>::create();
 
     for (const auto& point : hitBreakpoints) {
         DebugServerBreakpointToBreakpointIdAndSourceMap::iterator breakpointIterator = m_serverBreakpoints.find(point);
         if (breakpointIterator != m_serverBreakpoints.end()) {
             const String16& localId = breakpointIterator->second->first;
             hitBreakpointIds->addItem(localId);
 
             BreakpointSource source = breakpointIterator->second->second;
             if (m_breakReason == protocol::Debugger::Paused::ReasonEnum::Other && source == DebugCommandBreakpointSource)
                 m_breakReason = protocol::Debugger::Paused::ReasonEnum::DebugCommand;
@@ skipping 18 matching lines @@
 
 void V8DebuggerAgentImpl::didContinue()
 {
     m_pausedContext.Reset();
     JavaScriptCallFrames emptyCallFrames;
     m_pausedCallFrames.swap(emptyCallFrames);
     clearBreakDetails();
     m_frontend->resumed();
 }
 
-void V8DebuggerAgentImpl::breakProgram(const String16& breakReason, PassOwnPtr<protocol::DictionaryValue> data)
+void V8DebuggerAgentImpl::breakProgram(const String16& breakReason, std::unique_ptr<protocol::DictionaryValue> data)
 {
     if (!enabled() || m_skipAllPauses || !m_pausedContext.IsEmpty() || isCurrentCallStackEmptyOrBlackboxed() || !debugger().breakpointsActivated())
         return;
     m_breakReason = breakReason;
     m_breakAuxData = std::move(data);
     m_scheduledDebuggerStep = NoStep;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     debugger().breakProgram();
 }
 
-void V8DebuggerAgentImpl::breakProgramOnException(const String16& breakReason, PassOwnPtr<protocol::DictionaryValue> data)
+void V8DebuggerAgentImpl::breakProgramOnException(const String16& breakReason, std::unique_ptr<protocol::DictionaryValue> data)
 {
     if (!enabled() || m_debugger->getPauseOnExceptionsState() == V8DebuggerImpl::DontPauseOnExceptions)
         return;
     breakProgram(breakReason, std::move(data));
 }
 
 bool V8DebuggerAgentImpl::assertPaused(ErrorString* errorString)
 {
     if (m_pausedContext.IsEmpty()) {
         *errorString = "Can only perform operation while paused.";
@@ skipping 25 matching lines @@
     if (!enabled())
         return;
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     allAsyncTasksCanceled();
 }
 
 } // namespace blink