DevTools: migrate protocol values from RefPtr to OwnPtr.

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/Values.h"
 #include "platform/v8_inspector/AsyncCallChain.h"
 #include "platform/v8_inspector/IgnoreExceptionsScope.h"
 #include "platform/v8_inspector/InjectedScript.h"
@@ skipping 218 matching lines @@
 {
     if (depth <= 0) {
         m_maxAsyncCallStackDepth = 0;
         resetAsyncCallTracker();
     } else {
         m_maxAsyncCallStackDepth = depth;
     }
     m_v8AsyncCallTracker->asyncCallTrackingStateChanged(m_maxAsyncCallStackDepth);
 }
 
-void V8DebuggerAgentImpl::setInspectorState(PassRefPtr<protocol::DictionaryValue> state)
+void V8DebuggerAgentImpl::setInspectorState(protocol::DictionaryValue* state)
 {
     m_state = state;
 }
 
 void V8DebuggerAgentImpl::clearFrontend()
 {
     ErrorString error;
     disable(&error);
     ASSERT(m_frontend);
     m_frontend = nullptr;
@@ skipping 30 matching lines @@
 {
     m_skipAllPauses = skipped;
     m_state->setBoolean(DebuggerAgentState::skipAllPauses, m_skipAllPauses);
 }
 
 bool V8DebuggerAgentImpl::isPaused()
 {
     return debugger().isPaused();
 }
 
-static PassRefPtr<protocol::DictionaryValue> buildObjectForBreakpointCookie(const String& url, int lineNumber, int columnNumber, const String& condition, bool isRegex)
+static PassOwnPtr<protocol::DictionaryValue> buildObjectForBreakpointCookie(const String& url, int lineNumber, int columnNumber, const String& condition, bool isRegex)
 {
-    RefPtr<protocol::DictionaryValue> breakpointObject = protocol::DictionaryValue::create();
+    OwnPtr<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.release();
 }
 
 static bool matches(V8DebuggerImpl* debugger, const String& url, const String& pattern, bool isRegex)
 {
@@ skipping 25 matching lines @@
         columnNumber = optionalColumnNumber.fromJust();
         if (columnNumber < 0) {
             *errorString = "Incorrect column number";
             return;
         }
     }
     String condition = optionalCondition.fromMaybe("");
     bool isRegex = optionalURLRegex.isJust();
 
     String breakpointId = (isRegex ? "/" + url + "/" : url) + ':' + String::number(lineNumber) + ':' + String::number(columnNumber);
-    RefPtr<protocol::DictionaryValue> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
+    protocol::DictionaryValue* breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (!breakpointsCookie) {
-        breakpointsCookie = protocol::DictionaryValue::create();
-        m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, breakpointsCookie);
+        OwnPtr<protocol::DictionaryValue> newValue = protocol::DictionaryValue::create();
+        breakpointsCookie = newValue.get();
+        m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, newValue.release());
     }
-    if (breakpointsCookie->find(breakpointId) != breakpointsCookie->end()) {
+    if (breakpointsCookie->get(breakpointId)) {
         *errorString = "Breakpoint at specified location already exists.";
         return;
     }
 
     breakpointsCookie->setObject(breakpointId, buildObjectForBreakpointCookie(url, lineNumber, columnNumber, condition, isRegex));
-    m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, breakpointsCookie);
 
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
     for (auto& script : m_scripts) {
         if (!matches(m_debugger, script.value.sourceURL(), url, isRegex))
             continue;
         OwnPtr<protocol::Debugger::Location> location = resolveBreakpoint(breakpointId, script.key, breakpoint, UserBreakpointSource);
         if (location)
             (*locations)->addItem(location.release());
     }
 
@@ skipping 33 matching lines @@
     if (*actualLocation)
         *outBreakpointId = breakpointId;
     else
         *errorString = "Could not resolve breakpoint";
 }
 
 void V8DebuggerAgentImpl::removeBreakpoint(ErrorString* errorString, const String& breakpointId)
 {
     if (!checkEnabled(errorString))
         return;
-    RefPtr<protocol::DictionaryValue> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
+    protocol::DictionaryValue* breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (breakpointsCookie)
         breakpointsCookie->remove(breakpointId);
     removeBreakpoint(breakpointId);
 }
 
 void V8DebuggerAgentImpl::removeBreakpoint(const String& breakpointId)
 {
     ASSERT(enabled());
     BreakpointIdToDebuggerBreakpointIdsMap::iterator debuggerBreakpointIdsIterator = m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
     if (debuggerBreakpointIdsIterator == m_breakpointIdToDebuggerBreakpointIds.end())
@@ skipping 306 matching lines @@
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
     if (!injectedScript) {
         *errorString = "Inspected frame has gone";
         return;
     }
     injectedScript->getCollectionEntries(errorString, objectId, entries);
 }
 
