debugger communication using v8 tasks

Author: blagoev

runtime/build.gradle

@@ -232,7 +232,7 @@ model {
                        //"-I${file("src/main/jni/v8_inspector/protocol/")}".toString(),
                        ])
 
-        cppFlags.addAll(["-std=c++11", "-fexceptions", "-fno-builtin-stpcpy", "-DHAVE_INSPECTOR"]) //, "-DV8_INSPECTOR_USE_STL=1", "-D__GXX_EXPERIMENTAL_CXX0X__=1"
+        cppFlags.addAll(["-std=c++11", "-fexceptions", "-fno-builtin-stpcpy", "-DHAVE_INSPECTOR", "-D__ANDROID__"]) //, "-DV8_INSPECTOR_USE_STL=1", "-D__GXX_EXPERIMENTAL_CXX0X__=1"
 
 
         CFlags.addAll(["-Wno-error=format-security", "-g", "-fno-builtin-stpcpy"])
@@ -247,7 +247,25 @@ model {
         toolchain = "clang"
         stl = "c++_static"
 
-        abiFilters.addAll(["armeabi-v7a", "x86", "arm64-v8a"])
+        abiFilters.addAll(["armeabi-v7a"])
+
+        if (System.getProperties()['idea.platform.prefix'] != null)
+        {
+            // Built from AndroidStudio
+            println "Build from AndroidStudio"
+
+            if (!ndkDebuggable)
+            {
+                abiFilters.addAll(["x86", "arm64-v8a"])
+            }
+        }
+        else
+        {
+            // Built from command line
+            abiFilters.addAll(["x86", "arm64-v8a"])
+
+            println "Build from Command Line"
+        }
     }
 
     android.sources {

runtime/src/main/java/com/tns/AndroidJsV8Inspector.java

@@ -89,7 +89,7 @@ protected void onClose(NanoWSD.WebSocketFrame.CloseCode code, String reason, boo
         protected void onMessage(NanoWSD.WebSocketFrame message)
         {
             Log.d("V8Inspector", "onMessage");
-            Log.d("V8Inspector", "onMessage TextPayload" + message.getTextPayload());
+            Log.d("V8Inspector", "onMessage TextPayload" + message.getTextPayload() + " ThreadId:" + Thread.currentThread().getId());
             dispatchMessage(message.getTextPayload());
         }
 

runtime/src/main/jni/JsDebugger.cpp

@@ -44,7 +44,7 @@ void JsDebugger::Enable()
 	v8::Isolate::Scope isolate_scope(isolate);
 	v8::HandleScope handleScope(isolate);
 
-	v8::Debug::SetMessageHandler(isolate, MyMessageHandler);
+	//v8::Debug::SetMessageHandler(MyMessageHandler);
 	enabled = true;
 }
 

runtime/src/main/jni/JsV8InspectorClient.cpp

@@ -9,43 +9,150 @@
 #include "Runtime.h"
 #include "src/inspector/string-16.h"
 
+#include "src/inspector/task-runner.h"
+
 using namespace std;
 using namespace tns;
 using namespace v8;
 
 using namespace v8_inspector;
 
+class ConnectTask : public TaskRunner::Task
+{
+public:
+    ConnectTask(JsV8InspectorClient* client, v8::base_copied::Semaphore  *ready_semaphore)
+            : client_(client), ready_semaphore_(ready_semaphore)
+    {
+
+    }
+
+    ~ConnectTask() = default;
+
+    bool is_inspector_task() final
+    {
+        return true;
+    }
+
+    void Run(v8::Isolate *isolate, const v8::Global<v8::Context> &global_context)
+    {
+        v8::HandleScope handle_scope(isolate);
+        v8::Local<v8::Context> context = global_context.Get(isolate);
+        client_->doConnect(isolate, context);
+        if (ready_semaphore_ != nullptr)
+        {
+            ready_semaphore_->Signal();
+        }
+    }
+
+private:
+    JsV8InspectorClient* client_;
+    v8::base_copied::Semaphore *ready_semaphore_;
+};
+
+
+class SendMessageToBackendTask : public TaskRunner::Task
+{
+public:
+    explicit SendMessageToBackendTask(JsV8InspectorClient* client, const std::string &message)
+            : client_(client), message_(message)
+    {
+
+    }
+
+    bool is_inspector_task() final
+    {
+        return true;
+    }
+
+    void Run(v8::Isolate *isolate, const v8::Global<v8::Context> &global_context) override
+    {
+//        v8_inspector::V8InspectorSession *session = nullptr;
+//        {
+//            v8::HandleScope handle_scope(isolate);
+//            v8::Local<v8::Context> context = global_context.Get(isolate);
+//            session = InspectorClientImpl::SessionFromContext(context);
+//            CHECK(session);
+//        }
+//
+//        v8_inspector::StringView message_view(reinterpret_cast<const uint16_t *>(message_.characters16()), message_.length());
+//        session->dispatchProtocolMessage(message_view);
+
+        v8::HandleScope handle_scope(isolate);
+        v8::Local<v8::Context> context = global_context.Get(isolate);
+        client_->doDispatchMessage(isolate, message_);
+    }
+
+private:
+    JsV8InspectorClient* client_;
+    std::string message_;
+};
+
 JsV8InspectorClient::JsV8InspectorClient(v8::Isolate *isolate)
-        : isolate_(nullptr),
+        : isolate_(isolate),
           inspector_(nullptr),
           session_(nullptr),
-          connection(nullptr)
+          connection(nullptr),
+          backend_runner(nullptr)
 {
-    isolate_ = isolate;
-
     JEnv env;
 
+
     inspectorClass = env.FindClass("com/tns/AndroidJsV8Inspector");
     assert(inspectorClass != nullptr);
 
     sendMethod = env.GetStaticMethodID(inspectorClass, "send", "(Ljava/lang/Object;Ljava/lang/String;)V");
     assert(sendMethod != nullptr);
 }
 
+JsV8InspectorClient::~JsV8InspectorClient()
+{
+    if (backend_runner != nullptr)
+    {
+        delete backend_runner;
+    }
+}
+
 void JsV8InspectorClient::connect(jobject connection)
 {
-    v8::Isolate::Scope isolate_scope(isolate_);
-    v8::HandleScope handleScope(isolate_);
+    //Isolate::Scope isolate_scope(isolate_);
+    //v8::HandleScope handleScope(isolate_);
 
-    //session_ = inspector_->connect(1, this, nullptr);
+    v8::base_copied::Semaphore ready_semaphore(0);
 
     JEnv env;
     this->connection = env.NewGlobalRef(connection);
+
+    this->backend_runner->Append(new ConnectTask(this, &ready_semaphore));
+
+    ready_semaphore.Wait();
+
+
+
+    //inspector_ = V8Inspector::create(isolate_, this);
+
+    //session_ = inspector_->connect(1, this, v8_inspector::StringView());
+
+    //inspector_->contextCreated(v8_inspector::V8ContextInfo(isolate_->GetCurrentContext(), 1, v8_inspector::StringView()));
+
+
+}
+
+void JsV8InspectorClient::doConnect(v8::Isolate *isolate, const v8::Local<v8::Context>& context)
+{
+//    Isolate::Scope isolate_scope(isolate_);
+//    v8::HandleScope handleScope(isolate_);
+
+
+    inspector_ = V8Inspector::create(isolate, this);
+
+    session_ = inspector_->connect(1, this, v8_inspector::StringView());
+
+    inspector_->contextCreated(v8_inspector::V8ContextInfo(/*isolate->GetCurrentContext()*/ context, 1, v8_inspector::StringView()));
 }
 
 void JsV8InspectorClient::disconnect()
 {
-    v8::Isolate::Scope isolate_scope(isolate_);
+    Isolate::Scope isolate_scope(isolate_);
     v8::HandleScope handleScope(isolate_);
 
     session_.reset();
@@ -55,14 +162,105 @@ void JsV8InspectorClient::disconnect()
     this->connection = nullptr;
 }
 
+
 void JsV8InspectorClient::dispatchMessage(const std::string &message)
 {
-    v8::Isolate::Scope isolate_scope(isolate_);
-    v8::HandleScope handleScope(isolate_);
+    //Isolate::Scope isolate_scope(isolate_);
+    //v8::HandleScope handleScope(isolate_);
+
+//    assert(session_ != nullptr);
+//
+//    const String16 msg(message.c_str());
+//    v8_inspector::StringView message_view(reinterpret_cast<const uint16_t *>(msg.characters16()), msg.length());
+//    session_->dispatchProtocolMessage(message_view);
+
+    this->backend_runner->Append(new SendMessageToBackendTask(this, message));
+
+}
+
+void JsV8InspectorClient::doDispatchMessage(v8::Isolate *isolate, const std::string &message)
+{
+    //Isolate::Scope isolate_scope(isolate_);
+    //v8::HandleScope handleScope(isolate_);
 
     assert(session_ != nullptr);
-    //const String16 protocolMessage(message.c_str());
-    //session_->dispatchProtocolMessage(protocolMessage);
+
+    const String16 msg(message.c_str());
+    v8_inspector::StringView message_view(reinterpret_cast<const uint16_t *>(msg.characters16()), msg.length());
+    session_->dispatchProtocolMessage(message_view);
+}
+
+void JsV8InspectorClient::sendProtocolResponse(int callId, const v8_inspector::StringView &message)
+{
+    //frontend_channel_->SendMessageToFrontend(message);
+    sendProtocolNotification(message);
+}
+
+static v8_inspector::String16 ToString16(const v8_inspector::StringView &string)
+{
+    if (string.is8Bit())
+    {
+        return v8_inspector::String16(reinterpret_cast<const char *>(string.characters8()), string.length());
+    }
+
+    return v8_inspector::String16(reinterpret_cast<const uint16_t *>(string.characters16()), string.length());
+}
+
+void JsV8InspectorClient::sendProtocolNotification(const v8_inspector::StringView &message)
+{
+    //frontend_channel_->SendMessageToFrontend(message);
+
+    if (inspectorClass == nullptr || this->connection == nullptr)
+    {
+        return;
+    }
+
+    v8_inspector::String16 msg = ToString16(message);
+
+    JEnv env;
+    JniLocalRef string(env.NewStringUTF(msg.utf8().c_str()));
+    env.CallStaticVoidMethod(inspectorClass, sendMethod,  this->connection, (jstring) string);
+}
+
+void JsV8InspectorClient::flushProtocolNotifications()
+{
+}
+
+void MessageHandler(v8::Local<v8::Message> message,
+                    v8::Local<v8::Value> exception)
+{
+    v8::Isolate *isolate = v8::Isolate::GetCurrent();
+    v8::Local<v8::Context> context = isolate->GetEnteredContext();
+//    if (context.IsEmpty()) return;
+//    v8_inspector::V8Inspector *inspector = InspectorClientImpl::InspectorFromContext(context);
+//
+//    v8::Local<v8::StackTrace> stack = message->GetStackTrace();
+//    int script_id = message->GetScriptOrigin().ScriptID()->Value();
+//    if (!stack.IsEmpty() && stack->GetFrameCount() > 0)
+//    {
+//        int top_script_id = stack->GetFrame(0)->GetScriptId();
+//        if (top_script_id == script_id) script_id = 0;
+//    }
+//    int line_number = message->GetLineNumber(context).FromMaybe(0);
+//    int column_number = 0;
+//    if (message->GetStartColumn(context).IsJust())
+//        column_number = message->GetStartColumn(context).FromJust() + 1;
+//
+//    v8_inspector::StringView detailed_message;
+//    v8_inspector::String16 message_text_string = ToString16(message->Get());
+//    v8_inspector::StringView message_text(message_text_string.characters16(),
+//                                          message_text_string.length());
+//    v8_inspector::String16 url_string;
+//    if (message->GetScriptOrigin().ResourceName()->IsString())
+//    {
+//        url_string =
+//                ToString16(message->GetScriptOrigin().ResourceName().As<v8::String>());
+//    }
+//    v8_inspector::StringView url(url_string.characters16(), url_string.length());
+//
+//    inspector->exceptionThrown(context, message_text, exception, detailed_message,
+//                               url, line_number, column_number,
+//                               inspector->createStackTrace(stack), script_id);
 }
 
 //void JsV8InspectorClient::sendProtocolResponse(int callId, const String16 &message)
@@ -94,11 +292,17 @@ void JsV8InspectorClient::init()
         return;
     }
 
