DevTools: generate string16-based handlers for v8_inspector.

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/IgnoreExceptionsScope.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InjectedScriptHost.h"
 #include "platform/v8_inspector/InjectedScriptManager.h"
 #include "platform/v8_inspector/JavaScriptCallFrame.h"
 #include "platform/v8_inspector/PromiseTracker.h"
 #include "platform/v8_inspector/RemoteObjectId.h"
 #include "platform/v8_inspector/V8AsyncCallTracker.h"
 #include "platform/v8_inspector/V8JavaScriptCallFrame.h"
 #include "platform/v8_inspector/V8Regex.h"
 #include "platform/v8_inspector/V8RuntimeAgentImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8ContentSearchUtil.h"
 #include "platform/v8_inspector/public/V8Debugger.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
-#include "wtf/text/StringBuilder.h"
-#include "wtf/text/WTFString.h"
 
 using blink::protocol::Array;
 using blink::protocol::Maybe;
 using blink::protocol::Debugger::AsyncOperation;
 using blink::protocol::Debugger::BreakpointId;
 using blink::protocol::Debugger::CallFrame;
 using blink::protocol::Debugger::CollectionEntry;
 using blink::protocol::Runtime::ExceptionDetails;
 using blink::protocol::Debugger::FunctionDetails;
 using blink::protocol::Debugger::GeneratorObjectDetails;
@@ skipping 20 matching lines @@
 static const char skipAllPauses[] = "skipAllPauses";
 
 } // namespace DebuggerAgentState;
 
 static const int maxSkipStepFrameCount = 128;
 
 const char V8DebuggerAgent::backtraceObjectGroup[] = "backtrace";
 
 const int V8DebuggerAgent::unknownAsyncOperationId = 0;
 
-static String breakpointIdSuffix(V8DebuggerAgentImpl::BreakpointSource source)
+static String16 breakpointIdSuffix(V8DebuggerAgentImpl::BreakpointSource source)
 {
     switch (source) {
     case V8DebuggerAgentImpl::UserBreakpointSource:
         break;
     case V8DebuggerAgentImpl::DebugCommandBreakpointSource:
         return ":debug";
     case V8DebuggerAgentImpl::MonitorCommandBreakpointSource:
         return ":monitor";
     }
-    return String();
+    return String16();
 }
 
-static String generateBreakpointId(const String& scriptId, int lineNumber, int columnNumber, V8DebuggerAgentImpl::BreakpointSource source)
+static String16 generateBreakpointId(const String16& scriptId, int lineNumber, int columnNumber, V8DebuggerAgentImpl::BreakpointSource source)
 {
-    return scriptId + ':' + String::number(lineNumber) + ':' + String::number(columnNumber) + breakpointIdSuffix(source);
+    return scriptId + ":" + String16::number(lineNumber) + ":" + String16::number(columnNumber) + breakpointIdSuffix(source);
 }
 
 static bool positionComparator(const std::pair<int, int>& a, const std::pair<int, int>& b)
 {
     if (a.first != b.first)
         return a.first < b.first;
     return a.second < b.second;
 }
 
 static const LChar hexDigits[17] = "0123456789ABCDEF";
 
-static void appendUnsignedAsHex(unsigned number, String& destination)
+static void appendUnsignedAsHex(unsigned number, String16Builder* destination)
 {
     for (size_t i = 0; i < 8; ++i) {
-        destination.append(hexDigits[number & 0xF]);
+        destination->append(hexDigits[number & 0xF]);
         number >>= 4;
     }
 }
 
 // Hash algorithm for substrings is described in "Über die Komplexität der Multiplikation in
 // eingeschränkten Branchingprogrammmodellen" by Woelfe.
 // http://opendatastructures.org/versions/edition-0.1d/ods-java/node33.html#SECTION00832000000000000000
-static String calculateHash(const String& str)
+static String16 calculateHash(const String16& str)
 {
     static uint64_t prime[] = { 0x3FB75161, 0xAB1F4E4F, 0x82675BC5, 0xCD924D35, 0x81ABE279 };
     static uint64_t random[] = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 };
     static uint32_t randomOdd[] = { 0xB4663807, 0xCC322BF5, 0xD4F91BBD, 0xA7BEA11D, 0x8F462907 };
 
     uint64_t hashes[] = { 0, 0, 0, 0, 0 };
     uint64_t zi[] = { 1, 1, 1, 1, 1 };
 
     const size_t hashesSize = WTF_ARRAY_LENGTH(hashes);
 
