[inspector] added inspector test runner [part 3]

test/inspector-protocol/inspector-protocol.cc

Index: test/inspector-protocol/inspector-protocol.cc
diff --git a/test/inspector-protocol/inspector-protocol.cc b/test/inspector-protocol/inspector-protocol.cc
new file mode 100644
index 0000000000000000000000000000000000000000..907549b2e94e2049d7181df9869bbf8632a678c5
--- /dev/null
+++ b/test/inspector-protocol/inspector-protocol.cc
@@ -0,0 +1,217 @@
+// Copyright 2016 the V8 project 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 "include/libplatform/libplatform.h"
+#include "include/v8.h"
+
+#include "src/base/platform/platform.h"
+#include "src/flags.h"
+#include "src/utils.h"
+#include "src/vector.h"
+
+#include "test/inspector-protocol/inspector-impl.h"
+#include "test/inspector-protocol/task-runner.h"
+
+namespace {
+
+class UtilsExtension : public v8::Extension {
+ public:
+  UtilsExtension()
+      : v8::Extension("v8_inspector/utils",
+                      "native function print(); native function quit();") {}
+  virtual v8::Local<v8::FunctionTemplate> GetNativeFunctionTemplate(
+      v8::Isolate* isolate, v8::Local<v8::String> name) {
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    if (name->Equals(context, v8::String::NewFromUtf8(
+                                  isolate, "print", v8::NewStringType::kNormal)
+                                  .ToLocalChecked())
+            .FromJust()) {
+      return v8::FunctionTemplate::New(isolate, UtilsExtension::Print);
+    } else if (name->Equals(context,
+                            v8::String::NewFromUtf8(isolate, "quit",
+                                                    v8::NewStringType::kNormal)
+                                .ToLocalChecked())
+                   .FromJust()) {
+      return v8::FunctionTemplate::New(isolate, UtilsExtension::Quit);
+    }
+    return v8::Local<v8::FunctionTemplate>();
+  }
+
+ private:
+  static void Print(const v8::FunctionCallbackInfo<v8::Value>& args) {
+    for (int i = 0; i < args.Length(); i++) {
+      v8::HandleScope handle_scope(args.GetIsolate());
+      if (i != 0) {
+        printf(" ");
+      }
+
+      // Explicitly catch potential exceptions in toString().
+      v8::TryCatch try_catch(args.GetIsolate());
+      v8::Local<v8::Value> arg = args[i];
+      v8::Local<v8::String> str_obj;
+
+      if (arg->IsSymbol()) {
+        arg = v8::Local<v8::Symbol>::Cast(arg)->Name();
+      }
+      if (!arg->ToString(args.GetIsolate()->GetCurrentContext())
+               .ToLocal(&str_obj)) {
+        try_catch.ReThrow();
+        return;
+      }
+
+      v8::String::Utf8Value str(str_obj);
+      int n =
+          static_cast<int>(fwrite(*str, sizeof(**str), str.length(), stdout));
+      if (n != str.length()) {
+        printf("Error in fwrite\n");
+        Quit(args);
+      }
+    }
+    printf("\n");
+    fflush(stdout);
+  }
+
+  static void Quit(const v8::FunctionCallbackInfo<v8::Value>& args) {
+    fflush(stdout);
+    fflush(stderr);
+    _exit(0);
+  }
+};
+
+class SetTimeoutTask : public TaskRunner::Task {
+ public:
+  SetTimeoutTask(v8::Isolate* isolate, v8::Local<v8::Function> function)
+      : function_(isolate, function) {}
+  virtual ~SetTimeoutTask() {}
+
+  bool is_inspector_task() final { return false; }
+
+  void Run(v8::Isolate* isolate,
+           const v8::Global<v8::Context>& global_context) override {
+    v8::MicrotasksScope microtasks_scope(isolate,
+                                         v8::MicrotasksScope::kRunMicrotasks);
+    v8::HandleScope handle_scope(isolate);
+    v8::Local<v8::Context> context = global_context.Get(isolate);
+    v8::Context::Scope context_scope(context);
+
+    v8::Local<v8::Function> function = function_.Get(isolate);
+    v8::MaybeLocal<v8::Value> result;
+    v8_inspector::V8Inspector* inspector =
+        InspectorClientImpl::InspectorFromContext(context);
+    if (inspector) inspector->willExecuteScript(context, function->ScriptId());
+    result = function->Call(context, context->Global(), 0, nullptr);
+    if (inspector) inspector->didExecuteScript(context);
+  }
+
+ private:
+  v8::Global<v8::Function> function_;
+};
+
+class SetTimeoutExtension : public v8::Extension {
+ public:
+  SetTimeoutExtension()
+      : v8::Extension("v8_inspector/setTimeout",
+                      "native function setTimeout();") {}
+
+  virtual v8::Local<v8::FunctionTemplate> GetNativeFunctionTemplate(
+      v8::Isolate* isolate, v8::Local<v8::String> name) {
+    return v8::FunctionTemplate::New(isolate, SetTimeoutExtension::SetTimeout);
+  }
+
+ private:
+  static void SetTimeout(const v8::FunctionCallbackInfo<v8::Value>& args) {
+    CHECK(args.Length() == 2 && args[1]->IsNumber() && args[0]->IsFunction());
+    double delay = args[1].As<v8::Number>()->Value();
+    // setTimeout supports only zero delay.
+    CHECK(delay == 0.0);
+    v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
+    TaskRunner::FromContext(context)->Append(new SetTimeoutTask(
+        args.GetIsolate(), v8::Local<v8::Function>::Cast(args[0])));
+  }
+};
+
+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());
+}
+
+class FrontendChannelImpl : public InspectorClientImpl::FrontendChannel {
+ public:
+  FrontendChannelImpl(TaskRunner* frontend_task_runner)
+      : frontend_task_runner_(frontend_task_runner) {}
+  virtual ~FrontendChannelImpl() {}
+
+  void SendMessageToFrontend(const v8_inspector::StringView& message) final {
+    v8_inspector::String16Builder script;
+    script.append("InspectorTest.dispatchMessage(");
+    script.append(ToString16(message));
+    script.append(")");
+    v8_inspector::String16 script_string = script.toString();
+    frontend_task_runner_->Append(
+        new ExecuteStringTask(v8_inspector::StringView(

[dgozman, 2016/09/28 17:44:22]

StringView cannot outlive underlying String16.

[kozy, 2016/09/28 19:22:58]

Done.

+            script_string.characters16(), script_string.length())));
+  }
+
+ private:
+  TaskRunner* frontend_task_runner_;
+};
+
+}  //  namespace
+
+int main(int argc, char* argv[]) {
+  v8::V8::InitializeICUDefaultLocation(argv[0]);
+  v8::Platform* platform = v8::platform::CreateDefaultPlatform();
+  v8::V8::InitializePlatform(platform);
+  v8::internal::FlagList::SetFlagsFromCommandLine(&argc, argv, true);
+  v8::V8::InitializeExternalStartupData(argv[0]);
+  v8::V8::Initialize();
+
+  SetTimeoutExtension set_timeout_extension;
+  v8::RegisterExtension(&set_timeout_extension);
+  UtilsExtension utils_extension;
+  v8::RegisterExtension(&utils_extension);
+  SendMessageToBackendExtension send_message_to_backend_extension;
+  v8::RegisterExtension(&send_message_to_backend_extension);
+
+  v8::base::Semaphore ready_semaphore(0);
+
+  const char* backend_extensions[] = {"v8_inspector/setTimeout"};
+  v8::ExtensionConfiguration backend_configuration(
+      arraysize(backend_extensions), backend_extensions);
+  TaskRunner backend_runner(&backend_configuration, &ready_semaphore);
+  ready_semaphore.Wait();
+  SendMessageToBackendExtension::set_backend_task_runner(&backend_runner);
+
+  const char* frontend_extensions[] = {"v8_inspector/utils",
+                                       "v8_inspector/frontend"};
+  v8::ExtensionConfiguration frontend_configuration(
+      arraysize(frontend_extensions), frontend_extensions);
+  TaskRunner frontend_runner(&frontend_configuration, &ready_semaphore);
+  ready_semaphore.Wait();
+
+  FrontendChannelImpl frontend_channel(&frontend_runner);
+  InspectorClientImpl inspector_client(&backend_runner, &frontend_channel,
+                                       &ready_semaphore);
+  ready_semaphore.Wait();
+
+  for (int i = 1; i < argc; ++i) {
+    if (argv[i][0] == '-') break;
+
+    bool exists = false;
+    v8::internal::Vector<const char> chars =
+        v8::internal::ReadFile(argv[i], &exists, true);
+    CHECK(exists);
+    v8_inspector::String16 source =
+        v8_inspector::String16::fromUTF8(chars.start(), chars.length());
+    frontend_runner.Append(new ExecuteStringTask(
+        v8_inspector::StringView(source.characters16(), source.length())));
+  }
+
+  frontend_runner.Join();
+  return 0;
+}