-    v8::Isolate::Scope isolate_scope(isolate_);
-    v8::HandleScope handleScope(isolate_);
+    //SendMessageToBackendExtension send_message_to_backend_extension;
+    //v8::RegisterExtension(&send_message_to_backend_extension);
+
+    v8::base_copied::Semaphore ready_semaphore(0);
+
+    //const char *backend_extensions[0] = {"v8_inspector/setTimeout"};
+    //v8::ExtensionConfiguration backend_configuration(arraysize(backend_extensions), backend_extensions);
+
+    this->backend_runner = new TaskRunner(/*&backend_configuration*/ nullptr, false, &ready_semaphore);
+    ready_semaphore.Wait();
 
-    inspector_ = V8Inspector::create(isolate_, this);
-    //inspector_->contextCreated(v8_inspector::V8ContextInfo(isolate_->GetCurrentContext(), 1, "{N} Context"));
 }
 
 JsV8InspectorClient *JsV8InspectorClient::GetInstance()

runtime/src/main/jni/JsV8InspectorClient.h

@@ -2,6 +2,7 @@
 #define JSV8INSPECTORCLIENT_H_
 
 #include <string>
+#include <v8_inspector/src/inspector/task-runner.h>
 #include "v8.h"
 #include "v8-debug.h"
 #include "JEnv.h"