@@ skipping 18 matching lines @@
         }
         uint64_t xi = v * randomOdd[current] & 0x7FFFFFFF;
         hashes[current] = (hashes[current] + zi[current] * xi) % prime[current];
         zi[current] = (zi[current] * random[current]) % prime[current];
         current = current == hashesSize - 1 ? 0 : current + 1;
     }
 
     for (size_t i = 0; i < hashesSize; ++i)
         hashes[i] = (hashes[i] + zi[i] * (prime[i] - 1)) % prime[i];
 
-    String hash;
+    String16Builder hash;
     for (size_t i = 0; i < hashesSize; ++i)
-        appendUnsignedAsHex(hashes[i], hash);
-    return hash;
+        appendUnsignedAsHex(hashes[i], &hash);
+    return hash.toString();
 }
 
 PassOwnPtr<V8DebuggerAgent> V8DebuggerAgent::create(V8RuntimeAgent* runtimeAgent, int contextGroupId)
 {
     V8RuntimeAgentImpl* runtimeAgentImpl = static_cast<V8RuntimeAgentImpl*>(runtimeAgent);
     return adoptPtr(new V8DebuggerAgentImpl(runtimeAgentImpl->injectedScriptManager(), runtimeAgentImpl->debugger(), contextGroupId));
 }
 
 V8DebuggerAgentImpl::V8DebuggerAgentImpl(InjectedScriptManager* injectedScriptManager, V8DebuggerImpl* debugger, int contextGroupId)
     : m_injectedScriptManager(injectedScriptManager)
@@ skipping 80 matching lines @@
     m_state->setBoolean(DebuggerAgentState::promiseTrackerCaptureStacks, false);
 
     debugger().removeAgent(m_contextGroupId);
     m_pausedContext.Reset();
     m_currentCallStack.Reset();
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     internalSetAsyncCallStackDepth(0);
     m_promiseTracker->setEnabled(false, false);
-    m_continueToLocationBreakpointId = String();
+    m_continueToLocationBreakpointId = String16();
     clearBreakDetails();
     m_scheduledDebuggerStep = NoStep;
     m_skipNextDebuggerStepOut = false;
     m_javaScriptPauseScheduled = false;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     m_skippedStepFrameCount = 0;
     m_recursionLevelForStepFrame = 0;
     m_asyncOperationNotifications.clear();
     clearStepIntoAsync();
@@ skipping 23 matching lines @@
     disable(&error);
     ASSERT(m_frontend);
     m_frontend = nullptr;
 }
 
 void V8DebuggerAgentImpl::restore()
 {
     ASSERT(!m_enabled);
     m_frontend->globalObjectCleared();
     enable();
-    String error;
+    ErrorString error;
 
     int pauseState = V8DebuggerImpl::DontPauseOnExceptions;
     m_state->getNumber(DebuggerAgentState::pauseOnExceptionsState, &pauseState);
     setPauseOnExceptionsImpl(&error, pauseState);
 
     m_skipAllPauses = m_state->booleanProperty(DebuggerAgentState::skipAllPauses, false);
 
     int asyncCallStackDepth = 0;
     m_state->getNumber(DebuggerAgentState::asyncCallStackDepth, &asyncCallStackDepth);
     internalSetAsyncCallStackDepth(asyncCallStackDepth);
@@ skipping 12 matching lines @@
 {
     m_skipAllPauses = skipped;
     m_state->setBoolean(DebuggerAgentState::skipAllPauses, m_skipAllPauses);
 }
 
 bool V8DebuggerAgentImpl::isPaused()
 {
     return debugger().isPaused();
 }
 
-static PassOwnPtr<protocol::DictionaryValue> buildObjectForBreakpointCookie(const String& url, int lineNumber, int columnNumber, const String& condition, bool isRegex)
+static PassOwnPtr<protocol::DictionaryValue> buildObjectForBreakpointCookie(const String16& url, int lineNumber, int columnNumber, const String16& condition, bool isRegex)
 {
     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)
+static bool matches(V8DebuggerImpl* debugger, const String16& url, const String16& pattern, bool isRegex)
 {
     if (isRegex) {
-        V8Regex regex(debugger, pattern, TextCaseSensitive);
+        V8Regex regex(debugger, pattern, true);
         return regex.match(url) != -1;
     }
     return url == pattern;
 }
 
 void V8DebuggerAgentImpl::setBreakpointByUrl(ErrorString* errorString,
     int lineNumber,
-    const Maybe<String>& optionalURL,
-    const Maybe<String>& optionalURLRegex,
+    const Maybe<String16>& optionalURL,
+    const Maybe<String16>& optionalURLRegex,
     const Maybe<int>& optionalColumnNumber,
-    const Maybe<String>& optionalCondition,
-    BreakpointId* outBreakpointId,
+    const Maybe<String16>& optionalCondition,
+    String16* outBreakpointId,
     OwnPtr<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;
     }
 
-    String url = optionalURL.isJust() ? optionalURL.fromJust() : optionalURLRegex.fromJust();
+    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;
         }
     }
