Remove V8\Isolate::$snapshot private property

Author: pinepain

scripts/replace_expect.php

@@ -45,6 +45,7 @@
         }
 
         continue;
+    //} elseif (0) {
     } elseif (false !== ($pos = strpos($test_content, '--EXPECTF--'))) {
 
         printf("--EXPECTF--  [%s]".PHP_EOL, $iterator->key());

src/php_v8_isolate.cc

@@ -128,6 +128,12 @@ static void php_v8_isolate_free(zend_object *object) {
 
         delete php_v8_isolate->create_params;
     }
+
+    if (php_v8_isolate->blob && php_v8_isolate->blob->release()) {
+        delete php_v8_isolate->blob;
+    }
+
+    php_v8_isolate->blob = nullptr;
 }
 
 static void php_v8_isolate_oom_error_callback(const char *location, bool is_heap_oom) {
@@ -144,6 +150,7 @@ static zend_object *php_v8_isolate_ctor(zend_class_entry *ce) {
 
     php_v8_init();
 
+    php_v8_isolate->blob = nullptr;
     php_v8_isolate->create_params = new v8::Isolate::CreateParams();
     php_v8_isolate->create_params->array_buffer_allocator = v8::ArrayBuffer::Allocator::NewDefaultAllocator();
 
@@ -191,9 +198,10 @@ static PHP_METHOD(V8Isolate, __construct) {
 
     if (snapshot_zv != NULL) {
         PHP_V8_STARTUP_DATA_FETCH_INTO(snapshot_zv, php_v8_startup_data);
-        zend_update_property(this_ce, getThis(), ZEND_STRL("snapshot"), snapshot_zv);
-
-        php_v8_isolate->create_params->snapshot_blob = php_v8_startup_data->blob;
+        if (php_v8_startup_data->blob && php_v8_startup_data->blob->hasData()) {
+            php_v8_isolate->blob = php_v8_startup_data->blob;
+            php_v8_isolate->create_params->snapshot_blob = php_v8_isolate->blob->acquire();
+        }
     }
 
     php_v8_isolate->isolate = v8::Isolate::New(*php_v8_isolate->create_params);
@@ -313,21 +321,6 @@ static PHP_METHOD(V8Isolate, IsMemoryLimitHit) {
     RETVAL_ZVAL(prop, 1, 0);
 }
 
-static PHP_METHOD(V8Isolate, GetSnapshot) {
-    zval rv;
-
-    zval *prop = NULL;
-    if (zend_parse_parameters_none() == FAILURE) {
-        return;
-    }
-
-    PHP_V8_ISOLATE_FETCH_WITH_CHECK(getThis(), php_v8_isolate);
-
-    prop = zend_read_property(this_ce, getThis(), ZEND_STRL("snapshot"), 0, &rv);
-
-    RETVAL_ZVAL(prop, 1, 0);
-}
-
 static PHP_METHOD(V8Isolate, GetHeapStatistics) {
     if (zend_parse_parameters_none() == FAILURE) {
         return;
@@ -526,9 +519,6 @@ ZEND_END_ARG_INFO()
 PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_v8_isolate_IsMemoryLimitHit, ZEND_RETURN_VALUE, 0, _IS_BOOL, 0)
 ZEND_END_ARG_INFO()
 
-PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_v8_isolate_GetSnapshot, ZEND_RETURN_VALUE, 0, V8\\StartupData, 1)
-ZEND_END_ARG_INFO()
-
 PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_v8_isolate_GetHeapStatistics, ZEND_RETURN_VALUE, 0, V8\\HeapStatistics, 0)
 ZEND_END_ARG_INFO()
 
@@ -586,8 +576,6 @@ static const zend_function_entry php_v8_isolate_methods[] = {
         PHP_ME(V8Isolate, GetMemoryLimit, arginfo_v8_isolate_GetMemoryLimit, ZEND_ACC_PUBLIC)
         PHP_ME(V8Isolate, IsMemoryLimitHit, arginfo_v8_isolate_IsMemoryLimitHit, ZEND_ACC_PUBLIC)
 
-        PHP_ME(V8Isolate, GetSnapshot, arginfo_v8_isolate_GetSnapshot, ZEND_ACC_PUBLIC)
-
         PHP_ME(V8Isolate, GetHeapStatistics, arginfo_v8_isolate_GetHeapStatistics, ZEND_ACC_PUBLIC)
 
         PHP_ME(V8Isolate, InContext, arginfo_v8_isolate_InContext, ZEND_ACC_PUBLIC)
@@ -616,8 +604,6 @@ PHP_MINIT_FUNCTION (php_v8_isolate) {
     this_ce = zend_register_internal_class(&ce);
     this_ce->create_object = php_v8_isolate_ctor;
 
-    zend_declare_property_null(this_ce, ZEND_STRL("snapshot"), ZEND_ACC_PRIVATE);
-
     zend_declare_property_double(this_ce, ZEND_STRL("time_limit"), 0.0, ZEND_ACC_PRIVATE);
     zend_declare_property_bool(this_ce, ZEND_STRL("time_limit_hit"), 0, ZEND_ACC_PRIVATE);
 

src/php_v8_isolate.h

@@ -15,6 +15,7 @@
 
 typedef struct _php_v8_isolate_t php_v8_isolate_t;
 
+#include "php_v8_startup_data.h"
 #include "php_v8_isolate_limits.h"
 #include "php_v8_exceptions.h"
 #include "php_v8_callbacks.h"
@@ -119,6 +120,7 @@ inline v8::Local<v8::Private> php_v8_isolate_get_key_local(php_v8_isolate_t *php
 struct _php_v8_isolate_t {
     v8::Isolate *isolate;
     v8::Isolate::CreateParams *create_params;
+    phpv8::StartupData *blob;
 
     phpv8::PersistentCollection<v8::FunctionTemplate> *weak_function_templates;
     phpv8::PersistentCollection<v8::ObjectTemplate> *weak_object_templates;

src/php_v8_startup_data.cc

@@ -31,15 +31,16 @@ void php_v8_startup_data_create(zval *return_value, v8::StartupData *blob) {
 
     PHP_V8_STARTUP_DATA_FETCH_INTO(return_value, php_v8_startup_data);
 
-    php_v8_startup_data->blob = blob;
+    php_v8_startup_data->blob = new phpv8::StartupData(blob);
 }
 
 static void php_v8_startup_data_free(zend_object *object) {
     php_v8_startup_data_t *php_v8_startup_data = php_v8_startup_data_fetch_object(object);
 
-    if (php_v8_startup_data->blob) {
+    if (php_v8_startup_data->blob && php_v8_startup_data->blob->release()) {
         delete php_v8_startup_data->blob;
     }
+    php_v8_startup_data->blob = nullptr;
 
     zend_object_std_dtor(&php_v8_startup_data->std);
 }
@@ -61,27 +62,28 @@ static zend_object *php_v8_startup_data_ctor(zend_class_entry *ce) {
 }
 
 static PHP_METHOD(V8StartupData, __construct) {
-    zend_string *blob = NULL;
+    zend_string *blob_string = NULL;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &blob) == FAILURE) {
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &blob_string) == FAILURE) {
         return;
     }
 
-    if (ZSTR_LEN(blob) > INT_MAX) {
+    if (ZSTR_LEN(blob_string) > INT_MAX) {
         PHP_V8_THROW_EXCEPTION("Failed to create startup blob due to blob size integer overflow");
         return;
     }
 
-    if (!ZSTR_LEN(blob)) {
+    if (!ZSTR_LEN(blob_string)) {
         return;
     }
 
     PHP_V8_STARTUP_DATA_FETCH_INTO(getThis(), php_v8_startup_data);
 
-    php_v8_startup_data->blob = new v8::StartupData();
+    v8::StartupData *blob = new v8::StartupData();
+    blob->data = (const char *) estrndup(ZSTR_VAL(blob_string), ZSTR_LEN(blob_string));
+    blob->raw_size = static_cast<int>(ZSTR_LEN(blob_string));
 
-    php_v8_startup_data->blob->data = (const char *) estrndup(ZSTR_VAL(blob), ZSTR_LEN(blob));
-    php_v8_startup_data->blob->raw_size = static_cast<int>(ZSTR_LEN(blob));
+    php_v8_startup_data->blob = new phpv8::StartupData(blob);
 }
 
 static PHP_METHOD(V8StartupData, GetData) {
@@ -91,8 +93,8 @@ static PHP_METHOD(V8StartupData, GetData) {
 
     PHP_V8_STARTUP_DATA_FETCH_INTO(getThis(), php_v8_startup_data);
 
-    if (php_v8_startup_data->blob->data != NULL) {
-        zend_string *out = zend_string_init(php_v8_startup_data->blob->data, static_cast<size_t>(php_v8_startup_data->blob->raw_size), 0);
+    if (php_v8_startup_data->blob && php_v8_startup_data->blob->hasData()) {
+        zend_string *out = zend_string_init(php_v8_startup_data->blob->data()->data, static_cast<size_t>(php_v8_startup_data->blob->data()->raw_size), 0);
         RETURN_STR(out);
     }
 
@@ -106,7 +108,12 @@ static PHP_METHOD(V8StartupData, GetRawSize) {
 
     PHP_V8_STARTUP_DATA_FETCH_INTO(getThis(), php_v8_startup_data);
 
-    RETVAL_LONG(static_cast<zend_long>(php_v8_startup_data->blob->raw_size));
+    if (php_v8_startup_data->blob && php_v8_startup_data->blob->hasData()) {
+        RETVAL_LONG(static_cast<zend_long>(php_v8_startup_data->blob->data()->raw_size));
+        return;
+    }
+
+    RETURN_LONG(0);
 }
 
 static PHP_METHOD(V8StartupData, CreateFromSource) {

src/php_v8_startup_data.h

@@ -15,6 +15,11 @@
 
 typedef struct _php_v8_startup_data_t php_v8_startup_data_t;
 
+namespace phpv8 {
+    class StartupData;
+}
+
+#include "php_v8_exceptions.h"
 #include <v8.h>
 
 extern "C" {
@@ -33,8 +38,46 @@ inline php_v8_startup_data_t * php_v8_startup_data_fetch_object(zend_object *obj
 #define PHP_V8_STARTUP_DATA_FETCH_INTO(pzval, into) php_v8_startup_data_t *(into) = PHP_V8_STARTUP_DATA_FETCH((pzval))
 
 
+namespace phpv8 {
+    class StartupData {
+    public:
+        StartupData(v8::StartupData *data = nullptr) : _data(data), in_use(1) {}
+
+        inline v8::StartupData *acquire() {
+            assert(in_use < UINT32_MAX);
+            in_use++;
+            return _data;
+        }
+
+        inline bool hasData() {
+            return _data && _data->raw_size > 0;
+        }
+
+        inline v8::StartupData *data() {
+            return _data;
+        }
+
+        bool release() {
+            assert(in_use > 0);
+            return --in_use == 0;
+        }
+
+        ~StartupData() {
+            if (_data) {
+                delete _data;
+            }
+        }
+
+        v8::StartupData* operator*() const { return _data; }
+    private:
+        v8::StartupData *_data;
+        uint32_t in_use;
+    };
+}
+
+
 struct _php_v8_startup_data_t {
-    v8::StartupData *blob;
+    phpv8::StartupData *blob;
     zend_object std;
 };
 

stubs/src/Isolate.php

@@ -17,16 +17,6 @@
 
 class Isolate
 {
-    /**
-     * @var StartupData | null
-     */
-    private $snapshot;
-
-    private $time_limit = 0.0;
-    private $time_limit_hit = false;
-    private $memory_limit = 0;
-    private $memory_limit_hit = false;
-
     public function __construct(StartupData $snapshot = null)
     {
     }
@@ -55,13 +45,6 @@ public function IsTimeLimitHit(): bool
     {
     }
 
-    /**
-     * @return StartupData | null
-     */
-    public function GetSnapshot()
-    {
-    }
-
     /**
      * Get statistics about the heap memory usage.
      *