@@ -16,28 +17,37 @@ using namespace v8_inspector;
 
 namespace tns
 {
-	class JsV8InspectorClient : V8InspectorClient //,  InspectorClientImpl::FrontendChannel
+	class JsV8InspectorClient : V8InspectorClient, v8_inspector::V8Inspector::Channel
 	{
 		public:
             static JsV8InspectorClient* GetInstance();
 
             void init();
 			void connect(jobject connection);
+			void doConnect(v8::Isolate *isolate, const v8::Local<v8::Context>& context);
 			void disconnect();
-            void dispatchMessage(const std::string& message);
-            //void sendProtocolResponse(int callId, const String16& message) override;
+			void dispatchMessage(const std::string& message);
+			void doDispatchMessage(v8::Isolate *isolate, const std::string& message);
+
+			//void sendProtocolResponse(int callId, const String16& message) override;
             //void sendProtocolNotification(const String16& message) override;
             //void flushProtocolNotifications() override;
 
+			void sendProtocolResponse(int callId, const v8_inspector::StringView &message) override;
+			void sendProtocolNotification(const v8_inspector::StringView &message) override;
+			void flushProtocolNotifications() override;
+
 		private:
             JsV8InspectorClient(v8::Isolate *isolate);
+			~JsV8InspectorClient();
 
             static JsV8InspectorClient* instance;
             static jclass inspectorClass;
             static jmethodID sendMethod;
 
+			TaskRunner* backend_runner;
             v8::Isolate* isolate_;
-            std::unique_ptr<V8Inspector> inspector_ = nullptr;
+            std::unique_ptr<V8Inspector> inspector_;
             std::unique_ptr<V8InspectorSession> session_;
             jobject connection;
 	};