-    String condition = optionalCondition.fromMaybe("");
+    String16 condition = optionalCondition.fromMaybe("");
     bool isRegex = optionalURLRegex.isJust();
 
-    String breakpointId = (isRegex ? "/" + url + "/" : url) + ':' + String::number(lineNumber) + ':' + String::number(columnNumber);
+    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();
         breakpointsCookie = newValue.get();
         m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, newValue.release());
     }
     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);
         if (location)
             (*locations)->addItem(location.release());
     }
 
     *outBreakpointId = breakpointId;
 }
 
-static bool parseLocation(ErrorString* errorString, PassOwnPtr<protocol::Debugger::Location> location, String* scriptId, int* lineNumber, int* columnNumber)
+static bool parseLocation(ErrorString* errorString, PassOwnPtr<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,
-    const Maybe<String>& optionalCondition,
-    BreakpointId* outBreakpointId,
+    const Maybe<String16>& optionalCondition,
+    String16* outBreakpointId,
     OwnPtr<protocol::Debugger::Location>* actualLocation)
 {
-    String scriptId;
+    String16 scriptId;
     int lineNumber;
     int columnNumber;
 
     if (!parseLocation(errorString, location, &scriptId, &lineNumber, &columnNumber))
         return;
 
-    String condition = optionalCondition.fromMaybe("");
+    String16 condition = optionalCondition.fromMaybe("");
 
-    String breakpointId = generateBreakpointId(scriptId, lineNumber, columnNumber, UserBreakpointSource);
+    String16 breakpointId = generateBreakpointId(scriptId, lineNumber, columnNumber, UserBreakpointSource);
     if (m_breakpointIdToDebuggerBreakpointIds.contains(breakpointId)) {
         *errorString = "Breakpoint at specified location already exists.";
         return;
     }
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
     *actualLocation = resolveBreakpoint(breakpointId, scriptId, breakpoint, UserBreakpointSource);
     if (*actualLocation)
         *outBreakpointId = breakpointId;
     else
         *errorString = "Could not resolve breakpoint";
 }
 
-void V8DebuggerAgentImpl::removeBreakpoint(ErrorString* errorString, const String& breakpointId)
+void V8DebuggerAgentImpl::removeBreakpoint(ErrorString* errorString, const String16& breakpointId)
 {
     if (!checkEnabled(errorString))
         return;
     protocol::DictionaryValue* breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (breakpointsCookie)
         breakpointsCookie->remove(breakpointId);
     removeBreakpoint(breakpointId);
 }
 
-void V8DebuggerAgentImpl::removeBreakpoint(const String& breakpointId)
+void V8DebuggerAgentImpl::removeBreakpoint(const String16& breakpointId)
 {
     ASSERT(enabled());
     BreakpointIdToDebuggerBreakpointIdsMap::iterator debuggerBreakpointIdsIterator = m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
     if (debuggerBreakpointIdsIterator == m_breakpointIdToDebuggerBreakpointIds.end())
         return;
-    protocol::Vector<String>* ids = debuggerBreakpointIdsIterator->second;
+    protocol::Vector<String16>* ids = debuggerBreakpointIdsIterator->second;
     for (size_t i = 0; i < ids->size(); ++i) {
-        const String& debuggerBreakpointId = ids->at(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,
     const protocol::Maybe<bool>& interstateLocationOpt)
 {
     if (!checkEnabled(errorString))
         return;
     if (!m_continueToLocationBreakpointId.isEmpty()) {
         debugger().removeBreakpoint(m_continueToLocationBreakpointId);
         m_continueToLocationBreakpointId = "";
     }
 
-    String scriptId;
+    String16 scriptId;
     int lineNumber;
     int columnNumber;
 
     if (!parseLocation(errorString, location, &scriptId, &lineNumber, &columnNumber))
         return;
 
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, "");
     m_continueToLocationBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &lineNumber, &columnNumber, interstateLocationOpt.fromMaybe(false));
     resume(errorString);
 }
 
