DevTools: generate string16-based handlers for v8_inspector.

third_party/WebKit/Source/platform/v8_inspector/V8InjectedScriptHost.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/V8InjectedScriptHost.h"
 
+#include "platform/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InjectedScriptHost.h"
 #include "platform/v8_inspector/InspectorWrapper.h"
 #include "platform/v8_inspector/JavaScriptCallFrame.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
 #include "platform/v8_inspector/public/V8EventListenerInfo.h"
 #include "platform/v8_inspector/public/V8ToProtocolValue.h"
-#include "wtf/text/WTFString.h"
 #include <algorithm>
 
 namespace blink {
 
 namespace {
 
 template<typename CallbackInfo, typename S>
 inline void v8SetReturnValue(const CallbackInfo& info, const v8::Local<S> handle)
 {
     info.GetReturnValue().Set(handle);
@@ skipping 111 matching lines @@
     }
 
     if (value->IsNativeError()) {
         v8SetReturnValue(info, toV8StringInternalized(isolate, "error"));
         return;
     }
 
     InjectedScriptHost* host = V8InjectedScriptHost::unwrap(info.GetIsolate()->GetCurrentContext(), info.Holder());
     if (!host->debugger())
         return;
-    String subtype = host->debugger()->client()->valueSubtype(value);
+    String16 subtype = host->debugger()->client()->valueSubtype(value);
     if (!subtype.isEmpty()) {
         v8SetReturnValue(info, toV8String(isolate, subtype));
         return;
     }
 }
 
 void V8InjectedScriptHost::functionDetailsCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsFunction())
         return;
@@ skipping 81 matching lines @@
         return;
 
     InjectedScriptHost* host = V8InjectedScriptHost::unwrap(info.GetIsolate()->GetCurrentContext(), info.Holder());
     if (!host->debugger())
         return;
     V8DebuggerClient* client = host->debugger()->client();
     V8EventListenerInfoMap listenerInfo;
     client->eventListeners(info[0], listenerInfo);
 
     v8::Local<v8::Object> result = v8::Object::New(info.GetIsolate());
-    protocol::Vector<String> types;
+    protocol::Vector<String16> types;
     for (auto& it : listenerInfo)
         types.append(it.first);
-    std::sort(types.begin(), types.end(), WTF::codePointCompareLessThan);
-    for (const String& type : types) {
+    std::sort(types.begin(), types.end(), String16::codePointCompareLessThan);
+    for (const String16& type : types) {
         v8::Local<v8::Array> listeners = wrapListenerFunctions(info.GetIsolate(), *listenerInfo.get(type));
         if (!listeners->Length())
             continue;
         result->Set(toV8String(info.GetIsolate(), type), listeners);
     }
 
     v8SetReturnValue(info, result);
 }
 
 void V8InjectedScriptHost::inspectCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
@@ skipping 59 matching lines @@
     v8::Local<v8::Object> wrappedResult = v8::Object::New(isolate);
     if (wrappedResult.IsEmpty())
         return;
 
     v8::TryCatch tryCatch(isolate);
     v8::Local<v8::Context> context = isolate->GetCurrentContext();
     InjectedScriptHost* host = V8InjectedScriptHost::unwrap(context, info.Holder());
     if (!host->debugger())
         return;
 
-    v8::Local<v8::Script> script = host->debugger()->compileInternalScript(context, expression, String());
+    v8::Local<v8::Script> script = host->debugger()->compileInternalScript(context, expression, String16());
     if (script.IsEmpty()) {
         setExceptionAsReturnValue(info, wrappedResult, tryCatch);
         return;
     }
 
     v8::Local<v8::Symbol> commandLineAPISymbolValue = V8Debugger::commandLineAPISymbol(isolate);
     v8::Local<v8::Object> global = context->Global();
     if (info.Length() >= 2 && info[1]->IsObject()) {
         v8::Local<v8::Object> commandLineAPI = info[1]->ToObject(isolate);
         global->Set(commandLineAPISymbolValue, commandLineAPI);
@@ skipping 12 matching lines @@
     v8SetReturnValue(info, wrappedResult);
 }
 
 void V8InjectedScriptHost::setFunctionVariableValueCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 4 || !info[0]->IsFunction() || !info[1]->IsInt32() || !info[2]->IsString())
         return;
 
     v8::Local<v8::Value> functionValue = info[0];
     int scopeIndex = info[1].As<v8::Int32>()->Value();
-    String variableName = toWTFStringWithTypeCheck(info[2]);
+    String16 variableName = toProtocolStringWithTypeCheck(info[2]);
     v8::Local<v8::Value> newValue = info[3];
 
     InjectedScriptHost* host = V8InjectedScriptHost::unwrap(info.GetIsolate()->GetCurrentContext(), info.Holder());
     if (!host->debugger())
         return;
     v8SetReturnValue(info, host->debugger()->setFunctionVariableValue(functionValue, scopeIndex, variableName, newValue));
 }
 
-static bool getFunctionLocation(const v8::FunctionCallbackInfo<v8::Value>& info, String* scriptId, int* lineNumber, int* columnNumber)
+static bool getFunctionLocation(const v8::FunctionCallbackInfo<v8::Value>& info, String16* scriptId, int* lineNumber, int* columnNumber)
 {
     if (info.Length() < 1 || !info[0]->IsFunction())
         return false;
     v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(info[0]);
     *lineNumber = function->GetScriptLineNumber();
     *columnNumber = function->GetScriptColumnNumber();
     if (*lineNumber == v8::Function::kLineOffsetNotFound || *columnNumber == v8::Function::kLineOffsetNotFound)
         return false;
-    *scriptId = String::number(function->ScriptId());
+    *scriptId = String16::number(function->ScriptId());
     return true;
 }
 
 void V8InjectedScriptHost::debugFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    String scriptId;
