revert as workaround for compiler error with old clang < 17 commit ce71348a09f6689dd01a68db64b172191d0182d8 Author: Andrey Kosyakov Date: Thu Dec 21 18:38:38 2023 +0000 [bindings] Use v8::Array::Iterate for converting script wrappables This changes CreateIDLSequenceFromV8Array to use the new v8::Array::Iterate() operation. This speeds up the "execBundles" part of the microbenchmark at crbug.com/dawn/1858 by around 3x. This depends on crrev.com/c/4846594 landing (and rolling) first. This is a slight re-work of https://crrev.com/c/4847447/3, originally by jkummerow@chromium.org Bug: v8:14218, dawn:1858, 1511239 Change-Id: Ia266556d05b4d53e6942e12609d1c08882b4ff0f Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5132129 Commit-Queue: Andrey Kosyakov Reviewed-by: Yuki Shiino Cr-Commit-Position: refs/heads/main@{#1240236} --- a/third_party/blink/renderer/bindings/core/v8/native_value_traits.h 2024-05-13 20:23:41.165774029 +0200 +++ b/third_party/blink/renderer/bindings/core/v8/native_value_traits.h 2024-05-13 20:27:58.994663485 +0200 @@ -110,12 +110,6 @@ struct NativeValueTraitsBase< static constexpr bool has_null_value = bindings::NativeValueTraitsHasNullValue::value; - // This should only be true for certain subclasses of ScriptWrappable - // that satisfy the assumptions of CreateIDLSequenceFromV8ArraySlow() with - // regards to how NativeValue() is implemented for the underlying type. - static constexpr bool supports_scriptwrappable_specific_fast_array_iteration = - false; - template static decltype(auto) ArgumentValue(v8::Isolate* isolate, int argument_index, --- a/third_party/blink/renderer/bindings/core/v8/native_value_traits_impl.h 2024-05-13 20:23:47.295915837 +0200 +++ b/third_party/blink/renderer/bindings/core/v8/native_value_traits_impl.h 2024-05-13 20:27:21.649808564 +0200 @@ -1050,87 +1050,11 @@ CreateIDLSequenceFromV8ArraySlow(v8::Iso return {}; } - using ResultType = typename NativeValueTraits>::ImplType; - ResultType result; + typename NativeValueTraits>::ImplType result; result.ReserveInitialCapacity(length); v8::Local current_context = isolate->GetCurrentContext(); v8::TryCatch try_block(isolate); - // Fast path -- we're creating a sequence of script wrappables, which can be - // done by directly getting underlying object as long as array types are - // homogeneous. With ScriptWrappables, we don't expect to enter JS during - // iteration, so we can rely on v8::Array::Iterate() which is much faster than - // iterating an array on the client side of the v8. Additionally, for most - // subsptyes of ScriptWrappables, we can speed up type checks (see more on - // that below next to supports_scriptwrappable_specific_fast_array_iteration - // check. - if constexpr (std::is_base_of_v) { - struct CallbackData { - STACK_ALLOCATED(); - - public: - v8::Isolate* isolate; - v8::TypecheckWitness witness; - ResultType& result; - ExceptionState& exception_state; - CallbackData(v8::Isolate* isolate, - ResultType& result, - ExceptionState& exception_state) - : isolate(isolate), - witness(isolate), - result(result), - exception_state(exception_state) {} - }; - - CallbackData callback_data(isolate, result, exception_state); - v8::Array::IterationCallback callback = [](uint32_t index, - v8::Local v8_element, - void* data) { - CallbackData* callback_data = reinterpret_cast(data); - v8::Isolate* isolate = callback_data->isolate; - // 3.4. Initialize Si to the result of converting nextItem to an IDL value - // of type T. - v8::TypecheckWitness& witness = callback_data->witness; - // We can speed up type check by taking advantage of V8's type witness, - // provided traits' NativeValue implementation doesn't have additional - // logic beyond checking the type and calling ToScriptWrappable(). - if constexpr ( - NativeValueTraits< - T>::supports_scriptwrappable_specific_fast_array_iteration) { - if (witness.Matches(v8_element)) { - auto&& value = ToScriptWrappable(isolate, v8_element.As()) - ->template ToImpl(); - callback_data->result.push_back(std::move(value)); - return v8::Array::CallbackResult::kContinue; - } - } - auto&& element = NativeValueTraits::NativeValue( - isolate, v8_element, callback_data->exception_state); - if (callback_data->exception_state.HadException()) { - // It doesn't matter whether we return `kException` or `kBreak` here, - // as that only affects the return value of `v8_array->Iterate()`, - // which we are ignoring. - return v8::Array::CallbackResult::kException; - } - if constexpr ( - NativeValueTraits< - T>::supports_scriptwrappable_specific_fast_array_iteration) { - witness.Update(v8_element); - } - callback_data->result.push_back(std::move(element)); - return v8::Array::CallbackResult::kContinue; - }; - if (!v8_array->Iterate(current_context, callback, &callback_data) - .IsJust()) { - if (try_block.HasCaught()) { - exception_state.RethrowV8Exception(try_block.Exception()); - } - DCHECK(exception_state.HadException()); - return {}; - } - return result; - } - // Array length may change if array is mutated during iteration. for (uint32_t i = 0; i < v8_array->Length(); ++i) { v8::Local v8_element; @@ -1590,12 +1514,6 @@ struct NativeValueTraits< T, typename std::enable_if_t::value>> : public NativeValueTraitsBase { - // This signifies that CreateIDLSequenceFromV8ArraySlow() may apply - // certain optimization based on assumptions about `NativeValue()` - // implementation below. For subclasses of ScriptWrappable that have - // different implementation of NativeValue(), this should remain false. - static constexpr bool supports_scriptwrappable_specific_fast_array_iteration = - true; static inline T* NativeValue(v8::Isolate* isolate, v8::Local value,