-void V8DebuggerAgentImpl::getStepInPositions(ErrorString* errorString, const String& callFrameId, Maybe<Array<protocol::Debugger::Location>>* positions)
+void V8DebuggerAgentImpl::getStepInPositions(ErrorString* errorString, const String16& callFrameId, Maybe<Array<protocol::Debugger::Location>>* positions)
 {
     if (!isPaused() || m_currentCallStack.IsEmpty()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
     OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(callFrameId);
     if (!remoteId) {
         *errorString = "Invalid call frame id";
         return;
     }
@@ skipping 33 matching lines @@
 bool V8DebuggerAgentImpl::isTopCallFrameBlackboxed()
 {
     ASSERT(enabled());
     return isCallFrameWithUnknownScriptOrBlackboxed(debugger().callFrameNoScopes(0).get());
 }
 
 bool V8DebuggerAgentImpl::isCallFrameWithUnknownScriptOrBlackboxed(JavaScriptCallFrame* frame)
 {
     if (!frame)
         return true;
-    ScriptsMap::iterator it = m_scripts.find(String::number(frame->sourceID()));
+    ScriptsMap::iterator it = m_scripts.find(String16::number(frame->sourceID()));
     if (it == m_scripts.end()) {
         // Unknown scripts are blackboxed.
         return true;
     }
-    auto itBlackboxedPositions = m_blackboxedPositions.find(String::number(frame->sourceID()));
+    auto itBlackboxedPositions = m_blackboxedPositions.find(String16::number(frame->sourceID()));
     if (itBlackboxedPositions == m_blackboxedPositions.end())
         return false;
 
     protocol::Vector<std::pair<int, int>>* ranges = itBlackboxedPositions->second;
     auto itRange = std::lower_bound(ranges->begin(), ranges->end(), std::make_pair(frame->line(), frame->column()), positionComparator);
     // Ranges array contains positions in script where blackbox state is changed.
     // [(0,0) ... ranges[0]) isn't blackboxed, [ranges[0] ... ranges[1]) is blackboxed...
     return std::distance(ranges->begin(), itRange) % 2;
 }
 
@@ skipping 23 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 String& breakpointId, const String& scriptId, const ScriptBreakpoint& breakpoint, BreakpointSource source)
+PassOwnPtr<protocol::Debugger::Location> V8DebuggerAgentImpl::resolveBreakpoint(const String16& breakpointId, const String16& scriptId, const ScriptBreakpoint& breakpoint, BreakpointSource source)
 {
     ASSERT(enabled());
     // FIXME: remove these checks once crbug.com/520702 is resolved.
     RELEASE_ASSERT(!breakpointId.isEmpty());
     RELEASE_ASSERT(!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)
         return nullptr;
 
     int actualLineNumber;
     int actualColumnNumber;
-    String debuggerBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &actualLineNumber, &actualColumnNumber, false);
+    String16 debuggerBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &actualLineNumber, &actualColumnNumber, false);
     if (debuggerBreakpointId.isEmpty())
         return nullptr;
 
     m_serverBreakpoints.set(debuggerBreakpointId, std::make_pair(breakpointId, source));
     RELEASE_ASSERT(!breakpointId.isEmpty());
     if (!m_breakpointIdToDebuggerBreakpointIds.contains(breakpointId))
-        m_breakpointIdToDebuggerBreakpointIds.set(breakpointId, protocol::Vector<String>());
+        m_breakpointIdToDebuggerBreakpointIds.set(breakpointId, protocol::Vector<String16>());
 
     BreakpointIdToDebuggerBreakpointIdsMap::iterator debuggerBreakpointIdsIterator = m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
     debuggerBreakpointIdsIterator->second->append(debuggerBreakpointId);
 
     OwnPtr<protocol::Debugger::Location> location = protocol::Debugger::Location::create()
         .setScriptId(scriptId)
         .setLineNumber(actualLineNumber)
         .setColumnNumber(actualColumnNumber).build();
     return location.release();
 }
 
-void V8DebuggerAgentImpl::searchInContent(ErrorString* error, const String& scriptId, const String& query,
+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)
 {
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it != m_scripts.end())
         *results = V8ContentSearchUtil::searchInTextByLines(m_debugger, it->second->source(), query, optionalCaseSensitive.fromMaybe(false), optionalIsRegex.fromMaybe(false));
     else
-        *error = "No script for id: " + scriptId;
+        *error = String16("No script for id: " + scriptId);
 }
 
 void V8DebuggerAgentImpl::setScriptSource(ErrorString* error,
-    const String& scriptId,
-    const String& newContent,
+    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(error))
         return;
     if (!debugger().setScriptSource(scriptId, newContent, preview.fromMaybe(false), error, optOutCompileError, &m_currentCallStack, stackChanged))
         return;
 
     *newCallFrames = currentCallFrames();
     *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 String& callFrameId,
