Lines Matching defs:that
2 // Use of this source code is governed by a BSD-style license that can be
667 // Check that values referenced by global/eternal handles are accounted for.
693 void V8::SetDcheckErrorHandler(DcheckErrorCallback that) {
694 v8::base::SetDcheckFunction(that);
924 // We make an exception if the serializer is enabled, which means that the
1168 static void InitializeTemplate(i::TemplateInfo that, int type,
1170 that.set_number_of_properties(0);
1171 that.set_tag(type);
1174 that.set_serial_number(serial_number);
1593 // Ensure that the object template has a constructor. If no
1966 // construct code, so we ensure that there is a constructor
2244 void v8::PrimitiveArray::CheckCast(v8::Data* that) {
2245 i::Handle<i::Object> obj = Utils::OpenHandle(that);
2862 // for reuse. capture_message_ needs to be disabled so that Throw()
2875 // Note that this will not cancel termination exceptions.
2950 // Note that this will not cancel termination exceptions.
3852 void v8::Value::CheckCast(Data* that) {
3853 Utils::ApiCheck(that->IsValue(), "v8::Value::Cast", "Data is not a Value");
3856 void External::CheckCast(v8::Value* that) {
3857 Utils::ApiCheck(that->IsExternal(), "v8::External::Cast",
3861 void v8::Object::CheckCast(Value* that) {
3862 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3867 void v8::Function::CheckCast(Value* that) {
3868 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3873 void v8::Boolean::CheckCast(v8::Data* that) {
3874 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3879 void v8::Name::CheckCast(v8::Data* that) {
3880 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3884 void v8::String::CheckCast(v8::Data* that) {
3885 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3889 void v8::Symbol::CheckCast(v8::Data* that) {
3890 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3894 void v8::Private::CheckCast(v8::Data* that) {
3895 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3901 void v8::FixedArray::CheckCast(v8::Data* that) {
3902 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3907 void v8::ModuleRequest::CheckCast(v8::Data* that) {
3908 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3913 void v8::Module::CheckCast(v8::Data* that) {
3914 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3918 void v8::Number::CheckCast(v8::Data* that) {
3919 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3924 void v8::Integer::CheckCast(v8::Data* that) {
3925 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3930 void v8::Int32::CheckCast(v8::Data* that) {
3931 Utils::ApiCheck(Value::Cast(that)->IsInt32(), "v8::Int32::Cast",
3935 void v8::Uint32::CheckCast(v8::Data* that) {
3936 Utils::ApiCheck(Value::Cast(that)->IsUint32(), "v8::Uint32::Cast",
3940 void v8::BigInt::CheckCast(v8::Data* that) {
3941 Utils::ApiCheck(Value::Cast(that)->IsBigInt(), "v8::BigInt::Cast",
3945 void v8::Context::CheckCast(v8::Data* that) {
3946 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3951 void v8::Array::CheckCast(Value* that) {
3952 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3956 void v8::Map::CheckCast(Value* that) {
3957 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3961 void v8::Set::CheckCast(Value* that) {
3962 i::Handle<i::Object> obj = Utils::OpenHandle(that);
3966 void v8::Promise::CheckCast(Value* that) {
3967 Utils::ApiCheck(that->IsPromise(), "v8::Promise::Cast",
3971 void v8::Promise::Resolver::CheckCast(Value* that) {
3972 Utils::ApiCheck(that->IsPromise(), "v8::Promise::Resolver::Cast",
3976 void v8::Proxy::CheckCast(Value* that) {
3977 Utils::ApiCheck(that->IsProxy(), "v8::Proxy::Cast", "Value is not a Proxy");
3980 void v8::WasmMemoryObject::CheckCast(Value* that) {
3981 Utils::ApiCheck(that->IsWasmMemoryObject(), "v8::WasmMemoryObject::Cast",
3985 void v8::WasmModuleObject::CheckCast(Value* that) {
3986 Utils::ApiCheck(that->IsWasmModuleObject(), "v8::WasmModuleObject::Cast",
4061 void v8::ArrayBuffer::CheckCast(Value* that) {
4062 i::Handle<i::Object> obj = Utils::OpenHandle(that);
4068 void v8::ArrayBufferView::CheckCast(Value* that) {
4069 i::Handle<i::Object> obj = Utils::OpenHandle(that);
4076 void v8::TypedArray::CheckCast(Value* that) {
4077 i::Handle<i::Object> obj = Utils::OpenHandle(that);
4083 void v8::Type##Array::CheckCast(Value* that) { \
4084 i::Handle<i::Object> obj = Utils::OpenHandle(that); \
4095 void v8::DataView::CheckCast(Value* that) {
4096 i::Handle<i::Object> obj = Utils::OpenHandle(that);
4101 void v8::SharedArrayBuffer::CheckCast(Value* that) {
4102 i::Handle<i::Object> obj = Utils::OpenHandle(that);
4108 void v8::Date::CheckCast(v8::Value* that) {
4109 i::Handle<i::Object> obj = Utils::OpenHandle(that);
4113 void v8::StringObject::CheckCast(v8::Value* that) {
4114 i::Handle<i::Object> obj = Utils::OpenHandle(that);
4119 void v8::SymbolObject::CheckCast(v8::Value* that) {
4120 i::Handle<i::Object> obj = Utils::OpenHandle(that);
4125 void v8::NumberObject::CheckCast(v8::Value* that) {
4126 i::Handle<i::Object> obj = Utils::OpenHandle(that);
4131 void v8::BigIntObject::CheckCast(v8::Value* that) {
4132 i::Handle<i::Object> obj = Utils::OpenHandle(that);
4137 void v8::BooleanObject::CheckCast(v8::Value* that) {
4138 i::Handle<i::Object> obj = Utils::OpenHandle(that);
4143 void v8::RegExp::CheckCast(v8::Value* that) {
4144 i::Handle<i::Object> obj = Utils::OpenHandle(that);
4226 Maybe<bool> Value::Equals(Local<Context> context, Local<Value> that) const {
4230 auto other = Utils::OpenHandle(*that);
4237 bool Value::StrictEquals(Local<Value> that) const {
4239 auto other = Utils::OpenHandle(*that);
4243 bool Value::SameValue(Local<Value> that) const {
4245 auto other = Utils::OpenHandle(*that);
4468 // Even though we said kDontThrow, there might be accessors that do throw.
4639 // IsTemplateFor() ensures that iter.GetCurrent() can't be a Proxy here.
5631 // previous characters in the stream. We know, however, that
6245 // insecure. Once we use sandboxed pointers, which assume that the sandbox
6310 // Make sure that the global_template has a constructor.
6402 // Sanity-check that the isolate is initialized and usable.
6654 // Shrink the list so that the last element is not the hole (unless it's
6684 void v8::ObjectTemplate::CheckCast(Data* that) {
6685 i::Handle<i::Object> obj = Utils::OpenHandle(that);
6690 void v8::FunctionTemplate::CheckCast(Data* that) {
6691 i::Handle<i::Object> obj = Utils::OpenHandle(that);
6696 void v8::Signature::CheckCast(Data* that) {
6697 i::Handle<i::Object> obj = Utils::OpenHandle(that);
6702 void v8::AccessorSignature::CheckCast(Data* that) {
6703 i::Handle<i::Object> obj = Utils::OpenHandle(that);
6752 // If it's a global proxy, then test with the global object. Note that the
6975 // SupportsExternalization already checked that the object is writable.
7002 // SupportsExternalization already checked that the object is writable.
7028 bool v8::String::StringEquals(Local<String> that) const {
7030 auto other = Utils::OpenHandle(*that);
7121 // We assume that this API is mostly used to create objects with named
7267 // Assert that the static TimeZoneDetection cast in
7314 // Assert that the static flags cast in GetFlags is valid.
7976 // version that throws an exception or otherwise does not crash.
8173 // version that throws an exception or otherwise does not crash.
8615 // This is separate so that tests can provide a different |isolate|.
8676 "that the snapshot blob file is corrupted or missing.");
8682 "Failed to deserialize the V8 snapshot blob. This can mean that the "
8688 // because that is where we add the isolate to WasmEngine.
8721 "Disposing the isolate that is entered by a thread.")) {
9087 void Isolate::SetEventLogger(LogEventCallback that) {
9091 isolate->set_event_logger(that);
9218 // Returning true tells the caller that it need not
9242 // of that context.
9312 // Ensure that logging is initialized for our isolate.
9453 bool Isolate::AddMessageListener(MessageCallback that, Local<Value> data) {
9454 return AddMessageListenerWithErrorLevel(that, kMessageError, data);
9457 bool Isolate::AddMessageListenerWithErrorLevel(MessageCallback that,
9466 isolate->factory()->NewForeign(FUNCTION_ADDR(that));
9476 void Isolate::RemoveMessageListeners(MessageCallback that) {
9486 if (callback_obj.foreign_address() == FUNCTION_ADDR(that)) {
10598 // Switch first and last blocks, such that the last block is the one
10599 // that is potentially half full.