+    String16 scriptId;
     int lineNumber;
     int columnNumber;
     if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
         return;
 
     InjectedScriptHost* host = V8InjectedScriptHost::unwrap(info.GetIsolate()->GetCurrentContext(), info.Holder());
     host->debugFunction(scriptId, lineNumber, columnNumber);
 }
 
 void V8InjectedScriptHost::undebugFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    String scriptId;
+    String16 scriptId;
     int lineNumber;
     int columnNumber;
     if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
         return;
 
     InjectedScriptHost* host = V8InjectedScriptHost::unwrap(info.GetIsolate()->GetCurrentContext(), info.Holder());
     host->undebugFunction(scriptId, lineNumber, columnNumber);
 }
 
 void V8InjectedScriptHost::monitorFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    String scriptId;
+    String16 scriptId;
     int lineNumber;
     int columnNumber;
     if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
         return;
 
     v8::Local<v8::Value> name;
     if (info.Length() > 0 && info[0]->IsFunction()) {
         v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(info[0]);
         name = function->GetName();
         if (!name->IsString() || !v8::Local<v8::String>::Cast(name)->Length())
             name = function->GetInferredName();
     }
 
     InjectedScriptHost* host = V8InjectedScriptHost::unwrap(info.GetIsolate()->GetCurrentContext(), info.Holder());
-    host->monitorFunction(scriptId, lineNumber, columnNumber, toWTFStringWithTypeCheck(name));
+    host->monitorFunction(scriptId, lineNumber, columnNumber, toProtocolStringWithTypeCheck(name));
 }
 
 void V8InjectedScriptHost::unmonitorFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    String scriptId;
+    String16 scriptId;
     int lineNumber;
     int columnNumber;
     if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
         return;
 
     InjectedScriptHost* host = V8InjectedScriptHost::unwrap(info.GetIsolate()->GetCurrentContext(), info.Holder());
     host->unmonitorFunction(scriptId, lineNumber, columnNumber);
 }
 
 void V8InjectedScriptHost::callFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
@@ skipping 51 matching lines @@
 
 void V8InjectedScriptHost::bindCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 2 || !info[1]->IsString())
         return;
     InjectedScriptNative* injectedScriptNative = InjectedScriptNative::fromInjectedScriptHost(info.Holder());
     if (!injectedScriptNative)
         return;
 
     v8::Local<v8::String> v8groupName = info[1]->ToString(info.GetIsolate());
-    String groupName = toWTFStringWithTypeCheck(v8groupName);
+    String16 groupName = toProtocolStringWithTypeCheck(v8groupName);
     int id = injectedScriptNative->bind(info[0], groupName);
     info.GetReturnValue().Set(id);
 }
 
 void V8InjectedScriptHost::objectForIdCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsInt32())
         return;
     InjectedScriptNative* injectedScriptNative = InjectedScriptNative::fromInjectedScriptHost(info.Holder());
     if (!injectedScriptNative)
         return;
     int id = info[0].As<v8::Int32>()->Value();
     v8::Local<v8::Value> value = injectedScriptNative->objectForId(id);
     if (!value.IsEmpty())
         info.GetReturnValue().Set(value);
 }
 
 void V8InjectedScriptHost::idToObjectGroupNameCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsInt32())
         return;
     InjectedScriptNative* injectedScriptNative = InjectedScriptNative::fromInjectedScriptHost(info.Holder());
     if (!injectedScriptNative)
         return;
     int id = info[0].As<v8::Int32>()->Value();
-    String groupName = injectedScriptNative->groupName(id);
+    String16 groupName = injectedScriptNative->groupName(id);
     if (!groupName.isEmpty())
         info.GetReturnValue().Set(toV8String(info.GetIsolate(), groupName));
 }
 
 v8::Local<v8::Symbol> V8Debugger::commandLineAPISymbol(v8::Isolate* isolate)
 {
     return v8::Symbol::ForApi(isolate, toV8StringInternalized(isolate, "commandLineAPI"));
 }
 
-bool V8Debugger::isCommandLineAPIMethod(const AtomicString& name)
+bool V8Debugger::isCommandLineAPIMethod(const String16& name)
 {
-    DEFINE_STATIC_LOCAL(protocol::HashSet<String>, methods, ());
+    DEFINE_STATIC_LOCAL(protocol::HashSet<String16>, methods, ());
     if (methods.size() == 0) {
         const char* members[] = { "$", "$$", "$x", "dir", "dirxml", "keys", "values", "profile", "profileEnd",
             "monitorEvents", "unmonitorEvents", "inspect", "copy", "clear", "getEventListeners",
             "debug", "undebug", "monitor", "unmonitor", "table", "$_", "$0", "$1", "$2", "$3", "$4" };
         for (size_t i = 0; i < sizeof(members) / sizeof(const char*); ++i)
             methods.add(members[i]);
     }
     return methods.find(name) != methods.end();
 }
 
@@ skipping 45 matching lines @@
 {
     return InjectedScriptHostWrapper::wrap(client, constructorTemplate, context, host);
 }
 
 InjectedScriptHost* V8InjectedScriptHost::unwrap(v8::Local<v8::Context> context, v8::Local<v8::Object> object)
 {
     return InjectedScriptHostWrapper::unwrap(context, object);
 }
 
 } // namespace blink