+    const String16& callFrameId,
     OwnPtr<Array<CallFrame>>* newCallFrames,
     Maybe<StackTrace>* asyncStackTrace)
 {
     if (!isPaused() || m_currentCallStack.IsEmpty()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
     OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(callFrameId);
     if (!remoteId) {
         *errorString = "Invalid call frame id";
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
     if (!injectedScript) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::Object> callStack = m_currentCallStack.Get(m_isolate);
     injectedScript->restartFrame(errorString, callStack, callFrameId);
     m_currentCallStack.Reset(m_isolate, debugger().currentCallFrames());
     *newCallFrames = currentCallFrames();
     *asyncStackTrace = currentAsyncStackTrace();
 }
 
-void V8DebuggerAgentImpl::getScriptSource(ErrorString* error, const String& scriptId, String* scriptSource)
+void V8DebuggerAgentImpl::getScriptSource(ErrorString* error, const String16& scriptId, String16* scriptSource)
 {
     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 String& functionId, OwnPtr<FunctionDetails>* details)
+void V8DebuggerAgentImpl::getFunctionDetails(ErrorString* errorString, const String16& functionId, OwnPtr<FunctionDetails>* details)
 {
     if (!checkEnabled(errorString))
         return;
     OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(functionId);
     if (!remoteId) {
         *errorString = "Invalid object id";
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
     if (!injectedScript) {
         *errorString = "Function object id is obsolete";
         return;
     }
     injectedScript->getFunctionDetails(errorString, functionId, details);
 }
 
-void V8DebuggerAgentImpl::getGeneratorObjectDetails(ErrorString* errorString, const String& objectId, OwnPtr<GeneratorObjectDetails>* details)
+void V8DebuggerAgentImpl::getGeneratorObjectDetails(ErrorString* errorString, const String16& objectId, OwnPtr<GeneratorObjectDetails>* details)
 {
     if (!checkEnabled(errorString))
         return;
     OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(objectId);
     if (!remoteId) {
         *errorString = "Invalid object id";
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
     if (!injectedScript) {
         *errorString = "Inspected frame has gone";
         return;
     }
     injectedScript->getGeneratorObjectDetails(errorString, objectId, details);
 }
 
-void V8DebuggerAgentImpl::getCollectionEntries(ErrorString* errorString, const String& objectId, OwnPtr<protocol::Array<CollectionEntry>>* entries)
+void V8DebuggerAgentImpl::getCollectionEntries(ErrorString* errorString, const String16& objectId, OwnPtr<protocol::Array<CollectionEntry>>* entries)
 {
     if (!checkEnabled(errorString))
         return;
     OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(objectId);
     if (!remoteId) {
         *errorString = "Invalid object id";
         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, PassOwnPtr<protocol::DictionaryValue> data)
+void V8DebuggerAgentImpl::schedulePauseOnNextStatement(const String16& 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 17 matching lines @@
     clearBreakDetails();
     m_pausingOnNativeEvent = false;
     debugger().setPauseOnNextStatement(false);
 }
 
 bool V8DebuggerAgentImpl::v8AsyncTaskEventsEnabled() const
 {
     return trackingAsyncCalls();
 }
 
-void V8DebuggerAgentImpl::didReceiveV8AsyncTaskEvent(v8::Local<v8::Context> context, const String& eventType, const String& eventName, int id)
+void V8DebuggerAgentImpl::didReceiveV8AsyncTaskEvent(v8::Local<v8::Context> context, const String16& eventType, const String16& eventName, int id)
 {
     ASSERT(trackingAsyncCalls());
     m_v8AsyncCallTracker->didReceiveV8AsyncTaskEvent(context, eventType, eventName, id);
 }
 
 bool V8DebuggerAgentImpl::v8PromiseEventsEnabled() const
 {
     return m_promiseTracker->isEnabled();
 }
 
@@ skipping 72 matching lines @@
         return;
     if (!trackingAsyncCalls()) {
         *errorString = "Can only perform operation if async call stacks are enabled.";
         return;
     }
     clearStepIntoAsync();
     m_startingStepIntoAsync = true;
     stepInto(errorString);
 }
 
-void V8DebuggerAgentImpl::setPauseOnExceptions(ErrorString* errorString, const String& stringPauseState)
+void V8DebuggerAgentImpl::setPauseOnExceptions(ErrorString* errorString, const String16& stringPauseState)
 {
     if (!checkEnabled(errorString))
         return;
     V8DebuggerImpl::PauseOnExceptionsState pauseState;
     if (stringPauseState == "none") {
         pauseState = V8DebuggerImpl::DontPauseOnExceptions;
     } else if (stringPauseState == "all") {
         pauseState = V8DebuggerImpl::PauseOnAllExceptions;
     } else if (stringPauseState == "uncaught") {
         pauseState = V8DebuggerImpl::PauseOnUncaughtExceptions;
     } else {
         *errorString = "Unknown pause on exceptions mode: " + stringPauseState;
         return;
     }
     setPauseOnExceptionsImpl(errorString, pauseState);
 }
 
 void V8DebuggerAgentImpl::setPauseOnExceptionsImpl(ErrorString* errorString, int pauseState)
 {
     debugger().setPauseOnExceptionsState(static_cast<V8DebuggerImpl::PauseOnExceptionsState>(pauseState));
     if (debugger().getPauseOnExceptionsState() != pauseState)
         *errorString = "Internal error. Could not change pause on exceptions state";
     else
         m_state->setNumber(DebuggerAgentState::pauseOnExceptionsState, pauseState);
 }
 
 void V8DebuggerAgentImpl::evaluateOnCallFrame(ErrorString* errorString,
-    const String& callFrameId,
-    const String& expression,
-    const Maybe<String>& objectGroup,
+    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,
     Maybe<bool>* wasThrown,
     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     if (!isPaused() || m_currentCallStack.IsEmpty()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
@@ skipping 12 matching lines @@
 
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::Object> callStack = m_currentCallStack.Get(m_isolate);
 
     IgnoreExceptionsScope ignoreExceptionsScope(doNotPauseOnExceptionsAndMuteConsole.fromMaybe(false) ? m_debugger : nullptr);
     injectedScript->evaluateOnCallFrame(errorString, callStack, callFrameId, expression, objectGroup.fromMaybe(""), includeCommandLineAPI.fromMaybe(false), returnByValue.fromMaybe(false), generatePreview.fromMaybe(false), result, wasThrown, exceptionDetails);
 }
 
 void V8DebuggerAgentImpl::setVariableValue(ErrorString* errorString,
     int scopeNumber,
-    const String& variableName,
+    const String16& variableName,
     PassOwnPtr<protocol::Runtime::CallArgument> newValue,
-    const Maybe<String>& callFrameId,
-    const Maybe<String>& functionObjectId)
+    const Maybe<String16>& callFrameId,
+    const Maybe<String16>& functionObjectId)
 {
     if (!checkEnabled(errorString))
         return;
     InjectedScript* injectedScript = nullptr;
     if (callFrameId.isJust()) {
         if (!isPaused() || m_currentCallStack.IsEmpty()) {
             *errorString = "Attempt to access callframe when debugger is not on pause";
             return;
         }
         OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(callFrameId.fromJust());
@@ skipping 14 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.get())->toJSONString();
+    String16 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 11 matching lines @@
 }
 
 void V8DebuggerAgentImpl::disablePromiseTracker(ErrorString* errorString)
 {
     if (!checkEnabled(errorString))
         return;
     m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, false);
     m_promiseTracker->setEnabled(false, false);
 }
 
-void V8DebuggerAgentImpl::getPromiseById(ErrorString* errorString, int promiseId, const Maybe<String>& objectGroup, OwnPtr<RemoteObject>* promise)
+void V8DebuggerAgentImpl::getPromiseById(ErrorString* errorString, int promiseId, const Maybe<String16>& objectGroup, OwnPtr<RemoteObject>* promise)
 {
     if (!checkEnabled(errorString))
         return;
     if (!m_promiseTracker->isEnabled()) {
         *errorString = "Promise tracking is disabled";
         return;
     }
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Object> value = m_promiseTracker->promiseById(promiseId);
     if (value.IsEmpty()) {
         *errorString = "Promise with specified ID not found.";
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->injectedScriptFor(value->CreationContext());
     *promise = injectedScript->wrapObject(value, objectGroup.fromMaybe(""));
 }
 
-void V8DebuggerAgentImpl::didUpdatePromise(const String& eventType, PassOwnPtr<protocol::Debugger::PromiseDetails> promise)
+void V8DebuggerAgentImpl::didUpdatePromise(const String16& eventType, PassOwnPtr<protocol::Debugger::PromiseDetails> promise)
 {
     if (m_frontend)
         m_frontend->promiseUpdated(eventType, promise);
 }
 
-int V8DebuggerAgentImpl::traceAsyncOperationStarting(const String& description)
+int V8DebuggerAgentImpl::traceAsyncOperationStarting(const String16& description)
 {
     v8::HandleScope scope(m_isolate);
     OwnPtr<V8StackTraceImpl> chain = V8StackTraceImpl::capture(this, V8StackTrace::maxCallStackSizeToCapture, description);
 
     do {
         ++m_lastAsyncOperationId;
         if (m_lastAsyncOperationId <= 0)
             m_lastAsyncOperationId = 1;
     } while (m_asyncOperations.contains(m_lastAsyncOperationId));
 
@@ skipping 167 matching lines @@
         *errorString = "Can only perform operation while tracking async call stacks.";
         return;
     }
     if (operationId <= 0) {
         *errorString = "Wrong async operation id.";
         return;
     }
     m_asyncOperationBreakpoints.remove(operationId);
 }
 
-void V8DebuggerAgentImpl::setBlackboxedRanges(ErrorString* error, const String& scriptId, PassOwnPtr<protocol::Array<protocol::Debugger::ScriptPosition>> inPositions)
+void V8DebuggerAgentImpl::setBlackboxedRanges(ErrorString* error, const String16& scriptId, PassOwnPtr<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 24 matching lines @@
     m_blackboxedPositions.set(scriptId, positions);
 }
 
 void V8DebuggerAgentImpl::willExecuteScript(int scriptId)
 {
     changeJavaScriptRecursionLevel(+1);
     // Fast return.
     if (m_scheduledDebuggerStep != StepInto)
         return;
     // Skip unknown scripts (e.g. InjectedScript).
-    if (!m_scripts.contains(String::number(scriptId)))
+    if (!m_scripts.contains(String16::number(scriptId)))
         return;
     schedulePauseOnNextStatementIfSteppingInto();
 }
 
 void V8DebuggerAgentImpl::didExecuteScript()
 {
     changeJavaScriptRecursionLevel(-1);
 }
 
 void V8DebuggerAgentImpl::changeJavaScriptRecursionLevel(int step)
@@ skipping 77 matching lines @@
     else if (!script.sourceMappingURL().isEmpty())
         V8ContentSearchUtil::findSourceMapURL(script.source(), false, &isDeprecatedSourceMappingURL);
 
     script.setHash(calculateHash(script.source()));
 
     int executionContextId = script.executionContextId();
     bool isContentScript = script.isContentScript();
     bool isInternalScript = script.isInternalScript();
     bool isLiveEdit = script.isLiveEdit();
     bool hasSourceURL = script.hasSourceURL();
-    String scriptURL = script.sourceURL();
-    String sourceMapURL = script.sourceMappingURL();
+    String16 scriptURL = script.sourceURL();
+    String16 sourceMapURL = script.sourceMappingURL();
     bool deprecatedCommentWasUsed = isDeprecatedSourceURL || isDeprecatedSourceMappingURL;
 
-    const Maybe<String>& sourceMapURLParam = sourceMapURL;
+    const Maybe<String16>& sourceMapURLParam = sourceMapURL;
     const bool* isContentScriptParam = isContentScript ? &isContentScript : nullptr;
     const bool* isInternalScriptParam = isInternalScript ? &isInternalScript : nullptr;
     const bool* isLiveEditParam = isLiveEdit ? &isLiveEdit : nullptr;
     const bool* hasSourceURLParam = hasSourceURL ? &hasSourceURL : nullptr;
     const bool* deprecatedCommentWasUsedParam = deprecatedCommentWasUsed ? &deprecatedCommentWasUsed : nullptr;
     if (parsedScript.success)
         m_frontend->scriptParsed(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, script.hash(), isContentScriptParam, isInternalScriptParam, isLiveEditParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
     else
         m_frontend->scriptFailedToParse(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, script.hash(), isContentScriptParam, isInternalScriptParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
 
     m_scripts.set(parsedScript.scriptId, script);
 
     if (scriptURL.isEmpty() || !parsedScript.success)
         return;
 
     protocol::DictionaryValue* breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (!breakpointsCookie)
         return;
 
     for (size_t i = 0; i < breakpointsCookie->size(); ++i) {
         auto cookie = breakpointsCookie->at(i);
         protocol::DictionaryValue* breakpointObject = protocol::DictionaryValue::cast(cookie.second);
         bool isRegex;
         breakpointObject->getBoolean(DebuggerAgentState::isRegex, &isRegex);
-        String url;
+        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);
         if (location)
             m_frontend->breakpointResolved(cookie.first, location.release());
     }
 }
 
-V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::didPause(v8::Local<v8::Context> context, v8::Local<v8::Object> callFrames, v8::Local<v8::Value> exception, const protocol::Vector<String>& hitBreakpoints, bool isPromiseRejection)
+V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::didPause(v8::Local<v8::Context> context, v8::Local<v8::Object> callFrames, v8::Local<v8::Value> exception, const protocol::Vector<String16>& hitBreakpoints, bool isPromiseRejection)
 {
     V8DebuggerAgentImpl::SkipPauseRequest result;
     if (m_skipAllPauses)
         result = RequestContinue;
     else if (!hitBreakpoints.isEmpty())
         result = RequestNoSkip; // Don't skip explicit breakpoints even if set in frameworks.
     else if (!exception.IsEmpty())
         result = shouldSkipExceptionPause();
     else if (m_scheduledDebuggerStep != NoStep || m_javaScriptPauseScheduled || m_pausingOnNativeEvent)
         result = shouldSkipStepPause();
@@ skipping 20 matching lines @@
             auto obj = injectedScript->wrapObject(exception, V8DebuggerAgentImpl::backtraceObjectGroup);
             m_breakAuxData = obj ? obj->serialize() : nullptr;
             // m_breakAuxData might be null after this.
         }
     } else if (m_pausingOnAsyncOperation) {
         m_breakReason = protocol::Debugger::Paused::ReasonEnum::AsyncOperation;
         m_breakAuxData = protocol::DictionaryValue::create();
         m_breakAuxData->setNumber("operationId", m_currentAsyncOperationId);
     }
 
-    OwnPtr<Array<String>> hitBreakpointIds = Array<String>::create();
+    OwnPtr<Array<String16>> hitBreakpointIds = Array<String16>::create();
 
     for (const auto& point : hitBreakpoints) {
         DebugServerBreakpointToBreakpointIdAndSourceMap::iterator breakpointIterator = m_serverBreakpoints.find(point);
         if (breakpointIterator != m_serverBreakpoints.end()) {
-            const String& localId = breakpointIterator->second->first;
+            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;
         }
     }
 
     if (!m_asyncOperationNotifications.isEmpty())
         flushAsyncOperationEvents(nullptr);
@@ skipping 20 matching lines @@
     m_currentCallStack.Reset();
     clearBreakDetails();
     m_frontend->resumed();
 }
 
 bool V8DebuggerAgentImpl::canBreakProgram()
 {
     return debugger().canBreakProgram();
 }
 
-void V8DebuggerAgentImpl::breakProgram(const String& breakReason, PassOwnPtr<protocol::DictionaryValue> data)
+void V8DebuggerAgentImpl::breakProgram(const String16& 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, PassOwnPtr<protocol::DictionaryValue> data)
+void V8DebuggerAgentImpl::breakProgramOnException(const String16& breakReason, PassOwnPtr<protocol::DictionaryValue> data)
 {
     if (m_debugger->getPauseOnExceptionsState() == V8DebuggerImpl::DontPauseOnExceptions)
         return;
     breakProgram(breakReason, data);
 }
 
 void V8DebuggerAgentImpl::clearStepIntoAsync()
 {
     m_startingStepIntoAsync = false;
     m_pausingOnAsyncOperation = false;
     m_pausingAsyncOperations.clear();
 }
 
 bool V8DebuggerAgentImpl::assertPaused(ErrorString* errorString)
 {
     if (m_pausedContext.IsEmpty()) {
         *errorString = "Can only perform operation while paused.";
         return false;
     }
     return true;
 }
 
 void V8DebuggerAgentImpl::clearBreakDetails()
 {
     m_breakReason = protocol::Debugger::Paused::ReasonEnum::Other;
     m_breakAuxData = nullptr;
 }
 
-void V8DebuggerAgentImpl::setBreakpointAt(const String& scriptId, int lineNumber, int columnNumber, BreakpointSource source, const String& condition)
+void V8DebuggerAgentImpl::setBreakpointAt(const String16& scriptId, int lineNumber, int columnNumber, BreakpointSource source, const String16& condition)
 {
-    String breakpointId = generateBreakpointId(scriptId, lineNumber, columnNumber, source);
+    String16 breakpointId = generateBreakpointId(scriptId, lineNumber, columnNumber, source);
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
     resolveBreakpoint(breakpointId, scriptId, breakpoint, source);
 }
 
-void V8DebuggerAgentImpl::removeBreakpointAt(const String& scriptId, int lineNumber, int columnNumber, BreakpointSource source)
+void V8DebuggerAgentImpl::removeBreakpointAt(const String16& scriptId, int lineNumber, int columnNumber, BreakpointSource source)
 {
     removeBreakpoint(generateBreakpointId(scriptId, lineNumber, columnNumber, source));
 }
 
 void V8DebuggerAgentImpl::reset()
 {
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
     m_promiseTracker->clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 } // namespace blink