DevTools: generate string16-based handlers for v8_inspector.

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

 /*
  * Copyright (c) 2010-2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 89 matching lines @@
     m_debuggerContext.Reset();
     m_callFrameWrapperTemplate.Reset();
     v8::Debug::SetDebugEventListener(m_isolate, nullptr);
 }
 
 bool V8DebuggerImpl::enabled() const
 {
     return !m_debuggerScript.IsEmpty();
 }
 
-void V8Debugger::setContextDebugData(v8::Local<v8::Context> context, const String& type, int contextGroupId)
+void V8Debugger::setContextDebugData(v8::Local<v8::Context> context, const String16& type, int contextGroupId)
 {
     int contextId = atomicIncrement(&s_lastContextId);
-    String debugData = String::number(contextGroupId) + "," + String::number(contextId) + "," + type;
+    String16 debugData = String16::number(contextGroupId) + "," + String16::number(contextId) + "," + type;
     v8::HandleScope scope(context->GetIsolate());
     v8::Context::Scope contextScope(context);
     context->SetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex), toV8String(context->GetIsolate(), debugData));
 }
 
 int V8Debugger::contextId(v8::Local<v8::Context> context)
 {
     v8::Local<v8::Value> data = context->GetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex));
     if (data.IsEmpty() || !data->IsString())
         return 0;
-    String dataString = toWTFString(data.As<v8::String>());
+    String16 dataString = toProtocolString(data.As<v8::String>());
     if (dataString.isEmpty())
         return 0;
     size_t commaPos = dataString.find(",");
     if (commaPos == kNotFound)
         return 0;
     size_t commaPos2 = dataString.find(",", commaPos + 1);
     if (commaPos2 == kNotFound)
         return 0;
     return dataString.substring(commaPos + 1, commaPos2 - commaPos - 1).toInt();
 }
 
 static int getGroupId(v8::Local<v8::Context> context)
 {
     v8::Local<v8::Value> data = context->GetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex));
     if (data.IsEmpty() || !data->IsString())
         return 0;
-    String dataString = toWTFString(data.As<v8::String>());
+    String16 dataString = toProtocolString(data.As<v8::String>());
     if (dataString.isEmpty())
         return 0;
     size_t commaPos = dataString.find(",");
     if (commaPos == kNotFound)
         return 0;
     return dataString.left(commaPos).toInt();
 }
 
 void V8DebuggerImpl::addAgent(int contextGroupId, V8DebuggerAgentImpl* agent)
 {
@@ skipping 44 matching lines @@
     v8::Local<v8::Value> value;
     if (!m_client->callInternalFunction(getScriptsFunction, debuggerScript, WTF_ARRAY_LENGTH(argv), argv).ToLocal(&value))
         return;
     ASSERT(value->IsArray());
     v8::Local<v8::Array> scriptsArray = v8::Local<v8::Array>::Cast(value);
     result.resize(scriptsArray->Length());
     for (unsigned i = 0; i < scriptsArray->Length(); ++i)
         result[i] = createParsedScript(v8::Local<v8::Object>::Cast(scriptsArray->Get(v8::Integer::New(m_isolate, i))), true);
 }
 
-String V8DebuggerImpl::setBreakpoint(const String& sourceID, const ScriptBreakpoint& scriptBreakpoint, int* actualLineNumber, int* actualColumnNumber, bool interstatementLocation)
+String16 V8DebuggerImpl::setBreakpoint(const String16& sourceID, const ScriptBreakpoint& scriptBreakpoint, int* actualLineNumber, int* actualColumnNumber, bool interstatementLocation)
 {
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
 
     v8::Local<v8::Object> info = v8::Object::New(m_isolate);
     info->Set(v8InternalizedString("sourceID"), toV8String(m_isolate, sourceID));
     info->Set(v8InternalizedString("lineNumber"), v8::Integer::New(m_isolate, scriptBreakpoint.lineNumber));
     info->Set(v8InternalizedString("columnNumber"), v8::Integer::New(m_isolate, scriptBreakpoint.columnNumber));
     info->Set(v8InternalizedString("interstatementLocation"), v8Boolean(interstatementLocation, m_isolate));
     info->Set(v8InternalizedString("condition"), toV8String(m_isolate, scriptBreakpoint.condition));
 
     v8::Local<v8::Function> setBreakpointFunction = v8::Local<v8::Function>::Cast(m_debuggerScript.Get(m_isolate)->Get(v8InternalizedString("setBreakpoint")));
     v8::Local<v8::Value> breakpointId = v8::Debug::Call(debuggerContext(), setBreakpointFunction, info).ToLocalChecked();
     if (!breakpointId->IsString())
         return "";
     *actualLineNumber = info->Get(v8InternalizedString("lineNumber"))->Int32Value();
     *actualColumnNumber = info->Get(v8InternalizedString("columnNumber"))->Int32Value();
-    return toWTFString(breakpointId.As<v8::String>());
+    return toProtocolString(breakpointId.As<v8::String>());
 }
 
-void V8DebuggerImpl::removeBreakpoint(const String& breakpointId)
+void V8DebuggerImpl::removeBreakpoint(const String16& breakpointId)
 {
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
 
     v8::Local<v8::Object> info = v8::Object::New(m_isolate);
     info->Set(v8InternalizedString("breakpointId"), toV8String(m_isolate, breakpointId));
 
     v8::Local<v8::Function> removeBreakpointFunction = v8::Local<v8::Function>::Cast(m_debuggerScript.Get(m_isolate)->Get(v8InternalizedString("removeBreakpoint")));
     v8::Debug::Call(debuggerContext(), removeBreakpointFunction, info).ToLocalChecked();
 }
@@ skipping 131 matching lines @@
 void V8DebuggerImpl::clearStepping()
 {
     ASSERT(enabled());
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
 
     v8::Local<v8::Value> argv[] = { v8::Undefined(m_isolate) };
     callDebuggerMethod("clearStepping", 0, argv);
 }
 
-bool V8DebuggerImpl::setScriptSource(const String& sourceID, const String& newContent, bool preview, String* error, Maybe<protocol::Debugger::SetScriptSourceError>* errorData, v8::Global<v8::Object>* newCallFrames, Maybe<bool>* stackChanged)
+bool V8DebuggerImpl::setScriptSource(const String16& sourceID, const String16& newContent, bool preview, ErrorString* error, Maybe<protocol::Debugger::SetScriptSourceError>* errorData, v8::Global<v8::Object>* newCallFrames, Maybe<bool>* stackChanged)
 {
     class EnableLiveEditScope {
     public:
         explicit EnableLiveEditScope(v8::Isolate* isolate) : m_isolate(isolate)
         {
             v8::Debug::SetLiveEditEnabled(m_isolate, true);
             inLiveEditScope = true;
         }
         ~EnableLiveEditScope()
         {
@@ skipping 15 matching lines @@
 
     v8::Local<v8::Value> v8result;
     {
         EnableLiveEditScope enableLiveEditScope(m_isolate);
         v8::TryCatch tryCatch(m_isolate);
         tryCatch.SetVerbose(false);
         v8::MaybeLocal<v8::Value> maybeResult = callDebuggerMethod("liveEditScriptSource", 3, argv);
         if (tryCatch.HasCaught()) {
             v8::Local<v8::Message> message = tryCatch.Message();
             if (!message.IsEmpty())
-                *error = toWTFStringWithTypeCheck(message->Get());
+                *error = toProtocolStringWithTypeCheck(message->Get());
             else
                 *error = "Unknown error.";
             return false;
         }
         v8result = maybeResult.ToLocalChecked();
     }
     ASSERT(!v8result.IsEmpty());
     v8::Local<v8::Object> resultTuple = v8result->ToObject(m_isolate);
     int code = static_cast<int>(resultTuple->Get(0)->ToInteger(m_isolate)->Value());
     switch (code) {
     case 0:
         {
             *stackChanged = resultTuple->Get(1)->BooleanValue();
             // Call stack may have changed after if the edited function was on the stack.
             if (!preview && isPaused())
                 newCallFrames->Reset(m_isolate, currentCallFrames());
             return true;
         }
     // Compile error.
     case 1:
         {
             *errorData = protocol::Debugger::SetScriptSourceError::create()
-                    .setMessage(toWTFStringWithTypeCheck(resultTuple->Get(2)))
-                    .setLineNumber(resultTuple->Get(3)->ToInteger(m_isolate)->Value())
-                    .setColumnNumber(resultTuple->Get(4)->ToInteger(m_isolate)->Value()).build();
+                .setMessage(toProtocolStringWithTypeCheck(resultTuple->Get(2)))
+                .setLineNumber(resultTuple->Get(3)->ToInteger(m_isolate)->Value())
+                .setColumnNumber(resultTuple->Get(4)->ToInteger(m_isolate)->Value()).build();
             return false;
         }
     }
     *error = "Unknown error.";
     return false;
 }
 
 int V8DebuggerImpl::frameCount()
 {
     ASSERT(isPaused());
@@ skipping 81 matching lines @@
 void V8DebuggerImpl::handleProgramBreak(v8::Local<v8::Context> pausedContext, v8::Local<v8::Object> executionState, v8::Local<v8::Value> exception, v8::Local<v8::Array> hitBreakpointNumbers, bool isPromiseRejection)
 {
     // Don't allow nested breaks.
     if (m_runningNestedMessageLoop)
         return;
 
     V8DebuggerAgentImpl* agent = getAgentForContext(pausedContext);
     if (!agent)
         return;
 
-    protocol::Vector<String> breakpointIds;
+    protocol::Vector<String16> breakpointIds;
     if (!hitBreakpointNumbers.IsEmpty()) {
         breakpointIds.resize(hitBreakpointNumbers->Length());
         for (size_t i = 0; i < hitBreakpointNumbers->Length(); i++) {
             v8::Local<v8::Value> hitBreakpointNumber = hitBreakpointNumbers->Get(i);
             ASSERT(!hitBreakpointNumber.IsEmpty() && hitBreakpointNumber->IsInt32());
-            breakpointIds[i] = String::number(hitBreakpointNumber->Int32Value());
+            breakpointIds[i] = String16::number(hitBreakpointNumber->Int32Value());
         }
     }
 
     m_pausedContext = pausedContext;
     m_executionState = executionState;
     V8DebuggerAgentImpl::SkipPauseRequest result = agent->didPause(pausedContext, currentCallFrames(), exception, breakpointIds, isPromiseRejection);
     if (result == V8DebuggerAgentImpl::RequestNoSkip) {
         m_runningNestedMessageLoop = true;
         int groupId = getGroupId(pausedContext);
         ASSERT(groupId);
@@ skipping 69 matching lines @@
                 handleV8AsyncTaskEvent(agent, eventContext, eventDetails.GetExecutionState(), eventDetails.GetEventData());
         } else if (event == v8::PromiseEvent) {
             if (agent->v8PromiseEventsEnabled())
                 handleV8PromiseEvent(agent, eventContext, eventDetails.GetExecutionState(), eventDetails.GetEventData());
         }
     }
 }
 
 void V8DebuggerImpl::handleV8AsyncTaskEvent(V8DebuggerAgentImpl* agent, v8::Local<v8::Context> context, v8::Local<v8::Object> executionState, v8::Local<v8::Object> eventData)
 {
-    String type = toWTFStringWithTypeCheck(callInternalGetterFunction(eventData, "type"));
-    String name = toWTFStringWithTypeCheck(callInternalGetterFunction(eventData, "name"));
+    String16 type = toProtocolStringWithTypeCheck(callInternalGetterFunction(eventData, "type"));
+    String16 name = toProtocolStringWithTypeCheck(callInternalGetterFunction(eventData, "name"));
     int id = callInternalGetterFunction(eventData, "id")->ToInteger(m_isolate)->Value();
 
     m_pausedContext = context;
     m_executionState = executionState;
     agent->didReceiveV8AsyncTaskEvent(context, type, name, id);
     m_pausedContext.Clear();
     m_executionState.Clear();
 }
 
 void V8DebuggerImpl::handleV8PromiseEvent(V8DebuggerAgentImpl* agent, v8::Local<v8::Context> context, v8::Local<v8::Object> executionState, v8::Local<v8::Object> eventData)
@@ skipping 12 matching lines @@
     m_pausedContext.Clear();
     m_executionState.Clear();
 }
 
 V8DebuggerParsedScript V8DebuggerImpl::createParsedScript(v8::Local<v8::Object> object, bool success)
 {
     v8::Local<v8::Value> id = object->Get(v8InternalizedString("id"));
     ASSERT(!id.IsEmpty() && id->IsInt32());
 
     V8DebuggerParsedScript parsedScript;
-    parsedScript.scriptId = String::number(id->Int32Value());
-    parsedScript.script.setURL(toWTFStringWithTypeCheck(object->Get(v8InternalizedString("name"))))
-        .setSourceURL(toWTFStringWithTypeCheck(object->Get(v8InternalizedString("sourceURL"))))
-        .setSourceMappingURL(toWTFStringWithTypeCheck(object->Get(v8InternalizedString("sourceMappingURL"))))
-        .setSource(toWTFStringWithTypeCheck(object->Get(v8InternalizedString("source"))))
+    parsedScript.scriptId = String16::number(id->Int32Value());
+    parsedScript.script.setURL(toProtocolStringWithTypeCheck(object->Get(v8InternalizedString("name"))))
+        .setSourceURL(toProtocolStringWithTypeCheck(object->Get(v8InternalizedString("sourceURL"))))
+        .setSourceMappingURL(toProtocolStringWithTypeCheck(object->Get(v8InternalizedString("sourceMappingURL"))))
+        .setSource(toProtocolStringWithTypeCheck(object->Get(v8InternalizedString("source"))))
         .setStartLine(object->Get(v8InternalizedString("startLine"))->ToInteger(m_isolate)->Value())
         .setStartColumn(object->Get(v8InternalizedString("startColumn"))->ToInteger(m_isolate)->Value())
         .setEndLine(object->Get(v8InternalizedString("endLine"))->ToInteger(m_isolate)->Value())
         .setEndColumn(object->Get(v8InternalizedString("endColumn"))->ToInteger(m_isolate)->Value())
         .setIsContentScript(object->Get(v8InternalizedString("isContentScript"))->ToBoolean(m_isolate)->Value())
         .setIsInternalScript(object->Get(v8InternalizedString("isInternalScript"))->ToBoolean(m_isolate)->Value())
         .setExecutionContextId(object->Get(v8InternalizedString("executionContextId"))->ToInteger(m_isolate)->Value())
         .setIsLiveEdit(inLiveEditScope);
     parsedScript.success = success;
     return parsedScript;
@@ skipping 51 matching lines @@
 v8::Local<v8::Value> V8DebuggerImpl::collectionEntries(v8::Local<v8::Object>& object)
 {
     if (!enabled()) {
         ASSERT_NOT_REACHED();
         return v8::Local<v8::Value>::New(m_isolate, v8::Undefined(m_isolate));
     }
     v8::Local<v8::Value> argv[] = { object };
     return callDebuggerMethod("getCollectionEntries", 1, argv).ToLocalChecked();
 }
 
-v8::MaybeLocal<v8::Value> V8DebuggerImpl::setFunctionVariableValue(v8::Local<v8::Value> functionValue, int scopeNumber, const String& variableName, v8::Local<v8::Value> newValue)
+v8::MaybeLocal<v8::Value> V8DebuggerImpl::setFunctionVariableValue(v8::Local<v8::Value> functionValue, int scopeNumber, const String16& variableName, v8::Local<v8::Value> newValue)
 {
     if (m_debuggerScript.IsEmpty()) {
         ASSERT_NOT_REACHED();
         return m_isolate->ThrowException(v8::String::NewFromUtf8(m_isolate, "Debugging is not enabled.", v8::NewStringType::kNormal).ToLocalChecked());
     }
 
     v8::Local<v8::Value> argv[] = {
         functionValue,
         v8::Local<v8::Value>(v8::Integer::New(m_isolate, scopeNumber)),
         toV8String(m_isolate, variableName),
         newValue
     };
     return callDebuggerMethod("setFunctionVariableValue", 4, argv);
 }
 
 
 bool V8DebuggerImpl::isPaused()
 {
     return !m_pausedContext.IsEmpty();
 }
 
-v8::Local<v8::Script> V8DebuggerImpl::compileInternalScript(v8::Local<v8::Context>, v8::Local<v8::String> code, const String& fileName)
+v8::Local<v8::Script> V8DebuggerImpl::compileInternalScript(v8::Local<v8::Context>, v8::Local<v8::String> code, const String16& fileName)
 {
     // NOTE: For compatibility with WebCore, ScriptSourceCode's line starts at
     // 1, whereas v8 starts at 0.
     v8::ScriptOrigin origin(
         toV8String(m_isolate, fileName),
         v8::Integer::New(m_isolate, 0),
         v8::Integer::New(m_isolate, 0),
         v8::False(m_isolate), // sharable
         v8::Local<v8::Integer>(),
         v8::True(m_isolate), // internal
-        toV8String(m_isolate, String()), // sourceMap
+        toV8String(m_isolate, String16()), // sourceMap
         v8::True(m_isolate)); // opaqueresource
     v8::ScriptCompiler::Source source(code, origin);
     v8::Local<v8::Script> script;
     if (!v8::ScriptCompiler::Compile(m_isolate->GetCurrentContext(), &source, v8::ScriptCompiler::kNoCompileOptions).ToLocal(&script))
         return v8::Local<v8::Script>();
     return script;
 }
 
 PassOwnPtr<V8StackTrace> V8DebuggerImpl::createStackTrace(v8::Local<v8::StackTrace> stackTrace, size_t maxStackSize)
 {
     V8DebuggerAgentImpl* agent = getAgentForContext(m_isolate->GetCurrentContext());
     return V8StackTraceImpl::create(agent, stackTrace, maxStackSize);
 }
 
 PassOwnPtr<V8StackTrace> V8DebuggerImpl::captureStackTrace(size_t maxStackSize)
 {
     V8DebuggerAgentImpl* agent = getAgentForContext(m_isolate->GetCurrentContext());
     return V8StackTraceImpl::capture(agent, maxStackSize);
 }
 
 v8::Local<v8::Context> V8DebuggerImpl::regexContext()
 {
     if (m_regexContext.IsEmpty())
         m_regexContext.Reset(m_isolate, v8::Context::New(m_isolate));
     return m_regexContext.Get(m_isolate);
 }
 
 } // namespace blink