Fix inspector string encoding utf8-utf16

runtime/src/main/jni/ArgConverter.cpp

@@ -244,6 +244,17 @@ string ArgConverter::ConvertToString(const v8::Local<String>& s) {
     }
 }
 
+u16string ArgConverter::ConvertToUtf16String(const v8::Local<String>& s) {
+    if (s.IsEmpty()) {
+        return u16string();
+    } else {
+        auto str = ConvertToString(s);
+        auto utf16str =  Util::ConvertFromUtf8ToUtf16(str);
+
+        return utf16str;
+    }
+}
+
 jstring ArgConverter::ConvertToJavaString(const Local<Value>& value) {
     JEnv env;
     String::Value stringValue(value);
@@ -263,5 +274,18 @@ Local<String> ArgConverter::ConvertToV8String(Isolate* isolate, const char* data
     return String::NewFromUtf8(isolate, (const char*) data, String::kNormalString, length);
 }
 
+Local<String> ArgConverter::ConvertToV8UTF16String(Isolate* isolate, const string& string) {
+    auto utf16str = Util::ConvertFromUtf8ToUtf16(string);
+
+    return ConvertToV8UTF16String(isolate, utf16str);
+}
+
+Local<String> ArgConverter::ConvertToV8UTF16String(Isolate* isolate, const u16string& utf16string) {
+    return String::NewFromTwoByte(isolate, ((const uint16_t*) utf16string.data()));
+}
+
+Local<String> ArgConverter::ConvertToV8UTF16String(v8::Isolate* isolate, const uint16_t* utf16string, int size) {
+    return String::NewFromTwoByte(isolate, utf16string, NewStringType::kNormal, size).ToLocalChecked();
+}
 
 std::map<Isolate*, ArgConverter::TypeLongOperationsCache*> ArgConverter::s_type_long_operations_cache;

runtime/src/main/jni/ArgConverter.h

@@ -30,6 +30,8 @@ class ArgConverter {
 
         static std::string ConvertToString(const v8::Local<v8::String>& s);
 
+        static std::u16string ConvertToUtf16String(const v8::Local<v8::String>& s);
+
         static jstring ConvertToJavaString(const v8::Local<v8::Value>& jsValue);
 
         static v8::Local<v8::String> ConvertToV8String(v8::Isolate* isolate, const jchar* data, int length);
@@ -38,6 +40,12 @@ class ArgConverter {
 
         static v8::Local<v8::String> ConvertToV8String(v8::Isolate* isolate, const char* data, int length);
 
+        static v8::Local<v8::String> ConvertToV8UTF16String(v8::Isolate* isolate, const std::string& string);
+
+        static v8::Local<v8::String> ConvertToV8UTF16String(v8::Isolate* isolate, const uint16_t* utf16string, int size);
+
+        static v8::Local<v8::String> ConvertToV8UTF16String(v8::Isolate* isolate, const std::u16string& utf16string);
+
     private:
 
         // TODO: plamen5kov: rewrite logic for java long number operations in javascript (java long -> javascript number operations check)

runtime/src/main/jni/DOMDomainCallbackHandlers.cpp

@@ -9,7 +9,7 @@
 
 using namespace tns;
 
-void DOMDomainCallbackHandlers::DocumentUpdatedCallback(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void DOMDomainCallbackHandlers::DocumentUpdatedCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
     auto domAgentInstance = V8DOMAgentImpl::Instance;
 
     if (!domAgentInstance) {
@@ -19,7 +19,7 @@ void DOMDomainCallbackHandlers::DocumentUpdatedCallback(const v8::FunctionCallba
     domAgentInstance->m_frontend.documentUpdated();
 }
 
-void DOMDomainCallbackHandlers::ChildNodeInsertedCallback(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void DOMDomainCallbackHandlers::ChildNodeInsertedCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
     try {
         auto domAgentInstance = V8DOMAgentImpl::Instance;
 
@@ -39,9 +39,7 @@ void DOMDomainCallbackHandlers::ChildNodeInsertedCallback(const v8::FunctionCall
         auto lastId = args[1]->ToNumber(isolate);
         auto node = args[2]->ToString(isolate);
 
-        auto nodeString = ArgConverter::ConvertToString(node);
-        auto nodeCStr = nodeString.c_str();
-        auto nodeJson = protocol::parseJSON(nodeCStr);
+        auto nodeJson = protocol::parseJSON(v8_inspector::toProtocolString(node));
 
         protocol::ErrorSupport errorSupport;
         auto domNode = protocol::DOM::Node::parse(nodeJson.get(), &errorSupport);
@@ -66,7 +64,7 @@ void DOMDomainCallbackHandlers::ChildNodeInsertedCallback(const v8::FunctionCall
     }
 }
 
-void DOMDomainCallbackHandlers::ChildNodeRemovedCallback(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void DOMDomainCallbackHandlers::ChildNodeRemovedCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
     try {
         auto domAgentInstance = V8DOMAgentImpl::Instance;
 
@@ -99,7 +97,7 @@ void DOMDomainCallbackHandlers::ChildNodeRemovedCallback(const v8::FunctionCallb
     }
 }
 
-void DOMDomainCallbackHandlers::AttributeModifiedCallback(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void DOMDomainCallbackHandlers::AttributeModifiedCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
     try {
         auto domAgentInstance = V8DOMAgentImpl::Instance;
 
@@ -119,9 +117,9 @@ void DOMDomainCallbackHandlers::AttributeModifiedCallback(const v8::FunctionCall
         auto attributeName = args[1]->ToString();
         auto attributeValue = args[2]->ToString();
 
-         domAgentInstance->m_frontend.attributeModified(nodeId->Int32Value(),
-                                                        ArgConverter::ConvertToString(attributeName).c_str(),
-                                                        ArgConverter::ConvertToString(attributeValue).c_str());
+        domAgentInstance->m_frontend.attributeModified(nodeId->Int32Value(),
+                v8_inspector::toProtocolString(attributeName),
+                v8_inspector::toProtocolString(attributeValue));
     } catch (NativeScriptException& e) {
         e.ReThrowToV8();
     } catch (std::exception e) {
@@ -135,7 +133,7 @@ void DOMDomainCallbackHandlers::AttributeModifiedCallback(const v8::FunctionCall
     }
 }
 
-void DOMDomainCallbackHandlers::AttributeRemovedCallback(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void DOMDomainCallbackHandlers::AttributeRemovedCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
     try {
         auto domAgentInstance = V8DOMAgentImpl::Instance;
 
@@ -154,7 +152,7 @@ void DOMDomainCallbackHandlers::AttributeRemovedCallback(const v8::FunctionCallb
         auto attributeName = args[1]->ToString();
 
         domAgentInstance->m_frontend.attributeRemoved(nodeId->Int32Value(),
-                                                       ArgConverter::ConvertToString(attributeName).c_str());
+                v8_inspector::toProtocolString(attributeName));
     } catch (NativeScriptException& e) {
         e.ReThrowToV8();
     } catch (std::exception e) {

runtime/src/main/jni/NetworkDomainCallbackHandlers.cpp

@@ -49,9 +49,9 @@ void NetworkDomainCallbackHandlers::ResponseReceivedCallback(const v8::FunctionC
             throw NativeScriptException("`response` parameter not in the correct format.");
         }
 
-        auto responseJsonString = ArgConverter::ConvertToString(responseJson);
-        auto responseJsonCString = responseJsonString.c_str();
-        auto protocolResponseJson = protocol::parseJSON(responseJsonCString);
+        auto responseJsonString = ArgConverter::ConvertToUtf16String(responseJson);
+        auto responseUtf16Data = responseJsonString.data();
+        auto protocolResponseJson = protocol::parseJSON(String16((const uint16_t*) responseUtf16Data));
 
         protocol::ErrorSupport errorSupport;
 
@@ -133,9 +133,9 @@ void NetworkDomainCallbackHandlers::RequestWillBeSentCallback(const v8::Function
             throw NativeScriptException("`request` parameter not in the correct format.");
         }
 
-        auto requestJsonString = ArgConverter::ConvertToString(requestJson);
-        auto requestJsonCString = requestJsonString.c_str();
-        auto protocolRequestJson = protocol::parseJSON(requestJsonCString);
+        auto requestJsonString = ArgConverter::ConvertToUtf16String(requestJson);
+        auto requestUtf16Data = requestJsonString.data();
+        auto protocolRequestJson = protocol::parseJSON(String16((const uint16_t*)  requestUtf16Data));
 
         protocol::ErrorSupport errorSupport;
 
@@ -207,7 +207,7 @@ void NetworkDomainCallbackHandlers::DataForRequestIdCallback(const v8::FunctionC
         auto hasTextContent = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "hasTextContent")).ToLocalChecked()->ToBoolean();
 
         auto requestIdString = ArgConverter::ConvertToString(requestId).c_str();
-        auto dataString = ArgConverter::ConvertToString(data);
+        auto dataString = ArgConverter::ConvertToUtf16String(data);
         auto hasTextContentBool = hasTextContent->BooleanValue();
 
         auto responses = networkAgentInstance->m_responses;
@@ -219,11 +219,7 @@ void NetworkDomainCallbackHandlers::DataForRequestIdCallback(const v8::FunctionC
         } else {
             v8_inspector::utils::NetworkRequestData* response = it->second;
 
-            if (!hasTextContentBool) {
-                response->setData(dataString);
-            } else {
-                response->setData(ArgConverter::ConvertToString(data));
-            }
+            response->setData(dataString);
 
             response->setHasTextContent(hasTextContentBool);
         }

runtime/src/main/jni/Util.cpp

@@ -1,5 +1,7 @@
 #include "Util.h"
 #include <sstream>
+#include <iostream>
+#include <codecvt>
 
 using namespace v8;
 using namespace std;
@@ -77,28 +79,34 @@ bool Util::EndsWith(const string& str, const string& suffix) {
     return res;
 }
 
-string Util::ConvertFromJniToCanonicalName(const std::string& name) {
+string Util::ConvertFromJniToCanonicalName(const string& name) {
     string converted = name;
     replace(converted.begin(), converted.end(), '/', '.');
     return converted;
 }
 
-string Util::ConvertFromCanonicalToJniName(const std::string& name) {
+string Util::ConvertFromCanonicalToJniName(const string& name) {
     string converted = name;
     replace(converted.begin(), converted.end(), '.', '/');
     return converted;
 }
 
-string Util::ReplaceAll(std::string& str, const std::string& from, const std::string& to) {
+string Util::ReplaceAll(string& str, const string& from, const string& to) {
     if (from.empty()) {
         return str;
     }
 
     size_t start_pos = 0;
-    while ((start_pos = str.find(from, start_pos)) != std::string::npos) {
+    while ((start_pos = str.find(from, start_pos)) != string::npos) {
         str.replace(start_pos, from.length(), to);
         start_pos += to.length();
     }
 
     return str;
+}
+
+u16string Util::ConvertFromUtf8ToUtf16(const string& str) {
+    auto utf16String = std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>().from_bytes(str);
+
+    return utf16String;
 }

runtime/src/main/jni/Util.h

@@ -19,6 +19,8 @@ class Util {
         static std::string ConvertFromCanonicalToJniName(const std::string& name);
 
         static std::string ReplaceAll(std::string& str, const std::string& from, const std::string& to);
+
+        static std::u16string ConvertFromUtf8ToUtf16(const std::string& str);
 };
 }
 

runtime/src/main/jni/v8_inspector/src/inspector/utils/v8-network-request-data.cpp

@@ -7,9 +7,9 @@
 namespace v8_inspector {
 namespace utils {
 NetworkRequestData::NetworkRequestData()
-    : m_data(""),
+    : m_data(),
       m_hasTextContent(true) { }
-NetworkRequestData::NetworkRequestData(std::string data, bool hasTextContent)
+NetworkRequestData::NetworkRequestData(std::u16string data, bool hasTextContent)
     : m_data(data),
       m_hasTextContent(hasTextContent) { }
 }

runtime/src/main/jni/v8_inspector/src/inspector/utils/v8-network-request-data.h

@@ -13,16 +13,16 @@ namespace utils {
 class NetworkRequestData {
     public:
         NetworkRequestData();
-        NetworkRequestData(std::string data, bool hasTextContent);
-        const char*  getData() {
-            return m_data.c_str();
+        NetworkRequestData(std::u16string data, bool hasTextContent);
+        const char16_t*  getData() {
+            return m_data.data();
         };
 
         const bool hasTextContent() {
             return m_hasTextContent;
         }
 
-        void setData(const std::string& data) {
+        void setData(const std::u16string& data) {
             m_data = data;
         }
 
@@ -31,7 +31,7 @@ class NetworkRequestData {
         }
 
     private:
-        std::string m_data;
+        std::u16string m_data;
         bool m_hasTextContent;
 };
 }

runtime/src/main/jni/v8_inspector/src/inspector/utils/v8-page-resources.cpp

@@ -9,6 +9,7 @@
 #include <fstream>
 #include <iostream>
 #include <JniLocalRef.h>
+#include <Util.h>
 #include "base64.h"
 #include "v8_inspector/src/inspector/utils/v8-page-resources.h"
 #include "JEnv.h"
@@ -19,7 +20,7 @@ namespace utils {
 PageResource::PageResource(std::string filePath, std::string mimeType)
     : m_filePath(filePath),
       m_mimeType(mimeType),
-      m_content("") {
+      m_content() {
 
     m_type = PageResource::resourceTypeByMimeType(m_mimeType);
 }
@@ -82,15 +83,17 @@ String16 PageResource::getContent(protocol::ErrorString* errorString) {
 
         if (shouldEncode) {
             auto base64EncodedString = base64_encode(buff, size);
-            m_content = base64EncodedString;
+            m_content = tns::Util::ConvertFromUtf8ToUtf16(base64EncodedString);
         } else {
-            m_content = std::string(reinterpret_cast<char*>(buff));
+            auto utf8Content = std::string(reinterpret_cast<char*>(buff));
+            auto utf16Content = tns::Util::ConvertFromUtf8ToUtf16(utf8Content);
+            m_content = utf16Content;
         }
 
         free(buff);
     }
 
-    return m_content.c_str();
+    return String16((const uint16_t*) m_content.data());
 }
 
 const char* PageResource::resourceTypeByMimeType(std::string mimeType) {

runtime/src/main/jni/v8_inspector/src/inspector/utils/v8-page-resources.h

@@ -46,7 +46,7 @@ class PageResource {
     private:
         std::string m_filePath;
         std::string m_mimeType;
-        std::string m_content;
+        std::u16string m_content;
         const char* m_type;
 
         static std::map<std::string, const char*> s_mimeTypeMap;