-void V8DebuggerAgentImpl::schedulePauseOnNextStatement(const String& breakReason, PassRefPtr<protocol::DictionaryValue> data)
+void V8DebuggerAgentImpl::schedulePauseOnNextStatement(const String& breakReason, PassOwnPtr<protocol::DictionaryValue> data)
 {
     ASSERT(enabled());
     if (m_scheduledDebuggerStep == StepInto || m_javaScriptPauseScheduled || isPaused())
         return;
     m_breakReason = breakReason;
     m_breakAuxData = data;
     m_pausingOnNativeEvent = true;
     m_skipNextDebuggerStepOut = false;
     debugger().setPauseOnNextStatement(true);
 }
@@ skipping 236 matching lines @@
         }
         injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
         if (!injectedScript) {
             *errorString = "Function object id cannot be resolved";
             return;
         }
     } else {
         *errorString = "Either call frame or function object must be specified";
         return;
     }
-    String newValueString = protocol::toValue(newValue)->toJSONString();
+    String newValueString = protocol::toValue(newValue.get())->toJSONString();
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::Object> currentCallStack = m_currentCallStack.Get(m_isolate);
     injectedScript->setVariableValue(errorString, currentCallStack, callFrameId, functionObjectId, scopeNumber, variableName, newValueString);
 }
 
 void V8DebuggerAgentImpl::setAsyncCallStackDepth(ErrorString* errorString, int depth)
 {
     if (!checkEnabled(errorString))
         return;
     m_state->setNumber(DebuggerAgentState::asyncCallStackDepth, depth);
@@ skipping 440 matching lines @@
     if (parsedScript.success)
         m_frontend->scriptParsed(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, isContentScriptParam, isInternalScriptParam, isLiveEditParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
     else
         m_frontend->scriptFailedToParse(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, isContentScriptParam, isInternalScriptParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
 
     m_scripts.set(parsedScript.scriptId, script);
 
     if (scriptURL.isEmpty() || !parsedScript.success)
         return;
 
-    RefPtr<protocol::DictionaryValue> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
+    protocol::DictionaryValue* breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (!breakpointsCookie)
         return;
 
     for (auto& cookie : *breakpointsCookie) {
-        RefPtr<protocol::DictionaryValue> breakpointObject = protocol::DictionaryValue::cast(cookie.value);
+        protocol::DictionaryValue* breakpointObject = protocol::DictionaryValue::cast(cookie.value.get());
         bool isRegex;
         breakpointObject->getBoolean(DebuggerAgentState::isRegex, &isRegex);
         String 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);
@@ skipping 57 matching lines @@
 
             BreakpointSource source = breakpointIterator->value.second;
             if (m_breakReason == protocol::Debugger::Paused::ReasonEnum::Other && source == DebugCommandBreakpointSource)
                 m_breakReason = protocol::Debugger::Paused::ReasonEnum::DebugCommand;
         }
     }
 
     if (!m_asyncOperationNotifications.isEmpty())
         flushAsyncOperationEvents(nullptr);
 
-    m_frontend->paused(currentCallFrames(), m_breakReason, m_breakAuxData, hitBreakpointIds.release(), currentAsyncStackTrace());
+    m_frontend->paused(currentCallFrames(), m_breakReason, m_breakAuxData.release(), hitBreakpointIds.release(), currentAsyncStackTrace());
     m_scheduledDebuggerStep = NoStep;
     m_javaScriptPauseScheduled = false;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     m_skippedStepFrameCount = 0;
     m_recursionLevelForStepFrame = 0;
     clearStepIntoAsync();
 
     if (!m_continueToLocationBreakpointId.isEmpty()) {
         debugger().removeBreakpoint(m_continueToLocationBreakpointId);
         m_continueToLocationBreakpointId = "";
     }
     return result;
 }
 
 void V8DebuggerAgentImpl::didContinue()
 {
     m_pausedContext.Reset();
     m_currentCallStack.Reset();
     clearBreakDetails();
     m_frontend->resumed();
 }
 
 bool V8DebuggerAgentImpl::canBreakProgram()
 {
     return debugger().canBreakProgram();
 }
 
-void V8DebuggerAgentImpl::breakProgram(const String& breakReason, PassRefPtr<protocol::DictionaryValue> data)
+void V8DebuggerAgentImpl::breakProgram(const String& breakReason, PassOwnPtr<protocol::DictionaryValue> data)
 {
     ASSERT(enabled());
     if (m_skipAllPauses || !m_pausedContext.IsEmpty() || isCallStackEmptyOrBlackboxed())
         return;
     m_breakReason = breakReason;
     m_breakAuxData = data;
     m_scheduledDebuggerStep = NoStep;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     clearStepIntoAsync();
     debugger().breakProgram();
 }
 
-void V8DebuggerAgentImpl::breakProgramOnException(const String& breakReason, PassRefPtr<protocol::DictionaryValue> data)
+void V8DebuggerAgentImpl::breakProgramOnException(const String& breakReason, PassOwnPtr<protocol::DictionaryValue> data)
 {
     if (m_debugger->pauseOnExceptionsState() == V8DebuggerImpl::DontPauseOnExceptions)
         return;
     breakProgram(breakReason, data);
 }
 
 void V8DebuggerAgentImpl::clearStepIntoAsync()
 {
     m_startingStepIntoAsync = false;
     m_pausingOnAsyncOperation = false;
@@ skipping 33 matching lines @@
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
     m_promiseTracker->clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 } // namespace blink