Avoid using stale InspectedContext pointers

test/inspector/inspector-test.cc

 // 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.
 
 #if !defined(_WIN32) && !defined(_WIN64)
 #include <unistd.h>  // NOLINT
 #endif               // !defined(_WIN32) && !defined(_WIN64)
 
 #include <locale.h>
 
@@ skipping 194 matching lines @@
     if (args[0]->IsFunction()) {
       TaskRunner::FromContext(context)->Append(new SetTimeoutTask(
           args.GetIsolate(), v8::Local<v8::Function>::Cast(args[0])));
     } else {
       TaskRunner::FromContext(context)->Append(
           new ExecuteStringTask(ToVector(args[0].As<v8::String>())));
     }
   }
 };
 
+class InspectorExtension : public v8::Extension {
+ public:
+  InspectorExtension()
+      : v8::Extension("v8_inspector/inspector",
+                      "native function attachInspector();"
+                      "native function detachInspector();") {}
+
+  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, "attachInspector",
+                                             v8::NewStringType::kNormal)
+                         .ToLocalChecked())
+            .FromJust()) {
+      return v8::FunctionTemplate::New(isolate, InspectorExtension::Attach);
+    } else if (name->Equals(context,
+                            v8::String::NewFromUtf8(isolate, "detachInspector",
+                                                    v8::NewStringType::kNormal)
+                                .ToLocalChecked())
+                   .FromJust()) {
+      return v8::FunctionTemplate::New(isolate, InspectorExtension::Detach);
+    }
+    return v8::Local<v8::FunctionTemplate>();
+  }
+
+ private:
+  static void Attach(const v8::FunctionCallbackInfo<v8::Value>& args) {
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetEnteredContext();

[kozy, 2016/10/21 15:06:53]

GetCurrentContext()

[robwu, 2016/10/21 20:32:45]

Done.

+    v8_inspector::V8Inspector* inspector =
+        InspectorClientImpl::InspectorFromContext(context);
+    if (!inspector) {
+      fprintf(stderr, "Inspector client not found - cannot attach!");
+      Exit();
+    }
+    fprintf(stdout, "Attaching context.\n");
+    inspector->contextDestroyed(context);

[kozy, 2016/10/21 15:06:53]

Do you really need this call? Otherwise it looks like Reaatach, not attach.

[robwu, 2016/10/21 20:32:45]

Oops. Removed.

+    inspector->contextCreated(
+        v8_inspector::V8ContextInfo(context, 1, v8_inspector::StringView()));
+  }
+
+  static void Detach(const v8::FunctionCallbackInfo<v8::Value>& args) {
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetEnteredContext();
+    v8_inspector::V8Inspector* inspector =
+        InspectorClientImpl::InspectorFromContext(context);
+    if (!inspector) {
+      fprintf(stderr, "Inspector client not found - cannot detach!");
+      Exit();
+    }
+    fprintf(stdout, "Detaching context.\n");
+    inspector->contextDestroyed(context);
+  }
+};
+
 v8::Local<v8::String> ToString(v8::Isolate* isolate,
                                const v8_inspector::StringView& string) {
   if (string.is8Bit())
     return v8::String::NewFromOneByte(isolate, string.characters8(),
                                       v8::NewStringType::kNormal,
                                       static_cast<int>(string.length()))
         .ToLocalChecked();
   else
     return v8::String::NewFromTwoByte(isolate, string.characters16(),
                                       v8::NewStringType::kNormal,
@@ skipping 35 matching lines @@
 int main(int argc, char* argv[]) {
   v8::V8::InitializeICUDefaultLocation(argv[0]);
   v8::Platform* platform = v8::platform::CreateDefaultPlatform();
   v8::V8::InitializePlatform(platform);
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
   v8::V8::InitializeExternalStartupData(argv[0]);
   v8::V8::Initialize();
 
   SetTimeoutExtension set_timeout_extension;
   v8::RegisterExtension(&set_timeout_extension);
+  InspectorExtension inspector_extension;
+  v8::RegisterExtension(&inspector_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"};
+  const char* backend_extensions[] = {"v8_inspector/setTimeout",
+                                      "v8_inspector/inspector"};
   v8::ExtensionConfiguration backend_configuration(
       arraysize(backend_extensions), backend_extensions);
   TaskRunner backend_runner(&backend_configuration, false, &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);
@@ skipping 19 matching lines @@
               argv[i]);
       Exit();
     }
     frontend_runner.Append(new ExecuteStringTask(chars));
   }
 
   frontend_runner.Join();
   backend_runner.Join();
   return 0;
 }