src/api.cc

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/api.h"
   6
   7 #include <string.h>  // For memcpy, strlen.
   8 #ifdef V8_USE_ADDRESS_SANITIZER
   9 #include <sanitizer/asan_interface.h>
  10 #endif  // V8_USE_ADDRESS_SANITIZER
  11 #include <cmath>  // For isnan.
  12 #include "include/v8-debug.h"
  13 #include "include/v8-profiler.h"
  14 #include "include/v8-testing.h"
  15 #include "src/api-natives.h"
  16 #include "src/assert-scope.h"
  17 #include "src/background-parsing-task.h"
  18 #include "src/base/functional.h"
  19 #include "src/base/platform/platform.h"
  20 #include "src/base/platform/time.h"
  21 #include "src/base/utils/random-number-generator.h"
  22 #include "src/bootstrapper.h"
  23 #include "src/char-predicates-inl.h"
  24 #include "src/code-stubs.h"
  25 #include "src/compiler.h"
  26 #include "src/context-measure.h"
  27 #include "src/contexts.h"
  28 #include "src/conversions-inl.h"
  29 #include "src/counters.h"
  30 #include "src/cpu-profiler.h"
  31 #include "src/debug/debug.h"
  32 #include "src/deoptimizer.h"
  33 #include "src/execution.h"
  34 #include "src/global-handles.h"
  35 #include "src/heap-profiler.h"
  36 #include "src/heap-snapshot-generator-inl.h"
  37 #include "src/icu_util.h"
  38 #include "src/json-parser.h"
  39 #include "src/messages.h"
  40 #include "src/parser.h"
  41 #include "src/pending-compilation-error-handler.h"
  42 #include "src/profile-generator-inl.h"
  43 #include "src/property.h"
  44 #include "src/property-details.h"
  45 #include "src/prototype.h"
  46 #include "src/runtime/runtime.h"
  47 #include "src/runtime-profiler.h"
  48 #include "src/sampler.h"
  49 #include "src/scanner-character-streams.h"
  50 #include "src/simulator.h"
  51 #include "src/snapshot/natives.h"
  52 #include "src/snapshot/snapshot.h"
  53 #include "src/startup-data-util.h"
  54 #include "src/unicode-inl.h"
  55 #include "src/v8.h"
  56 #include "src/v8threads.h"
  57 #include "src/version.h"
  58 #include "src/vm-state-inl.h"
  59
  60
  61 namespace v8 {
  62
  63 #define LOG_API(isolate, expr) LOG(isolate, ApiEntryCall(expr))
  64
  65
  66 #define ENTER_V8(isolate) i::VMState<v8::OTHER> __state__((isolate))
  67
  68
  69 #define PREPARE_FOR_EXECUTION_GENERIC(isolate, context, function_name, \
  70                                       bailout_value, HandleScopeClass, \
  71                                       do_callback)                     \
  72   if (IsExecutionTerminatingCheck(isolate)) {                          \
  73     return bailout_value;                                              \
  74   }                                                                    \
  75   HandleScopeClass handle_scope(isolate);                              \
  76   CallDepthScope call_depth_scope(isolate, context, do_callback);      \
  77   LOG_API(isolate, function_name);                                     \
  78   ENTER_V8(isolate);                                                   \
  79   bool has_pending_exception = false
  80
  81
  82 #define PREPARE_FOR_EXECUTION_WITH_CONTEXT(                                  \
  83     context, function_name, bailout_value, HandleScopeClass, do_callback)    \
  84   auto isolate = context.IsEmpty()                                           \
  85                      ? i::Isolate::Current()                                 \
  86                      : reinterpret_cast<i::Isolate*>(context->GetIsolate()); \
  87   PREPARE_FOR_EXECUTION_GENERIC(isolate, context, function_name,             \
  88                                 bailout_value, HandleScopeClass, do_callback);
  89
  90
  91 #define PREPARE_FOR_EXECUTION_WITH_ISOLATE(isolate, function_name, T)     \
  92   PREPARE_FOR_EXECUTION_GENERIC(isolate, Local<Context>(), function_name, \
  93                                 MaybeLocal<T>(), InternalEscapableScope,  \
  94                                 false);
  95
  96
  97 #define PREPARE_FOR_EXECUTION(context, function_name, T)                      \
  98   PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, function_name, MaybeLocal<T>(), \
  99                                      InternalEscapableScope, false)
 100
 101
 102 #define PREPARE_FOR_EXECUTION_WITH_CALLBACK(context, function_name, T)        \
 103   PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, function_name, MaybeLocal<T>(), \
 104                                      InternalEscapableScope, true)
 105
 106
 107 #define PREPARE_FOR_EXECUTION_PRIMITIVE(context, function_name, T)         \
 108   PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, function_name, Nothing<T>(), \
 109                                      i::HandleScope, false)
 110
 111
 112 #define EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, value) \
 113   do {                                                 \
 114     if (has_pending_exception) {                       \
 115       call_depth_scope.Escape();                       \
 116       return value;                                    \
 117     }                                                  \
 118   } while (false)
 119
 120
 121 #define RETURN_ON_FAILED_EXECUTION(T) \
 122   EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, MaybeLocal<T>())
 123
 124
 125 #define RETURN_ON_FAILED_EXECUTION_PRIMITIVE(T) \
 126   EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, Nothing<T>())
 127
 128
 129 #define RETURN_TO_LOCAL_UNCHECKED(maybe_local, T) \
 130   return maybe_local.FromMaybe(Local<T>());
 131
 132
 133 #define RETURN_ESCAPED(value) return handle_scope.Escape(value);
 134
 135
 136 namespace {
 137
 138 Local<Context> ContextFromHeapObject(i::Handle<i::Object> obj) {
 139   return reinterpret_cast<v8::Isolate*>(i::HeapObject::cast(*obj)->GetIsolate())
 140       ->GetCurrentContext();
 141 }
 142
 143 class InternalEscapableScope : public v8::EscapableHandleScope {
 144  public:
 145   explicit inline InternalEscapableScope(i::Isolate* isolate)
 146       : v8::EscapableHandleScope(reinterpret_cast<v8::Isolate*>(isolate)) {}
 147 };
 148
 149
 150 class CallDepthScope {
 151  public:
 152   explicit CallDepthScope(i::Isolate* isolate, Local<Context> context,
 153                           bool do_callback)
 154       : isolate_(isolate),
 155         context_(context),
 156         escaped_(false),
 157         do_callback_(do_callback) {
 158     // TODO(dcarney): remove this when blink stops crashing.
 159     DCHECK(!isolate_->external_caught_exception());
 160     isolate_->handle_scope_implementer()->IncrementCallDepth();
 161     if (!context_.IsEmpty()) context_->Enter();
 162   }
 163   ~CallDepthScope() {
 164     if (!context_.IsEmpty()) context_->Exit();
 165     if (!escaped_) isolate_->handle_scope_implementer()->DecrementCallDepth();
 166     if (do_callback_) isolate_->FireCallCompletedCallback();
 167   }
 168
 169   void Escape() {
 170     DCHECK(!escaped_);
 171     escaped_ = true;
 172     auto handle_scope_implementer = isolate_->handle_scope_implementer();
 173     handle_scope_implementer->DecrementCallDepth();
 174     bool call_depth_is_zero = handle_scope_implementer->CallDepthIsZero();
 175     isolate_->OptionalRescheduleException(call_depth_is_zero);
 176   }
 177
 178  private:
 179   i::Isolate* const isolate_;
 180   Local<Context> context_;
 181   bool escaped_;
 182   bool do_callback_;
 183 };
 184
 185 }  // namespace
 186
 187
 188 static ScriptOrigin GetScriptOriginForScript(i::Isolate* isolate,
 189                                              i::Handle<i::Script> script) {
 190   i::Handle<i::Object> scriptName(i::Script::GetNameOrSourceURL(script));
 191   i::Handle<i::Object> source_map_url(script->source_mapping_url(), isolate);
 192   v8::Isolate* v8_isolate =
 193       reinterpret_cast<v8::Isolate*>(script->GetIsolate());
 194   ScriptOriginOptions options(script->origin_options());
 195   v8::ScriptOrigin origin(
 196       Utils::ToLocal(scriptName),
 197       v8::Integer::New(v8_isolate, script->line_offset()->value()),
 198       v8::Integer::New(v8_isolate, script->column_offset()->value()),
 199       v8::Boolean::New(v8_isolate, options.IsSharedCrossOrigin()),
 200       v8::Integer::New(v8_isolate, script->id()->value()),
 201       v8::Boolean::New(v8_isolate, options.IsEmbedderDebugScript()),
 202       Utils::ToLocal(source_map_url),
 203       v8::Boolean::New(v8_isolate, options.IsOpaque()));
 204   return origin;
 205 }
 206
 207
 208 // --- E x c e p t i o n   B e h a v i o r ---
 209
 210
 211 void i::FatalProcessOutOfMemory(const char* location) {
 212   i::V8::FatalProcessOutOfMemory(location, false);
 213 }
 214
 215
 216 // When V8 cannot allocated memory FatalProcessOutOfMemory is called.
 217 // The default fatal error handler is called and execution is stopped.
 218 void i::V8::FatalProcessOutOfMemory(const char* location, bool take_snapshot) {
 219   i::Isolate* isolate = i::Isolate::Current();
 220   char last_few_messages[Heap::kTraceRingBufferSize + 1];
 221   char js_stacktrace[Heap::kStacktraceBufferSize + 1];
 222   memset(last_few_messages, 0, Heap::kTraceRingBufferSize + 1);
 223   memset(js_stacktrace, 0, Heap::kStacktraceBufferSize + 1);
 224
 225   i::HeapStats heap_stats;
 226   int start_marker;
 227   heap_stats.start_marker = &start_marker;
 228   int new_space_size;
 229   heap_stats.new_space_size = &new_space_size;
 230   int new_space_capacity;
 231   heap_stats.new_space_capacity = &new_space_capacity;
 232   intptr_t old_space_size;
 233   heap_stats.old_space_size = &old_space_size;
 234   intptr_t old_space_capacity;
 235   heap_stats.old_space_capacity = &old_space_capacity;
 236   intptr_t code_space_size;
 237   heap_stats.code_space_size = &code_space_size;
 238   intptr_t code_space_capacity;
 239   heap_stats.code_space_capacity = &code_space_capacity;
 240   intptr_t map_space_size;
 241   heap_stats.map_space_size = &map_space_size;
 242   intptr_t map_space_capacity;
 243   heap_stats.map_space_capacity = &map_space_capacity;
 244   intptr_t lo_space_size;
 245   heap_stats.lo_space_size = &lo_space_size;
 246   int global_handle_count;
 247   heap_stats.global_handle_count = &global_handle_count;
 248   int weak_global_handle_count;
 249   heap_stats.weak_global_handle_count = &weak_global_handle_count;
 250   int pending_global_handle_count;
 251   heap_stats.pending_global_handle_count = &pending_global_handle_count;
 252   int near_death_global_handle_count;
 253   heap_stats.near_death_global_handle_count = &near_death_global_handle_count;
 254   int free_global_handle_count;
 255   heap_stats.free_global_handle_count = &free_global_handle_count;
 256   intptr_t memory_allocator_size;
 257   heap_stats.memory_allocator_size = &memory_allocator_size;
 258   intptr_t memory_allocator_capacity;
 259   heap_stats.memory_allocator_capacity = &memory_allocator_capacity;
 260   int objects_per_type[LAST_TYPE + 1] = {0};
 261   heap_stats.objects_per_type = objects_per_type;
 262   int size_per_type[LAST_TYPE + 1] = {0};
 263   heap_stats.size_per_type = size_per_type;
 264   int os_error;
 265   heap_stats.os_error = &os_error;
 266   heap_stats.last_few_messages = last_few_messages;
 267   heap_stats.js_stacktrace = js_stacktrace;
 268   int end_marker;
 269   heap_stats.end_marker = &end_marker;
 270   if (isolate->heap()->HasBeenSetUp()) {
 271     // BUG(1718): Don't use the take_snapshot since we don't support
 272     // HeapIterator here without doing a special GC.
 273     isolate->heap()->RecordStats(&heap_stats, false);
 274     char* first_newline = strchr(last_few_messages, '\n');
 275     if (first_newline == NULL || first_newline[1] == '\0')
 276       first_newline = last_few_messages;
 277     PrintF("\n<--- Last few GCs --->\n%s\n", first_newline);
 278     PrintF("\n<--- JS stacktrace --->\n%s\n", js_stacktrace);
 279   }
 280   Utils::ApiCheck(false, location, "Allocation failed - process out of memory");
 281   // If the fatal error handler returns, we stop execution.
 282   FATAL("API fatal error handler returned after process out of memory");
 283 }
 284
 285
 286 void Utils::ReportApiFailure(const char* location, const char* message) {
 287   i::Isolate* isolate = i::Isolate::Current();
 288   FatalErrorCallback callback = isolate->exception_behavior();
 289   if (callback == NULL) {
 290     base::OS::PrintError("\n#\n# Fatal error in %s\n# %s\n#\n\n", location,
 291                          message);
 292     base::OS::Abort();
 293   } else {
 294     callback(location, message);
 295   }
 296   isolate->SignalFatalError();
 297 }
 298
 299
 300 static inline bool IsExecutionTerminatingCheck(i::Isolate* isolate) {
 301   if (isolate->has_scheduled_exception()) {
 302     return isolate->scheduled_exception() ==
 303         isolate->heap()->termination_exception();
 304   }
 305   return false;
 306 }
 307
 308
 309 void V8::SetNativesDataBlob(StartupData* natives_blob) {
 310   i::V8::SetNativesBlob(natives_blob);
 311 }
 312
 313
 314 void V8::SetSnapshotDataBlob(StartupData* snapshot_blob) {
 315   i::V8::SetSnapshotBlob(snapshot_blob);
 316 }
 317
 318
 319 bool RunExtraCode(Isolate* isolate, Local<Context> context,
 320                   const char* utf8_source) {
 321   // Run custom script if provided.
 322   base::ElapsedTimer timer;
 323   timer.Start();
 324   TryCatch try_catch(isolate);
 325   Local<String> source_string;
 326   if (!String::NewFromUtf8(isolate, utf8_source, NewStringType::kNormal)
 327            .ToLocal(&source_string)) {
 328     return false;
 329   }
 330   Local<String> resource_name =
 331       String::NewFromUtf8(isolate, "<embedded script>", NewStringType::kNormal)
 332           .ToLocalChecked();
 333   ScriptOrigin origin(resource_name);
 334   ScriptCompiler::Source source(source_string, origin);
 335   Local<Script> script;
 336   if (!ScriptCompiler::Compile(context, &source).ToLocal(&script)) return false;
 337   if (script->Run(context).IsEmpty()) return false;
 338   if (i::FLAG_profile_deserialization) {
 339     i::PrintF("Executing custom snapshot script took %0.3f ms\n",
 340               timer.Elapsed().InMillisecondsF());
 341   }
 342   timer.Stop();
 343   CHECK(!try_catch.HasCaught());
 344   return true;
 345 }
 346
 347
 348 namespace {
 349
 350 class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
 351  public:
 352   virtual void* Allocate(size_t length) {
 353     void* data = AllocateUninitialized(length);
 354     return data == NULL ? data : memset(data, 0, length);
 355   }
 356   virtual void* AllocateUninitialized(size_t length) { return malloc(length); }
 357   virtual void Free(void* data, size_t) { free(data); }
 358 };
 359
 360 }  // namespace
 361
 362
 363 StartupData V8::CreateSnapshotDataBlob(const char* custom_source) {
 364   i::Isolate* internal_isolate = new i::Isolate(true);
 365   ArrayBufferAllocator allocator;
 366   internal_isolate->set_array_buffer_allocator(&allocator);
 367   Isolate* isolate = reinterpret_cast<Isolate*>(internal_isolate);
 368   StartupData result = {NULL, 0};
 369   {
 370     base::ElapsedTimer timer;
 371     timer.Start();
 372     Isolate::Scope isolate_scope(isolate);
 373     internal_isolate->Init(NULL);
 374     Persistent<Context> context;
 375     i::Snapshot::Metadata metadata;
 376     {
 377       HandleScope handle_scope(isolate);
 378       Local<Context> new_context = Context::New(isolate);
 379       context.Reset(isolate, new_context);
 380       if (custom_source != NULL) {
 381         metadata.set_embeds_script(true);
 382         Context::Scope context_scope(new_context);
 383         if (!RunExtraCode(isolate, new_context, custom_source)) context.Reset();
 384       }
 385     }
 386     if (!context.IsEmpty()) {
 387       // If we don't do this then we end up with a stray root pointing at the
 388       // context even after we have disposed of the context.
 389       internal_isolate->heap()->CollectAllAvailableGarbage("mksnapshot");
 390
 391       // GC may have cleared weak cells, so compact any WeakFixedArrays
 392       // found on the heap.
 393       i::HeapIterator iterator(internal_isolate->heap(),
 394                                i::HeapIterator::kFilterUnreachable);
 395       for (i::HeapObject* o = iterator.next(); o != NULL; o = iterator.next()) {
 396         if (o->IsPrototypeInfo()) {
 397           i::Object* prototype_users =
 398               i::PrototypeInfo::cast(o)->prototype_users();
 399           if (prototype_users->IsWeakFixedArray()) {
 400             i::WeakFixedArray* array = i::WeakFixedArray::cast(prototype_users);
 401             array->Compact<i::JSObject::PrototypeRegistryCompactionCallback>();
 402           }
 403         } else if (o->IsScript()) {
 404           i::Object* shared_list = i::Script::cast(o)->shared_function_infos();
 405           if (shared_list->IsWeakFixedArray()) {
 406             i::WeakFixedArray* array = i::WeakFixedArray::cast(shared_list);
 407             array->Compact<i::WeakFixedArray::NullCallback>();
 408           }
 409         }
 410       }
 411
 412       i::Object* raw_context = *v8::Utils::OpenPersistent(context);
 413       context.Reset();
 414
 415       i::SnapshotByteSink snapshot_sink;
 416       i::StartupSerializer ser(internal_isolate, &snapshot_sink);
 417       ser.SerializeStrongReferences();
 418
 419       i::SnapshotByteSink context_sink;
 420       i::PartialSerializer context_ser(internal_isolate, &ser, &context_sink);
 421       context_ser.Serialize(&raw_context);
 422       ser.SerializeWeakReferencesAndDeferred();
 423
 424       result = i::Snapshot::CreateSnapshotBlob(ser, context_ser, metadata);
 425     }
 426     if (i::FLAG_profile_deserialization) {
 427       i::PrintF("Creating snapshot took %0.3f ms\n",
 428                 timer.Elapsed().InMillisecondsF());
 429     }
 430     timer.Stop();
 431   }
 432   isolate->Dispose();
 433   return result;
 434 }
 435
 436
 437 void V8::SetFlagsFromString(const char* str, int length) {
 438   i::FlagList::SetFlagsFromString(str, length);
 439 }
 440
 441
 442 void V8::SetFlagsFromCommandLine(int* argc, char** argv, bool remove_flags) {
 443   i::FlagList::SetFlagsFromCommandLine(argc, argv, remove_flags);
 444 }
 445
 446
 447 RegisteredExtension* RegisteredExtension::first_extension_ = NULL;
 448
 449
 450 RegisteredExtension::RegisteredExtension(Extension* extension)
 451     : extension_(extension) { }
 452
 453
 454 void RegisteredExtension::Register(RegisteredExtension* that) {
 455   that->next_ = first_extension_;
 456   first_extension_ = that;
 457 }
 458
 459
 460 void RegisteredExtension::UnregisterAll() {
 461   RegisteredExtension* re = first_extension_;
 462   while (re != NULL) {
 463     RegisteredExtension* next = re->next();
 464     delete re;
 465     re = next;
 466   }
 467   first_extension_ = NULL;
 468 }
 469
 470
 471 void RegisterExtension(Extension* that) {
 472   RegisteredExtension* extension = new RegisteredExtension(that);
 473   RegisteredExtension::Register(extension);
 474 }
 475
 476
 477 Extension::Extension(const char* name,
 478                      const char* source,
 479                      int dep_count,
 480                      const char** deps,
 481                      int source_length)
 482     : name_(name),
 483       source_length_(source_length >= 0 ?
 484                      source_length :
 485                      (source ? static_cast<int>(strlen(source)) : 0)),
 486       source_(source, source_length_),
 487       dep_count_(dep_count),
 488       deps_(deps),
 489       auto_enable_(false) {
 490   CHECK(source != NULL || source_length_ == 0);
 491 }
 492
 493
 494 ResourceConstraints::ResourceConstraints()
 495     : max_semi_space_size_(0),
 496       max_old_space_size_(0),
 497       max_executable_size_(0),
 498       stack_limit_(NULL),
 499       code_range_size_(0) { }
 500
 501 void ResourceConstraints::ConfigureDefaults(uint64_t physical_memory,
 502                                             uint64_t virtual_memory_limit) {
 503 #if V8_OS_ANDROID
 504   // Android has higher physical memory requirements before raising the maximum
 505   // heap size limits since it has no swap space.
 506   const uint64_t low_limit = 512ul * i::MB;
 507   const uint64_t medium_limit = 1ul * i::GB;
 508   const uint64_t high_limit = 2ul * i::GB;
 509 #else
 510   const uint64_t low_limit = 512ul * i::MB;
 511   const uint64_t medium_limit = 768ul * i::MB;
 512   const uint64_t high_limit = 1ul  * i::GB;
 513 #endif
 514
 515   if (physical_memory <= low_limit) {
 516     set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeLowMemoryDevice);
 517     set_max_old_space_size(i::Heap::kMaxOldSpaceSizeLowMemoryDevice);
 518     set_max_executable_size(i::Heap::kMaxExecutableSizeLowMemoryDevice);
 519   } else if (physical_memory <= medium_limit) {
 520     set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeMediumMemoryDevice);
 521     set_max_old_space_size(i::Heap::kMaxOldSpaceSizeMediumMemoryDevice);
 522     set_max_executable_size(i::Heap::kMaxExecutableSizeMediumMemoryDevice);
 523   } else if (physical_memory <= high_limit) {
 524     set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeHighMemoryDevice);
 525     set_max_old_space_size(i::Heap::kMaxOldSpaceSizeHighMemoryDevice);
 526     set_max_executable_size(i::Heap::kMaxExecutableSizeHighMemoryDevice);
 527   } else {
 528     set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeHugeMemoryDevice);
 529     set_max_old_space_size(i::Heap::kMaxOldSpaceSizeHugeMemoryDevice);
 530     set_max_executable_size(i::Heap::kMaxExecutableSizeHugeMemoryDevice);
 531   }
 532
 533   if (virtual_memory_limit > 0 && i::kRequiresCodeRange) {
 534     // Reserve no more than 1/8 of the memory for the code range, but at most
 535     // kMaximalCodeRangeSize.
 536     set_code_range_size(
 537         i::Min(i::kMaximalCodeRangeSize / i::MB,
 538                static_cast<size_t>((virtual_memory_limit >> 3) / i::MB)));
 539   }
 540 }
 541
 542
 543 void SetResourceConstraints(i::Isolate* isolate,
 544                             const ResourceConstraints& constraints) {
 545   int semi_space_size = constraints.max_semi_space_size();
 546   int old_space_size = constraints.max_old_space_size();
 547   int max_executable_size = constraints.max_executable_size();
 548   size_t code_range_size = constraints.code_range_size();
 549   if (semi_space_size != 0 || old_space_size != 0 ||
 550       max_executable_size != 0 || code_range_size != 0) {
 551     isolate->heap()->ConfigureHeap(semi_space_size, old_space_size,
 552                                    max_executable_size, code_range_size);
 553   }
 554   if (constraints.stack_limit() != NULL) {
 555     uintptr_t limit = reinterpret_cast<uintptr_t>(constraints.stack_limit());
 556     isolate->stack_guard()->SetStackLimit(limit);
 557   }
 558 }
 559
 560
 561 i::Object** V8::GlobalizeReference(i::Isolate* isolate, i::Object** obj) {
 562   LOG_API(isolate, "Persistent::New");
 563   i::Handle<i::Object> result = isolate->global_handles()->Create(*obj);
 564 #ifdef VERIFY_HEAP
 565   if (i::FLAG_verify_heap) {
 566     (*obj)->ObjectVerify();
 567   }
 568 #endif  // VERIFY_HEAP
 569   return result.location();
 570 }
 571
 572
 573 i::Object** V8::CopyPersistent(i::Object** obj) {
 574   i::Handle<i::Object> result = i::GlobalHandles::CopyGlobal(obj);
 575 #ifdef VERIFY_HEAP
 576   if (i::FLAG_verify_heap) {
 577     (*obj)->ObjectVerify();
 578   }
 579 #endif  // VERIFY_HEAP
 580   return result.location();
 581 }
 582
 583
 584 void V8::MakeWeak(i::Object** object, void* parameter,
 585                   WeakCallback weak_callback) {
 586   i::GlobalHandles::MakeWeak(object, parameter, weak_callback);
 587 }
 588
 589
 590 void V8::MakeWeak(i::Object** object, void* parameter,
 591                   int internal_field_index1, int internal_field_index2,
 592                   WeakCallbackInfo<void>::Callback weak_callback) {
 593   WeakCallbackType type = WeakCallbackType::kParameter;
 594   if (internal_field_index1 == 0) {
 595     if (internal_field_index2 == 1) {
 596       type = WeakCallbackType::kInternalFields;
 597     } else {
 598       DCHECK_EQ(internal_field_index2, -1);
 599       type = WeakCallbackType::kInternalFields;
 600     }
 601   } else {
 602     DCHECK_EQ(internal_field_index1, -1);
 603     DCHECK_EQ(internal_field_index2, -1);
 604   }
 605   i::GlobalHandles::MakeWeak(object, parameter, weak_callback, type);
 606 }
 607
 608
 609 void V8::MakeWeak(i::Object** object, void* parameter,
 610                   WeakCallbackInfo<void>::Callback weak_callback,
 611                   WeakCallbackType type) {
 612   i::GlobalHandles::MakeWeak(object, parameter, weak_callback, type);
 613 }
 614
 615
 616 void* V8::ClearWeak(i::Object** obj) {
 617   return i::GlobalHandles::ClearWeakness(obj);
 618 }
 619
 620
 621 void V8::DisposeGlobal(i::Object** obj) {
 622   i::GlobalHandles::Destroy(obj);
 623 }
 624
 625
 626 void V8::Eternalize(Isolate* v8_isolate, Value* value, int* index) {
 627   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
 628   i::Object* object = *Utils::OpenHandle(value);
 629   isolate->eternal_handles()->Create(isolate, object, index);
 630 }
 631
 632
 633 Local<Value> V8::GetEternal(Isolate* v8_isolate, int index) {
 634   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
 635   return Utils::ToLocal(isolate->eternal_handles()->Get(index));
 636 }
 637
 638
 639 void V8::FromJustIsNothing() {
 640   Utils::ApiCheck(false, "v8::FromJust", "Maybe value is Nothing.");
 641 }
 642
 643
 644 void V8::ToLocalEmpty() {
 645   Utils::ApiCheck(false, "v8::ToLocalChecked", "Empty MaybeLocal.");
 646 }
 647
 648
 649 void V8::InternalFieldOutOfBounds(int index) {
 650   Utils::ApiCheck(0 <= index && index < kInternalFieldsInWeakCallback,
 651                   "WeakCallbackInfo::GetInternalField",
 652                   "Internal field out of bounds.");
 653 }
 654
 655
 656 // --- H a n d l e s ---
 657
 658
 659 HandleScope::HandleScope(Isolate* isolate) {
 660   Initialize(isolate);
 661 }
 662
 663
 664 void HandleScope::Initialize(Isolate* isolate) {
 665   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
 666   // We do not want to check the correct usage of the Locker class all over the
 667   // place, so we do it only here: Without a HandleScope, an embedder can do
 668   // almost nothing, so it is enough to check in this central place.
 669   // We make an exception if the serializer is enabled, which means that the
 670   // Isolate is exclusively used to create a snapshot.
 671   Utils::ApiCheck(
 672       !v8::Locker::IsActive() ||
 673           internal_isolate->thread_manager()->IsLockedByCurrentThread() ||
 674           internal_isolate->serializer_enabled(),
 675       "HandleScope::HandleScope",
 676       "Entering the V8 API without proper locking in place");
 677   i::HandleScopeData* current = internal_isolate->handle_scope_data();
 678   isolate_ = internal_isolate;
 679   prev_next_ = current->next;
 680   prev_limit_ = current->limit;
 681   current->level++;
 682 }
 683
 684
 685 HandleScope::~HandleScope() {
 686   i::HandleScope::CloseScope(isolate_, prev_next_, prev_limit_);
 687 }
 688
 689
 690 int HandleScope::NumberOfHandles(Isolate* isolate) {
 691   return i::HandleScope::NumberOfHandles(
 692       reinterpret_cast<i::Isolate*>(isolate));
 693 }
 694
 695
 696 i::Object** HandleScope::CreateHandle(i::Isolate* isolate, i::Object* value) {
 697   return i::HandleScope::CreateHandle(isolate, value);
 698 }
 699
 700
 701 i::Object** HandleScope::CreateHandle(i::HeapObject* heap_object,
 702                                       i::Object* value) {
 703   DCHECK(heap_object->IsHeapObject());
 704   return i::HandleScope::CreateHandle(heap_object->GetIsolate(), value);
 705 }
 706
 707
 708 EscapableHandleScope::EscapableHandleScope(Isolate* v8_isolate) {
 709   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
 710   escape_slot_ = CreateHandle(isolate, isolate->heap()->the_hole_value());
 711   Initialize(v8_isolate);
 712 }
 713
 714
 715 i::Object** EscapableHandleScope::Escape(i::Object** escape_value) {
 716   i::Heap* heap = reinterpret_cast<i::Isolate*>(GetIsolate())->heap();
 717   Utils::ApiCheck(*escape_slot_ == heap->the_hole_value(),
 718                   "EscapeableHandleScope::Escape",
 719                   "Escape value set twice");
 720   if (escape_value == NULL) {
 721     *escape_slot_ = heap->undefined_value();
 722     return NULL;
 723   }
 724   *escape_slot_ = *escape_value;
 725   return escape_slot_;
 726 }
 727
 728
 729 SealHandleScope::SealHandleScope(Isolate* isolate) {
 730   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
 731
 732   isolate_ = internal_isolate;
 733   i::HandleScopeData* current = internal_isolate->handle_scope_data();
 734   prev_limit_ = current->limit;
 735   current->limit = current->next;
 736   prev_level_ = current->level;
 737   current->level = 0;
 738 }
 739
 740
 741 SealHandleScope::~SealHandleScope() {
 742   i::HandleScopeData* current = isolate_->handle_scope_data();
 743   DCHECK_EQ(0, current->level);
 744   current->level = prev_level_;
 745   DCHECK_EQ(current->next, current->limit);
 746   current->limit = prev_limit_;
 747 }
 748
 749
 750 void Context::Enter() {
 751   i::Handle<i::Context> env = Utils::OpenHandle(this);
 752   i::Isolate* isolate = env->GetIsolate();
 753   ENTER_V8(isolate);
 754   i::HandleScopeImplementer* impl = isolate->handle_scope_implementer();
 755   impl->EnterContext(env);
 756   impl->SaveContext(isolate->context());
 757   isolate->set_context(*env);
 758 }
 759
 760
 761 void Context::Exit() {
 762   i::Handle<i::Context> env = Utils::OpenHandle(this);
 763   i::Isolate* isolate = env->GetIsolate();
 764   ENTER_V8(isolate);
 765   i::HandleScopeImplementer* impl = isolate->handle_scope_implementer();
 766   if (!Utils::ApiCheck(impl->LastEnteredContextWas(env),
 767                        "v8::Context::Exit()",
 768                        "Cannot exit non-entered context")) {
 769     return;
 770   }
 771   impl->LeaveContext();
 772   isolate->set_context(impl->RestoreContext());
 773 }
 774
 775
 776 static void* DecodeSmiToAligned(i::Object* value, const char* location) {
 777   Utils::ApiCheck(value->IsSmi(), location, "Not a Smi");
 778   return reinterpret_cast<void*>(value);
 779 }
 780
 781
 782 static i::Smi* EncodeAlignedAsSmi(void* value, const char* location) {
 783   i::Smi* smi = reinterpret_cast<i::Smi*>(value);
 784   Utils::ApiCheck(smi->IsSmi(), location, "Pointer is not aligned");
 785   return smi;
 786 }
 787
 788
 789 static i::Handle<i::FixedArray> EmbedderDataFor(Context* context,
 790                                                 int index,
 791                                                 bool can_grow,
 792                                                 const char* location) {
 793   i::Handle<i::Context> env = Utils::OpenHandle(context);
 794   i::Isolate* isolate = env->GetIsolate();
 795   bool ok =
 796       Utils::ApiCheck(env->IsNativeContext(),
 797                       location,
 798                       "Not a native context") &&
 799       Utils::ApiCheck(index >= 0, location, "Negative index");
 800   if (!ok) return i::Handle<i::FixedArray>();
 801   i::Handle<i::FixedArray> data(env->embedder_data());
 802   if (index < data->length()) return data;
 803   if (!Utils::ApiCheck(can_grow, location, "Index too large")) {
 804     return i::Handle<i::FixedArray>();
 805   }
 806   int new_size = i::Max(index, data->length() << 1) + 1;
 807   int grow_by = new_size - data->length();
 808   data = isolate->factory()->CopyFixedArrayAndGrow(data, grow_by);
 809   env->set_embedder_data(*data);
 810   return data;
 811 }
 812
 813
 814 v8::Local<v8::Value> Context::SlowGetEmbedderData(int index) {
 815   const char* location = "v8::Context::GetEmbedderData()";
 816   i::Handle<i::FixedArray> data = EmbedderDataFor(this, index, false, location);
 817   if (data.is_null()) return Local<Value>();
 818   i::Handle<i::Object> result(data->get(index), data->GetIsolate());
 819   return Utils::ToLocal(result);
 820 }
 821
 822
 823 void Context::SetEmbedderData(int index, v8::Local<Value> value) {
 824   const char* location = "v8::Context::SetEmbedderData()";
 825   i::Handle<i::FixedArray> data = EmbedderDataFor(this, index, true, location);
 826   if (data.is_null()) return;
 827   i::Handle<i::Object> val = Utils::OpenHandle(*value);
 828   data->set(index, *val);
 829   DCHECK_EQ(*Utils::OpenHandle(*value),
 830             *Utils::OpenHandle(*GetEmbedderData(index)));
 831 }
 832
 833
 834 void* Context::SlowGetAlignedPointerFromEmbedderData(int index) {
 835   const char* location = "v8::Context::GetAlignedPointerFromEmbedderData()";
 836   i::Handle<i::FixedArray> data = EmbedderDataFor(this, index, false, location);
 837   if (data.is_null()) return NULL;
 838   return DecodeSmiToAligned(data->get(index), location);
 839 }
 840
 841
 842 void Context::SetAlignedPointerInEmbedderData(int index, void* value) {
 843   const char* location = "v8::Context::SetAlignedPointerInEmbedderData()";
 844   i::Handle<i::FixedArray> data = EmbedderDataFor(this, index, true, location);
 845   data->set(index, EncodeAlignedAsSmi(value, location));
 846   DCHECK_EQ(value, GetAlignedPointerFromEmbedderData(index));
 847 }
 848
 849
 850 // --- N e a n d e r ---
 851
 852
 853 // A constructor cannot easily return an error value, therefore it is necessary
 854 // to check for a dead VM with ON_BAILOUT before constructing any Neander
 855 // objects.  To remind you about this there is no HandleScope in the
 856 // NeanderObject constructor.  When you add one to the site calling the
 857 // constructor you should check that you ensured the VM was not dead first.
 858 NeanderObject::NeanderObject(v8::internal::Isolate* isolate, int size) {
 859   ENTER_V8(isolate);
 860   value_ = isolate->factory()->NewNeanderObject();
 861   i::Handle<i::FixedArray> elements = isolate->factory()->NewFixedArray(size);
 862   value_->set_elements(*elements);
 863 }
 864
 865
 866 int NeanderObject::size() {
 867   return i::FixedArray::cast(value_->elements())->length();
 868 }
 869
 870
 871 NeanderArray::NeanderArray(v8::internal::Isolate* isolate) : obj_(isolate, 2) {
 872   obj_.set(0, i::Smi::FromInt(0));
 873 }
 874
 875
 876 int NeanderArray::length() {
 877   return i::Smi::cast(obj_.get(0))->value();
 878 }
 879
 880
 881 i::Object* NeanderArray::get(int offset) {
 882   DCHECK(0 <= offset);
 883   DCHECK(offset < length());
 884   return obj_.get(offset + 1);
 885 }
 886
 887
 888 // This method cannot easily return an error value, therefore it is necessary
 889 // to check for a dead VM with ON_BAILOUT before calling it.  To remind you
 890 // about this there is no HandleScope in this method.  When you add one to the
 891 // site calling this method you should check that you ensured the VM was not
 892 // dead first.
 893 void NeanderArray::add(i::Isolate* isolate, i::Handle<i::Object> value) {
 894   int length = this->length();
 895   int size = obj_.size();
 896   if (length == size - 1) {
 897     i::Factory* factory = isolate->factory();
 898     i::Handle<i::FixedArray> new_elms = factory->NewFixedArray(2 * size);
 899     for (int i = 0; i < length; i++)
 900       new_elms->set(i + 1, get(i));
 901     obj_.value()->set_elements(*new_elms);
 902   }
 903   obj_.set(length + 1, *value);
 904   obj_.set(0, i::Smi::FromInt(length + 1));
 905 }
 906
 907
 908 void NeanderArray::set(int index, i::Object* value) {
 909   if (index < 0 || index >= this->length()) return;
 910   obj_.set(index + 1, value);
 911 }
 912
 913
 914 // --- T e m p l a t e ---
 915
 916
 917 static void InitializeTemplate(i::Handle<i::TemplateInfo> that, int type) {
 918   that->set_number_of_properties(0);
 919   that->set_tag(i::Smi::FromInt(type));
 920 }
 921
 922
 923 void Template::Set(v8::Local<Name> name, v8::Local<Data> value,
 924                    v8::PropertyAttribute attribute) {
 925   auto templ = Utils::OpenHandle(this);
 926   i::Isolate* isolate = templ->GetIsolate();
 927   ENTER_V8(isolate);
 928   i::HandleScope scope(isolate);
 929   // TODO(dcarney): split api to allow values of v8::Value or v8::TemplateInfo.
 930   i::ApiNatives::AddDataProperty(isolate, templ, Utils::OpenHandle(*name),
 931                                  Utils::OpenHandle(*value),
 932                                  static_cast<PropertyAttributes>(attribute));
 933 }
 934
 935
 936 void Template::SetAccessorProperty(
 937     v8::Local<v8::Name> name,
 938     v8::Local<FunctionTemplate> getter,
 939     v8::Local<FunctionTemplate> setter,
 940     v8::PropertyAttribute attribute,
 941     v8::AccessControl access_control) {
 942   // TODO(verwaest): Remove |access_control|.
 943   DCHECK_EQ(v8::DEFAULT, access_control);
 944   auto templ = Utils::OpenHandle(this);
 945   auto isolate = templ->GetIsolate();
 946   ENTER_V8(isolate);
 947   DCHECK(!name.IsEmpty());
 948   DCHECK(!getter.IsEmpty() || !setter.IsEmpty());
 949   i::HandleScope scope(isolate);
 950   i::ApiNatives::AddAccessorProperty(
 951       isolate, templ, Utils::OpenHandle(*name),
 952       Utils::OpenHandle(*getter, true), Utils::OpenHandle(*setter, true),
 953       static_cast<PropertyAttributes>(attribute));
 954 }
 955
 956
 957 // --- F u n c t i o n   T e m p l a t e ---
 958 static void InitializeFunctionTemplate(
 959     i::Handle<i::FunctionTemplateInfo> info) {
 960   InitializeTemplate(info, Consts::FUNCTION_TEMPLATE);
 961   info->set_flag(0);
 962 }
 963
 964
 965 Local<ObjectTemplate> FunctionTemplate::PrototypeTemplate() {
 966   i::Isolate* i_isolate = Utils::OpenHandle(this)->GetIsolate();
 967   ENTER_V8(i_isolate);
 968   i::Handle<i::Object> result(Utils::OpenHandle(this)->prototype_template(),
 969                               i_isolate);
 970   if (result->IsUndefined()) {
 971     v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(i_isolate);
 972     result = Utils::OpenHandle(*ObjectTemplate::New(isolate));
 973     Utils::OpenHandle(this)->set_prototype_template(*result);
 974   }
 975   return ToApiHandle<ObjectTemplate>(result);
 976 }
 977
 978
 979 static void EnsureNotInstantiated(i::Handle<i::FunctionTemplateInfo> info,
 980                                   const char* func) {
 981   Utils::ApiCheck(!info->instantiated(), func,
 982                   "FunctionTemplate already instantiated");
 983 }
 984
 985
 986 void FunctionTemplate::Inherit(v8::Local<FunctionTemplate> value) {
 987   auto info = Utils::OpenHandle(this);
 988   EnsureNotInstantiated(info, "v8::FunctionTemplate::Inherit");
 989   i::Isolate* isolate = info->GetIsolate();
 990   ENTER_V8(isolate);
 991   info->set_parent_template(*Utils::OpenHandle(*value));
 992 }
 993
 994
 995 static Local<FunctionTemplate> FunctionTemplateNew(
 996     i::Isolate* isolate, FunctionCallback callback, v8::Local<Value> data,
 997     v8::Local<Signature> signature, int length, bool do_not_cache) {
 998   i::Handle<i::Struct> struct_obj =
 999       isolate->factory()->NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE);
1000   i::Handle<i::FunctionTemplateInfo> obj =
1001       i::Handle<i::FunctionTemplateInfo>::cast(struct_obj);
1002   InitializeFunctionTemplate(obj);
1003   obj->set_do_not_cache(do_not_cache);
1004   int next_serial_number = 0;
1005   if (!do_not_cache) {
1006     next_serial_number = isolate->next_serial_number() + 1;
1007     isolate->set_next_serial_number(next_serial_number);
1008   }
1009   obj->set_serial_number(i::Smi::FromInt(next_serial_number));
1010   if (callback != 0) {
1011     if (data.IsEmpty()) {
1012       data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1013     }
1014     Utils::ToLocal(obj)->SetCallHandler(callback, data);
1015   }
1016   obj->set_length(length);
1017   obj->set_undetectable(false);
1018   obj->set_needs_access_check(false);
1019   obj->set_accept_any_receiver(true);
1020   if (!signature.IsEmpty())
1021     obj->set_signature(*Utils::OpenHandle(*signature));
1022   return Utils::ToLocal(obj);
1023 }
1024
1025 Local<FunctionTemplate> FunctionTemplate::New(Isolate* isolate,
1026                                               FunctionCallback callback,
1027                                               v8::Local<Value> data,
1028                                               v8::Local<Signature> signature,
1029                                               int length) {
1030   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
1031   // Changes to the environment cannot be captured in the snapshot. Expect no
1032   // function templates when the isolate is created for serialization.
1033   DCHECK(!i_isolate->serializer_enabled());
1034   LOG_API(i_isolate, "FunctionTemplate::New");
1035   ENTER_V8(i_isolate);
1036   return FunctionTemplateNew(
1037       i_isolate, callback, data, signature, length, false);
1038 }
1039
1040
1041 Local<Signature> Signature::New(Isolate* isolate,
1042                                 Local<FunctionTemplate> receiver) {
1043   return Utils::SignatureToLocal(Utils::OpenHandle(*receiver));
1044 }
1045
1046
1047 Local<AccessorSignature> AccessorSignature::New(
1048     Isolate* isolate, Local<FunctionTemplate> receiver) {
1049   return Utils::AccessorSignatureToLocal(Utils::OpenHandle(*receiver));
1050 }
1051
1052
1053 Local<TypeSwitch> TypeSwitch::New(Local<FunctionTemplate> type) {
1054   Local<FunctionTemplate> types[1] = {type};
1055   return TypeSwitch::New(1, types);
1056 }
1057
1058
1059 Local<TypeSwitch> TypeSwitch::New(int argc, Local<FunctionTemplate> types[]) {
1060   i::Isolate* isolate = i::Isolate::Current();
1061   LOG_API(isolate, "TypeSwitch::New");
1062   ENTER_V8(isolate);
1063   i::Handle<i::FixedArray> vector = isolate->factory()->NewFixedArray(argc);
1064   for (int i = 0; i < argc; i++)
1065     vector->set(i, *Utils::OpenHandle(*types[i]));
1066   i::Handle<i::Struct> struct_obj =
1067       isolate->factory()->NewStruct(i::TYPE_SWITCH_INFO_TYPE);
1068   i::Handle<i::TypeSwitchInfo> obj =
1069       i::Handle<i::TypeSwitchInfo>::cast(struct_obj);
1070   obj->set_types(*vector);
1071   return Utils::ToLocal(obj);
1072 }
1073
1074
1075 int TypeSwitch::match(v8::Local<Value> value) {
1076   i::Handle<i::TypeSwitchInfo> info = Utils::OpenHandle(this);
1077   LOG_API(info->GetIsolate(), "TypeSwitch::match");
1078   i::Handle<i::Object> obj = Utils::OpenHandle(*value);
1079   i::FixedArray* types = i::FixedArray::cast(info->types());
1080   for (int i = 0; i < types->length(); i++) {
1081     if (i::FunctionTemplateInfo::cast(types->get(i))->IsTemplateFor(*obj))
1082       return i + 1;
1083   }
1084   return 0;
1085 }
1086
1087
1088 #define SET_FIELD_WRAPPED(obj, setter, cdata) do {                      \
1089     i::Handle<i::Object> foreign = FromCData(obj->GetIsolate(), cdata); \
1090     (obj)->setter(*foreign);                                            \
1091   } while (false)
1092
1093
1094 void FunctionTemplate::SetCallHandler(FunctionCallback callback,
1095                                       v8::Local<Value> data) {
1096   auto info = Utils::OpenHandle(this);
1097   EnsureNotInstantiated(info, "v8::FunctionTemplate::SetCallHandler");
1098   i::Isolate* isolate = info->GetIsolate();
1099   ENTER_V8(isolate);
1100   i::HandleScope scope(isolate);
1101   i::Handle<i::Struct> struct_obj =
1102       isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE);
1103   i::Handle<i::CallHandlerInfo> obj =
1104       i::Handle<i::CallHandlerInfo>::cast(struct_obj);
1105   SET_FIELD_WRAPPED(obj, set_callback, callback);
1106   if (data.IsEmpty()) {
1107     data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1108   }
1109   obj->set_data(*Utils::OpenHandle(*data));
1110   info->set_call_code(*obj);
1111 }
1112
1113
1114 static i::Handle<i::AccessorInfo> SetAccessorInfoProperties(
1115     i::Handle<i::AccessorInfo> obj, v8::Local<Name> name,
1116     v8::AccessControl settings, v8::PropertyAttribute attributes,
1117     v8::Local<AccessorSignature> signature) {
1118   obj->set_name(*Utils::OpenHandle(*name));
1119   if (settings & ALL_CAN_READ) obj->set_all_can_read(true);
1120   if (settings & ALL_CAN_WRITE) obj->set_all_can_write(true);
1121   obj->set_property_attributes(static_cast<PropertyAttributes>(attributes));
1122   if (!signature.IsEmpty()) {
1123     obj->set_expected_receiver_type(*Utils::OpenHandle(*signature));
1124   }
1125   return obj;
1126 }
1127
1128
1129 template <typename Getter, typename Setter>
1130 static i::Handle<i::AccessorInfo> MakeAccessorInfo(
1131     v8::Local<Name> name, Getter getter, Setter setter, v8::Local<Value> data,
1132     v8::AccessControl settings, v8::PropertyAttribute attributes,
1133     v8::Local<AccessorSignature> signature) {
1134   i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate();
1135   i::Handle<i::ExecutableAccessorInfo> obj =
1136       isolate->factory()->NewExecutableAccessorInfo();
1137   SET_FIELD_WRAPPED(obj, set_getter, getter);
1138   SET_FIELD_WRAPPED(obj, set_setter, setter);
1139   if (data.IsEmpty()) {
1140     data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1141   }
1142   obj->set_data(*Utils::OpenHandle(*data));
1143   return SetAccessorInfoProperties(obj, name, settings, attributes, signature);
1144 }
1145
1146
1147 Local<ObjectTemplate> FunctionTemplate::InstanceTemplate() {
1148   i::Handle<i::FunctionTemplateInfo> handle = Utils::OpenHandle(this, true);
1149   if (!Utils::ApiCheck(!handle.is_null(),
1150                        "v8::FunctionTemplate::InstanceTemplate()",
1151                        "Reading from empty handle")) {
1152     return Local<ObjectTemplate>();
1153   }
1154   i::Isolate* isolate = handle->GetIsolate();
1155   ENTER_V8(isolate);
1156   if (handle->instance_template()->IsUndefined()) {
1157     Local<ObjectTemplate> templ =
1158         ObjectTemplate::New(isolate, ToApiHandle<FunctionTemplate>(handle));
1159     handle->set_instance_template(*Utils::OpenHandle(*templ));
1160   }
1161   i::Handle<i::ObjectTemplateInfo> result(
1162       i::ObjectTemplateInfo::cast(handle->instance_template()));
1163   return Utils::ToLocal(result);
1164 }
1165
1166
1167 void FunctionTemplate::SetLength(int length) {
1168   auto info = Utils::OpenHandle(this);
1169   EnsureNotInstantiated(info, "v8::FunctionTemplate::SetLength");
1170   auto isolate = info->GetIsolate();
1171   ENTER_V8(isolate);
1172   info->set_length(length);
1173 }
1174
1175
1176 void FunctionTemplate::SetClassName(Local<String> name) {
1177   auto info = Utils::OpenHandle(this);
1178   EnsureNotInstantiated(info, "v8::FunctionTemplate::SetClassName");
1179   auto isolate = info->GetIsolate();
1180   ENTER_V8(isolate);
1181   info->set_class_name(*Utils::OpenHandle(*name));
1182 }
1183
1184
1185 void FunctionTemplate::SetAcceptAnyReceiver(bool value) {
1186   auto info = Utils::OpenHandle(this);
1187   EnsureNotInstantiated(info, "v8::FunctionTemplate::SetAcceptAnyReceiver");
1188   auto isolate = info->GetIsolate();
1189   ENTER_V8(isolate);
1190   info->set_accept_any_receiver(value);
1191 }
1192
1193
1194 void FunctionTemplate::SetHiddenPrototype(bool value) {
1195   auto info = Utils::OpenHandle(this);
1196   EnsureNotInstantiated(info, "v8::FunctionTemplate::SetHiddenPrototype");
1197   auto isolate = info->GetIsolate();
1198   ENTER_V8(isolate);
1199   info->set_hidden_prototype(value);
1200 }
1201
1202
1203 void FunctionTemplate::ReadOnlyPrototype() {
1204   auto info = Utils::OpenHandle(this);
1205   EnsureNotInstantiated(info, "v8::FunctionTemplate::ReadOnlyPrototype");
1206   auto isolate = info->GetIsolate();
1207   ENTER_V8(isolate);
1208   info->set_read_only_prototype(true);
1209 }
1210
1211
1212 void FunctionTemplate::RemovePrototype() {
1213   auto info = Utils::OpenHandle(this);
1214   EnsureNotInstantiated(info, "v8::FunctionTemplate::RemovePrototype");
1215   auto isolate = info->GetIsolate();
1216   ENTER_V8(isolate);
1217   info->set_remove_prototype(true);
1218 }
1219
1220
1221 // --- O b j e c t T e m p l a t e ---
1222
1223
1224 Local<ObjectTemplate> ObjectTemplate::New(
1225     Isolate* isolate, v8::Local<FunctionTemplate> constructor) {
1226   return New(reinterpret_cast<i::Isolate*>(isolate), constructor);
1227 }
1228
1229
1230 Local<ObjectTemplate> ObjectTemplate::New() {
1231   return New(i::Isolate::Current(), Local<FunctionTemplate>());
1232 }
1233
1234
1235 Local<ObjectTemplate> ObjectTemplate::New(
1236     i::Isolate* isolate, v8::Local<FunctionTemplate> constructor) {
1237   // Changes to the environment cannot be captured in the snapshot. Expect no
1238   // object templates when the isolate is created for serialization.
1239   DCHECK(!isolate->serializer_enabled());
1240   LOG_API(isolate, "ObjectTemplate::New");
1241   ENTER_V8(isolate);
1242   i::Handle<i::Struct> struct_obj =
1243       isolate->factory()->NewStruct(i::OBJECT_TEMPLATE_INFO_TYPE);
1244   i::Handle<i::ObjectTemplateInfo> obj =
1245       i::Handle<i::ObjectTemplateInfo>::cast(struct_obj);
1246   InitializeTemplate(obj, Consts::OBJECT_TEMPLATE);
1247   if (!constructor.IsEmpty())
1248     obj->set_constructor(*Utils::OpenHandle(*constructor));
1249   obj->set_internal_field_count(i::Smi::FromInt(0));
1250   return Utils::ToLocal(obj);
1251 }
1252
1253
1254 // Ensure that the object template has a constructor.  If no
1255 // constructor is available we create one.
1256 static i::Handle<i::FunctionTemplateInfo> EnsureConstructor(
1257     i::Isolate* isolate,
1258     ObjectTemplate* object_template) {
1259   i::Object* obj = Utils::OpenHandle(object_template)->constructor();
1260   if (!obj ->IsUndefined()) {
1261     i::FunctionTemplateInfo* info = i::FunctionTemplateInfo::cast(obj);
1262     return i::Handle<i::FunctionTemplateInfo>(info, isolate);
1263   }
1264   Local<FunctionTemplate> templ =
1265       FunctionTemplate::New(reinterpret_cast<Isolate*>(isolate));
1266   i::Handle<i::FunctionTemplateInfo> constructor = Utils::OpenHandle(*templ);
1267   constructor->set_instance_template(*Utils::OpenHandle(object_template));
1268   Utils::OpenHandle(object_template)->set_constructor(*constructor);
1269   return constructor;
1270 }
1271
1272
1273 static inline i::Handle<i::TemplateInfo> GetTemplateInfo(
1274     i::Isolate* isolate,
1275     Template* template_obj) {
1276   return Utils::OpenHandle(template_obj);
1277 }
1278
1279
1280 // TODO(dcarney): remove this with ObjectTemplate::SetAccessor
1281 static inline i::Handle<i::TemplateInfo> GetTemplateInfo(
1282     i::Isolate* isolate,
1283     ObjectTemplate* object_template) {
1284   EnsureConstructor(isolate, object_template);
1285   return Utils::OpenHandle(object_template);
1286 }
1287
1288
1289 template<typename Getter, typename Setter, typename Data, typename Template>
1290 static bool TemplateSetAccessor(
1291     Template* template_obj,
1292     v8::Local<Name> name,
1293     Getter getter,
1294     Setter setter,
1295     Data data,
1296     AccessControl settings,
1297     PropertyAttribute attribute,
1298     v8::Local<AccessorSignature> signature) {
1299   auto isolate = Utils::OpenHandle(template_obj)->GetIsolate();
1300   ENTER_V8(isolate);
1301   i::HandleScope scope(isolate);
1302   auto obj = MakeAccessorInfo(name, getter, setter, data, settings, attribute,
1303                               signature);
1304   if (obj.is_null()) return false;
1305   auto info = GetTemplateInfo(isolate, template_obj);
1306   i::ApiNatives::AddNativeDataProperty(isolate, info, obj);
1307   return true;
1308 }
1309
1310
1311 void Template::SetNativeDataProperty(v8::Local<String> name,
1312                                      AccessorGetterCallback getter,
1313                                      AccessorSetterCallback setter,
1314                                      v8::Local<Value> data,
1315                                      PropertyAttribute attribute,
1316                                      v8::Local<AccessorSignature> signature,
1317                                      AccessControl settings) {
1318   TemplateSetAccessor(
1319       this, name, getter, setter, data, settings, attribute, signature);
1320 }
1321
1322
1323 void Template::SetNativeDataProperty(v8::Local<Name> name,
1324                                      AccessorNameGetterCallback getter,
1325                                      AccessorNameSetterCallback setter,
1326                                      v8::Local<Value> data,
1327                                      PropertyAttribute attribute,
1328                                      v8::Local<AccessorSignature> signature,
1329                                      AccessControl settings) {
1330   TemplateSetAccessor(
1331       this, name, getter, setter, data, settings, attribute, signature);
1332 }
1333
1334
1335 void ObjectTemplate::SetAccessor(v8::Local<String> name,
1336                                  AccessorGetterCallback getter,
1337                                  AccessorSetterCallback setter,
1338                                  v8::Local<Value> data, AccessControl settings,
1339                                  PropertyAttribute attribute,
1340                                  v8::Local<AccessorSignature> signature) {
1341   TemplateSetAccessor(
1342       this, name, getter, setter, data, settings, attribute, signature);
1343 }
1344
1345
1346 void ObjectTemplate::SetAccessor(v8::Local<Name> name,
1347                                  AccessorNameGetterCallback getter,
1348                                  AccessorNameSetterCallback setter,
1349                                  v8::Local<Value> data, AccessControl settings,
1350                                  PropertyAttribute attribute,
1351                                  v8::Local<AccessorSignature> signature) {
1352   TemplateSetAccessor(
1353       this, name, getter, setter, data, settings, attribute, signature);
1354 }
1355
1356
1357 template <typename Getter, typename Setter, typename Query, typename Deleter,
1358           typename Enumerator>
1359 static void ObjectTemplateSetNamedPropertyHandler(ObjectTemplate* templ,
1360                                                   Getter getter, Setter setter,
1361                                                   Query query, Deleter remover,
1362                                                   Enumerator enumerator,
1363                                                   Local<Value> data,
1364                                                   PropertyHandlerFlags flags) {
1365   i::Isolate* isolate = Utils::OpenHandle(templ)->GetIsolate();
1366   ENTER_V8(isolate);
1367   i::HandleScope scope(isolate);
1368   auto cons = EnsureConstructor(isolate, templ);
1369   EnsureNotInstantiated(cons, "ObjectTemplateSetNamedPropertyHandler");
1370   auto obj = i::Handle<i::InterceptorInfo>::cast(
1371       isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE));
1372
1373   if (getter != 0) SET_FIELD_WRAPPED(obj, set_getter, getter);
1374   if (setter != 0) SET_FIELD_WRAPPED(obj, set_setter, setter);
1375   if (query != 0) SET_FIELD_WRAPPED(obj, set_query, query);
1376   if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover);
1377   if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator);
1378   obj->set_flags(0);
1379   obj->set_can_intercept_symbols(
1380       !(static_cast<int>(flags) &
1381         static_cast<int>(PropertyHandlerFlags::kOnlyInterceptStrings)));
1382   obj->set_all_can_read(static_cast<int>(flags) &
1383                         static_cast<int>(PropertyHandlerFlags::kAllCanRead));
1384   obj->set_non_masking(static_cast<int>(flags) &
1385                        static_cast<int>(PropertyHandlerFlags::kNonMasking));
1386
1387   if (data.IsEmpty()) {
1388     data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1389   }
1390   obj->set_data(*Utils::OpenHandle(*data));
1391   cons->set_named_property_handler(*obj);
1392 }
1393
1394
1395 void ObjectTemplate::SetNamedPropertyHandler(
1396     NamedPropertyGetterCallback getter, NamedPropertySetterCallback setter,
1397     NamedPropertyQueryCallback query, NamedPropertyDeleterCallback remover,
1398     NamedPropertyEnumeratorCallback enumerator, Local<Value> data) {
1399   ObjectTemplateSetNamedPropertyHandler(
1400       this, getter, setter, query, remover, enumerator, data,
1401       PropertyHandlerFlags::kOnlyInterceptStrings);
1402 }
1403
1404
1405 void ObjectTemplate::SetHandler(
1406     const NamedPropertyHandlerConfiguration& config) {
1407   ObjectTemplateSetNamedPropertyHandler(
1408       this, config.getter, config.setter, config.query, config.deleter,
1409       config.enumerator, config.data, config.flags);
1410 }
1411
1412
1413 void ObjectTemplate::MarkAsUndetectable() {
1414   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
1415   ENTER_V8(isolate);
1416   i::HandleScope scope(isolate);
1417   auto cons = EnsureConstructor(isolate, this);
1418   EnsureNotInstantiated(cons, "v8::ObjectTemplate::MarkAsUndetectable");
1419   cons->set_undetectable(true);
1420 }
1421
1422
1423 void ObjectTemplate::SetAccessCheckCallbacks(
1424     NamedSecurityCallback named_callback,
1425     IndexedSecurityCallback indexed_callback, Local<Value> data) {
1426   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
1427   ENTER_V8(isolate);
1428   i::HandleScope scope(isolate);
1429   auto cons = EnsureConstructor(isolate, this);
1430   EnsureNotInstantiated(cons, "v8::ObjectTemplate::SetAccessCheckCallbacks");
1431
1432   i::Handle<i::Struct> struct_info =
1433       isolate->factory()->NewStruct(i::ACCESS_CHECK_INFO_TYPE);
1434   i::Handle<i::AccessCheckInfo> info =
1435       i::Handle<i::AccessCheckInfo>::cast(struct_info);
1436
1437   SET_FIELD_WRAPPED(info, set_named_callback, named_callback);
1438   SET_FIELD_WRAPPED(info, set_indexed_callback, indexed_callback);
1439
1440   if (data.IsEmpty()) {
1441     data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1442   }
1443   info->set_data(*Utils::OpenHandle(*data));
1444
1445   cons->set_access_check_info(*info);
1446   cons->set_needs_access_check(true);
1447 }
1448
1449
1450 void ObjectTemplate::SetHandler(
1451     const IndexedPropertyHandlerConfiguration& config) {
1452   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
1453   ENTER_V8(isolate);
1454   i::HandleScope scope(isolate);
1455   auto cons = EnsureConstructor(isolate, this);
1456   EnsureNotInstantiated(cons, "v8::ObjectTemplate::SetHandler");
1457   auto obj = i::Handle<i::InterceptorInfo>::cast(
1458       isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE));
1459
1460   if (config.getter != 0) SET_FIELD_WRAPPED(obj, set_getter, config.getter);
1461   if (config.setter != 0) SET_FIELD_WRAPPED(obj, set_setter, config.setter);
1462   if (config.query != 0) SET_FIELD_WRAPPED(obj, set_query, config.query);
1463   if (config.deleter != 0) SET_FIELD_WRAPPED(obj, set_deleter, config.deleter);
1464   if (config.enumerator != 0) {
1465     SET_FIELD_WRAPPED(obj, set_enumerator, config.enumerator);
1466   }
1467   obj->set_flags(0);
1468   obj->set_all_can_read(static_cast<int>(config.flags) &
1469                         static_cast<int>(PropertyHandlerFlags::kAllCanRead));
1470
1471   v8::Local<v8::Value> data = config.data;
1472   if (data.IsEmpty()) {
1473     data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1474   }
1475   obj->set_data(*Utils::OpenHandle(*data));
1476   cons->set_indexed_property_handler(*obj);
1477 }
1478
1479
1480 void ObjectTemplate::SetCallAsFunctionHandler(FunctionCallback callback,
1481                                               Local<Value> data) {
1482   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
1483   ENTER_V8(isolate);
1484   i::HandleScope scope(isolate);
1485   auto cons = EnsureConstructor(isolate, this);
1486   EnsureNotInstantiated(cons, "v8::ObjectTemplate::SetCallAsFunctionHandler");
1487   i::Handle<i::Struct> struct_obj =
1488       isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE);
1489   i::Handle<i::CallHandlerInfo> obj =
1490       i::Handle<i::CallHandlerInfo>::cast(struct_obj);
1491   SET_FIELD_WRAPPED(obj, set_callback, callback);
1492   if (data.IsEmpty()) {
1493     data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1494   }
1495   obj->set_data(*Utils::OpenHandle(*data));
1496   cons->set_instance_call_handler(*obj);
1497 }
1498
1499
1500 int ObjectTemplate::InternalFieldCount() {
1501   return i::Smi::cast(Utils::OpenHandle(this)->internal_field_count())->value();
1502 }
1503
1504
1505 void ObjectTemplate::SetInternalFieldCount(int value) {
1506   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
1507   if (!Utils::ApiCheck(i::Smi::IsValid(value),
1508                        "v8::ObjectTemplate::SetInternalFieldCount()",
1509                        "Invalid internal field count")) {
1510     return;
1511   }
1512   ENTER_V8(isolate);
1513   if (value > 0) {
1514     // The internal field count is set by the constructor function's
1515     // construct code, so we ensure that there is a constructor
1516     // function to do the setting.
1517     EnsureConstructor(isolate, this);
1518   }
1519   Utils::OpenHandle(this)->set_internal_field_count(i::Smi::FromInt(value));
1520 }
1521
1522
1523 // --- S c r i p t s ---
1524
1525
1526 // Internally, UnboundScript is a SharedFunctionInfo, and Script is a
1527 // JSFunction.
1528
1529 ScriptCompiler::CachedData::CachedData(const uint8_t* data_, int length_,
1530                                        BufferPolicy buffer_policy_)
1531     : data(data_),
1532       length(length_),
1533       rejected(false),
1534       buffer_policy(buffer_policy_) {}
1535
1536
1537 ScriptCompiler::CachedData::~CachedData() {
1538   if (buffer_policy == BufferOwned) {
1539     delete[] data;
1540   }
1541 }
1542
1543
1544 bool ScriptCompiler::ExternalSourceStream::SetBookmark() { return false; }
1545
1546
1547 void ScriptCompiler::ExternalSourceStream::ResetToBookmark() { UNREACHABLE(); }
1548
1549
1550 ScriptCompiler::StreamedSource::StreamedSource(ExternalSourceStream* stream,
1551                                                Encoding encoding)
1552     : impl_(new i::StreamedSource(stream, encoding)) {}
1553
1554
1555 ScriptCompiler::StreamedSource::~StreamedSource() { delete impl_; }
1556
1557
1558 const ScriptCompiler::CachedData*
1559 ScriptCompiler::StreamedSource::GetCachedData() const {
1560   return impl_->cached_data.get();
1561 }
1562
1563
1564 Local<Script> UnboundScript::BindToCurrentContext() {
1565   i::Handle<i::HeapObject> obj =
1566       i::Handle<i::HeapObject>::cast(Utils::OpenHandle(this));
1567   i::Handle<i::SharedFunctionInfo>
1568       function_info(i::SharedFunctionInfo::cast(*obj), obj->GetIsolate());
1569   i::Isolate* isolate = obj->GetIsolate();
1570
1571   i::ScopeInfo* scope_info = function_info->scope_info();
1572   i::Handle<i::JSReceiver> global(isolate->native_context()->global_object());
1573   for (int i = 0; i < scope_info->StrongModeFreeVariableCount(); ++i) {
1574     i::Handle<i::String> name_string(scope_info->StrongModeFreeVariableName(i));
1575     i::ScriptContextTable::LookupResult result;
1576     i::Handle<i::ScriptContextTable> script_context_table(
1577         isolate->native_context()->script_context_table());
1578     if (!i::ScriptContextTable::Lookup(script_context_table, name_string,
1579                                        &result)) {
1580       i::Handle<i::Name> name(scope_info->StrongModeFreeVariableName(i));
1581       Maybe<bool> has = i::JSReceiver::HasProperty(global, name);
1582       if (has.IsJust() && !has.FromJust()) {
1583         i::PendingCompilationErrorHandler pending_error_handler_;
1584         pending_error_handler_.ReportMessageAt(
1585             scope_info->StrongModeFreeVariableStartPosition(i),
1586             scope_info->StrongModeFreeVariableEndPosition(i),
1587             i::MessageTemplate::kStrongUnboundGlobal, name_string,
1588             i::kReferenceError);
1589         i::Handle<i::Script> script(i::Script::cast(function_info->script()));
1590         pending_error_handler_.ThrowPendingError(isolate, script);
1591         isolate->ReportPendingMessages();
1592         isolate->OptionalRescheduleException(true);
1593         return Local<Script>();
1594       }
1595     }
1596   }
1597   i::Handle<i::JSFunction> function =
1598       obj->GetIsolate()->factory()->NewFunctionFromSharedFunctionInfo(
1599           function_info, isolate->native_context());
1600   return ToApiHandle<Script>(function);
1601 }
1602
1603
1604 int UnboundScript::GetId() {
1605   i::Handle<i::HeapObject> obj =
1606       i::Handle<i::HeapObject>::cast(Utils::OpenHandle(this));
1607   i::Isolate* isolate = obj->GetIsolate();
1608   LOG_API(isolate, "v8::UnboundScript::GetId");
1609   i::HandleScope scope(isolate);
1610   i::Handle<i::SharedFunctionInfo> function_info(
1611       i::SharedFunctionInfo::cast(*obj));
1612   i::Handle<i::Script> script(i::Script::cast(function_info->script()));
1613   return script->id()->value();
1614 }
1615
1616
1617 int UnboundScript::GetLineNumber(int code_pos) {
1618   i::Handle<i::SharedFunctionInfo> obj =
1619       i::Handle<i::SharedFunctionInfo>::cast(Utils::OpenHandle(this));
1620   i::Isolate* isolate = obj->GetIsolate();
1621   LOG_API(isolate, "UnboundScript::GetLineNumber");
1622   if (obj->script()->IsScript()) {
1623     i::Handle<i::Script> script(i::Script::cast(obj->script()));
1624     return i::Script::GetLineNumber(script, code_pos);
1625   } else {
1626     return -1;
1627   }
1628 }
1629
1630
1631 Local<Value> UnboundScript::GetScriptName() {
1632   i::Handle<i::SharedFunctionInfo> obj =
1633       i::Handle<i::SharedFunctionInfo>::cast(Utils::OpenHandle(this));
1634   i::Isolate* isolate = obj->GetIsolate();
1635   LOG_API(isolate, "UnboundScript::GetName");
1636   if (obj->script()->IsScript()) {
1637     i::Object* name = i::Script::cast(obj->script())->name();
1638     return Utils::ToLocal(i::Handle<i::Object>(name, isolate));
1639   } else {
1640     return Local<String>();
1641   }
1642 }
1643
1644
1645 Local<Value> UnboundScript::GetSourceURL() {
1646   i::Handle<i::SharedFunctionInfo> obj =
1647       i::Handle<i::SharedFunctionInfo>::cast(Utils::OpenHandle(this));
1648   i::Isolate* isolate = obj->GetIsolate();
1649   LOG_API(isolate, "UnboundScript::GetSourceURL");
1650   if (obj->script()->IsScript()) {
1651     i::Object* url = i::Script::cast(obj->script())->source_url();
1652     return Utils::ToLocal(i::Handle<i::Object>(url, isolate));
1653   } else {
1654     return Local<String>();
1655   }
1656 }
1657
1658
1659 Local<Value> UnboundScript::GetSourceMappingURL() {
1660   i::Handle<i::SharedFunctionInfo> obj =
1661       i::Handle<i::SharedFunctionInfo>::cast(Utils::OpenHandle(this));
1662   i::Isolate* isolate = obj->GetIsolate();
1663   LOG_API(isolate, "UnboundScript::GetSourceMappingURL");
1664   if (obj->script()->IsScript()) {
1665     i::Object* url = i::Script::cast(obj->script())->source_mapping_url();
1666     return Utils::ToLocal(i::Handle<i::Object>(url, isolate));
1667   } else {
1668     return Local<String>();
1669   }
1670 }
1671
1672
1673 MaybeLocal<Value> Script::Run(Local<Context> context) {
1674   PREPARE_FOR_EXECUTION_WITH_CALLBACK(context, "v8::Script::Run()", Value)
1675   i::AggregatingHistogramTimerScope timer(isolate->counters()->compile_lazy());
1676   i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
1677   auto fun = i::Handle<i::JSFunction>::cast(Utils::OpenHandle(this));
1678   i::Handle<i::Object> receiver(isolate->global_proxy(), isolate);
1679   Local<Value> result;
1680   has_pending_exception =
1681       !ToLocal<Value>(i::Execution::Call(isolate, fun, receiver, 0, NULL),
1682                       &result);
1683   RETURN_ON_FAILED_EXECUTION(Value);
1684   RETURN_ESCAPED(result);
1685 }
1686
1687
1688 Local<Value> Script::Run() {
1689   auto self = Utils::OpenHandle(this, true);
1690   // If execution is terminating, Compile(..)->Run() requires this
1691   // check.
1692   if (self.is_null()) return Local<Value>();
1693   auto context = ContextFromHeapObject(self);
1694   RETURN_TO_LOCAL_UNCHECKED(Run(context), Value);
1695 }
1696
1697
1698 Local<UnboundScript> Script::GetUnboundScript() {
1699   i::Handle<i::Object> obj = Utils::OpenHandle(this);
1700   return ToApiHandle<UnboundScript>(
1701       i::Handle<i::SharedFunctionInfo>(i::JSFunction::cast(*obj)->shared()));
1702 }
1703
1704
1705 MaybeLocal<UnboundScript> ScriptCompiler::CompileUnboundInternal(
1706     Isolate* v8_isolate, Source* source, CompileOptions options,
1707     bool is_module) {
1708   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
1709   PREPARE_FOR_EXECUTION_WITH_ISOLATE(
1710       isolate, "v8::ScriptCompiler::CompileUnbound()", UnboundScript);
1711
1712   // Don't try to produce any kind of cache when the debugger is loaded.
1713   if (isolate->debug()->is_loaded() &&
1714       (options == kProduceParserCache || options == kProduceCodeCache)) {
1715     options = kNoCompileOptions;
1716   }
1717
1718   i::ScriptData* script_data = NULL;
1719   if (options == kConsumeParserCache || options == kConsumeCodeCache) {
1720     DCHECK(source->cached_data);
1721     // ScriptData takes care of pointer-aligning the data.
1722     script_data = new i::ScriptData(source->cached_data->data,
1723                                     source->cached_data->length);
1724   }
1725
1726   i::Handle<i::String> str = Utils::OpenHandle(*(source->source_string));
1727   i::Handle<i::SharedFunctionInfo> result;
1728   {
1729     i::HistogramTimerScope total(isolate->counters()->compile_script(), true);
1730     i::Handle<i::Object> name_obj;
1731     i::Handle<i::Object> source_map_url;
1732     int line_offset = 0;
1733     int column_offset = 0;
1734     if (!source->resource_name.IsEmpty()) {
1735       name_obj = Utils::OpenHandle(*(source->resource_name));
1736     }
1737     if (!source->resource_line_offset.IsEmpty()) {
1738       line_offset = static_cast<int>(source->resource_line_offset->Value());
1739     }
1740     if (!source->resource_column_offset.IsEmpty()) {
1741       column_offset =
1742           static_cast<int>(source->resource_column_offset->Value());
1743     }
1744     if (!source->source_map_url.IsEmpty()) {
1745       source_map_url = Utils::OpenHandle(*(source->source_map_url));
1746     }
1747     result = i::Compiler::CompileScript(
1748         str, name_obj, line_offset, column_offset, source->resource_options,
1749         source_map_url, isolate->native_context(), NULL, &script_data, options,
1750         i::NOT_NATIVES_CODE, is_module);
1751     has_pending_exception = result.is_null();
1752     if (has_pending_exception && script_data != NULL) {
1753       // This case won't happen during normal operation; we have compiled
1754       // successfully and produced cached data, and but the second compilation
1755       // of the same source code fails.
1756       delete script_data;
1757       script_data = NULL;
1758     }
1759     RETURN_ON_FAILED_EXECUTION(UnboundScript);
1760
1761     if ((options == kProduceParserCache || options == kProduceCodeCache) &&
1762         script_data != NULL) {
1763       // script_data now contains the data that was generated. source will
1764       // take the ownership.
1765       source->cached_data = new CachedData(
1766           script_data->data(), script_data->length(), CachedData::BufferOwned);
1767       script_data->ReleaseDataOwnership();
1768     } else if (options == kConsumeParserCache || options == kConsumeCodeCache) {
1769       source->cached_data->rejected = script_data->rejected();
1770     }
1771     delete script_data;
1772   }
1773   RETURN_ESCAPED(ToApiHandle<UnboundScript>(result));
1774 }
1775
1776
1777 MaybeLocal<UnboundScript> ScriptCompiler::CompileUnboundScript(
1778     Isolate* v8_isolate, Source* source, CompileOptions options) {
1779   return CompileUnboundInternal(v8_isolate, source, options, false);
1780 }
1781
1782
1783 Local<UnboundScript> ScriptCompiler::CompileUnbound(Isolate* v8_isolate,
1784                                                     Source* source,
1785                                                     CompileOptions options) {
1786   RETURN_TO_LOCAL_UNCHECKED(
1787       CompileUnboundInternal(v8_isolate, source, options, false),
1788       UnboundScript);
1789 }
1790
1791
1792 MaybeLocal<Script> ScriptCompiler::Compile(Local<Context> context,
1793                                            Source* source,
1794                                            CompileOptions options) {
1795   auto isolate = context->GetIsolate();
1796   auto maybe = CompileUnboundInternal(isolate, source, options, false);
1797   Local<UnboundScript> result;
1798   if (!maybe.ToLocal(&result)) return MaybeLocal<Script>();
1799   v8::Context::Scope scope(context);
1800   return result->BindToCurrentContext();
1801 }
1802
1803
1804 Local<Script> ScriptCompiler::Compile(
1805     Isolate* v8_isolate,
1806     Source* source,
1807     CompileOptions options) {
1808   auto context = v8_isolate->GetCurrentContext();
1809   RETURN_TO_LOCAL_UNCHECKED(Compile(context, source, options), Script);
1810 }
1811
1812
1813 MaybeLocal<Script> ScriptCompiler::CompileModule(Local<Context> context,
1814                                                  Source* source,
1815                                                  CompileOptions options) {
1816   CHECK(i::FLAG_harmony_modules);
1817   auto isolate = context->GetIsolate();
1818   auto maybe = CompileUnboundInternal(isolate, source, options, true);
1819   Local<UnboundScript> generic;
1820   if (!maybe.ToLocal(&generic)) return MaybeLocal<Script>();
1821   v8::Context::Scope scope(context);
1822   return generic->BindToCurrentContext();
1823 }
1824
1825
1826 class IsIdentifierHelper {
1827  public:
1828   IsIdentifierHelper() : is_identifier_(false), first_char_(true) {}
1829
1830   bool Check(i::String* string) {
1831     i::ConsString* cons_string = i::String::VisitFlat(this, string, 0);
1832     if (cons_string == NULL) return is_identifier_;
1833     // We don't support cons strings here.
1834     return false;
1835   }
1836   void VisitOneByteString(const uint8_t* chars, int length) {
1837     for (int i = 0; i < length; ++i) {
1838       if (first_char_) {
1839         first_char_ = false;
1840         is_identifier_ = unicode_cache_.IsIdentifierStart(chars[0]);
1841       } else {
1842         is_identifier_ &= unicode_cache_.IsIdentifierPart(chars[i]);
1843       }
1844     }
1845   }
1846   void VisitTwoByteString(const uint16_t* chars, int length) {
1847     for (int i = 0; i < length; ++i) {
1848       if (first_char_) {
1849         first_char_ = false;
1850         is_identifier_ = unicode_cache_.IsIdentifierStart(chars[0]);
1851       } else {
1852         is_identifier_ &= unicode_cache_.IsIdentifierPart(chars[i]);
1853       }
1854     }
1855   }
1856
1857  private:
1858   bool is_identifier_;
1859   bool first_char_;
1860   i::UnicodeCache unicode_cache_;
1861   DISALLOW_COPY_AND_ASSIGN(IsIdentifierHelper);
1862 };
1863
1864
1865 MaybeLocal<Function> ScriptCompiler::CompileFunctionInContext(
1866     Local<Context> v8_context, Source* source, size_t arguments_count,
1867     Local<String> arguments[], size_t context_extension_count,
1868     Local<Object> context_extensions[]) {
1869   PREPARE_FOR_EXECUTION(
1870       v8_context, "v8::ScriptCompiler::CompileFunctionInContext()", Function);
1871   i::Handle<i::String> source_string;
1872   auto factory = isolate->factory();
1873   if (arguments_count) {
1874     source_string = factory->NewStringFromStaticChars("(function(");
1875     for (size_t i = 0; i < arguments_count; ++i) {
1876       IsIdentifierHelper helper;
1877       if (!helper.Check(*Utils::OpenHandle(*arguments[i]))) {
1878         return Local<Function>();
1879       }
1880       has_pending_exception =
1881           !factory->NewConsString(source_string,
1882                                   Utils::OpenHandle(*arguments[i]))
1883                .ToHandle(&source_string);
1884       RETURN_ON_FAILED_EXECUTION(Function);
1885       if (i + 1 == arguments_count) continue;
1886       has_pending_exception =
1887           !factory->NewConsString(source_string,
1888                                   factory->LookupSingleCharacterStringFromCode(
1889                                       ',')).ToHandle(&source_string);
1890       RETURN_ON_FAILED_EXECUTION(Function);
1891     }
1892     auto brackets = factory->NewStringFromStaticChars("){");
1893     has_pending_exception = !factory->NewConsString(source_string, brackets)
1894                                  .ToHandle(&source_string);
1895     RETURN_ON_FAILED_EXECUTION(Function);
1896   } else {
1897     source_string = factory->NewStringFromStaticChars("(function(){");
1898   }
1899
1900   int scope_position = source_string->length();
1901   has_pending_exception =
1902       !factory->NewConsString(source_string,
1903                               Utils::OpenHandle(*source->source_string))
1904            .ToHandle(&source_string);
1905   RETURN_ON_FAILED_EXECUTION(Function);
1906   // Include \n in case the source contains a line end comment.
1907   auto brackets = factory->NewStringFromStaticChars("\n})");
1908   has_pending_exception =
1909       !factory->NewConsString(source_string, brackets).ToHandle(&source_string);
1910   RETURN_ON_FAILED_EXECUTION(Function);
1911
1912   i::Handle<i::Context> context = Utils::OpenHandle(*v8_context);
1913   i::Handle<i::SharedFunctionInfo> outer_info(context->closure()->shared(),
1914                                               isolate);
1915   for (size_t i = 0; i < context_extension_count; ++i) {
1916     i::Handle<i::JSObject> extension =
1917         Utils::OpenHandle(*context_extensions[i]);
1918     i::Handle<i::JSFunction> closure(context->closure(), isolate);
1919     context = factory->NewWithContext(closure, context, extension);
1920   }
1921
1922   i::Handle<i::Object> name_obj;
1923   int line_offset = 0;
1924   int column_offset = 0;
1925   if (!source->resource_name.IsEmpty()) {
1926     name_obj = Utils::OpenHandle(*(source->resource_name));
1927   }
1928   if (!source->resource_line_offset.IsEmpty()) {
1929     line_offset = static_cast<int>(source->resource_line_offset->Value());
1930   }
1931   if (!source->resource_column_offset.IsEmpty()) {
1932     column_offset = static_cast<int>(source->resource_column_offset->Value());
1933   }
1934   i::Handle<i::JSFunction> fun;
1935   has_pending_exception = !i::Compiler::GetFunctionFromEval(
1936                                source_string, outer_info, context, i::SLOPPY,
1937                                i::ONLY_SINGLE_FUNCTION_LITERAL, line_offset,
1938                                column_offset - scope_position, name_obj,
1939                                source->resource_options).ToHandle(&fun);
1940   if (has_pending_exception) {
1941     isolate->ReportPendingMessages();
1942   }
1943   RETURN_ON_FAILED_EXECUTION(Function);
1944
1945   i::Handle<i::Object> result;
1946   has_pending_exception =
1947       !i::Execution::Call(isolate, fun,
1948                           Utils::OpenHandle(*v8_context->Global()), 0,
1949                           nullptr).ToHandle(&result);
1950   RETURN_ON_FAILED_EXECUTION(Function);
1951   RETURN_ESCAPED(Utils::ToLocal(i::Handle<i::JSFunction>::cast(result)));
1952 }
1953
1954
1955 Local<Function> ScriptCompiler::CompileFunctionInContext(
1956     Isolate* v8_isolate, Source* source, Local<Context> v8_context,
1957     size_t arguments_count, Local<String> arguments[],
1958     size_t context_extension_count, Local<Object> context_extensions[]) {
1959   RETURN_TO_LOCAL_UNCHECKED(
1960       CompileFunctionInContext(v8_context, source, arguments_count, arguments,
1961                                context_extension_count, context_extensions),
1962       Function);
1963 }
1964
1965
1966 ScriptCompiler::ScriptStreamingTask* ScriptCompiler::StartStreamingScript(
1967     Isolate* v8_isolate, StreamedSource* source, CompileOptions options) {
1968   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
1969   return new i::BackgroundParsingTask(source->impl(), options,
1970                                       i::FLAG_stack_size, isolate);
1971 }
1972
1973
1974 MaybeLocal<Script> ScriptCompiler::Compile(Local<Context> context,
1975                                            StreamedSource* v8_source,
1976                                            Local<String> full_source_string,
1977                                            const ScriptOrigin& origin) {
1978   PREPARE_FOR_EXECUTION(context, "v8::ScriptCompiler::Compile()", Script);
1979   i::StreamedSource* source = v8_source->impl();
1980   i::Handle<i::String> str = Utils::OpenHandle(*(full_source_string));
1981   i::Handle<i::Script> script = isolate->factory()->NewScript(str);
1982   if (!origin.ResourceName().IsEmpty()) {
1983     script->set_name(*Utils::OpenHandle(*(origin.ResourceName())));
1984   }
1985   if (!origin.ResourceLineOffset().IsEmpty()) {
1986     script->set_line_offset(i::Smi::FromInt(
1987         static_cast<int>(origin.ResourceLineOffset()->Value())));
1988   }
1989   if (!origin.ResourceColumnOffset().IsEmpty()) {
1990     script->set_column_offset(i::Smi::FromInt(
1991         static_cast<int>(origin.ResourceColumnOffset()->Value())));
1992   }
1993   script->set_origin_options(origin.Options());
1994   if (!origin.SourceMapUrl().IsEmpty()) {
1995     script->set_source_mapping_url(
1996         *Utils::OpenHandle(*(origin.SourceMapUrl())));
1997   }
1998
1999   source->info->set_script(script);
2000   source->info->set_context(isolate->native_context());
2001
2002   // Do the parsing tasks which need to be done on the main thread. This will
2003   // also handle parse errors.
2004   source->parser->Internalize(isolate, script,
2005                               source->info->literal() == nullptr);
2006   source->parser->HandleSourceURLComments(isolate, script);
2007
2008   i::Handle<i::SharedFunctionInfo> result;
2009   if (source->info->literal() != nullptr) {
2010     // Parsing has succeeded.
2011     result = i::Compiler::CompileStreamedScript(script, source->info.get(),
2012                                                 str->length());
2013   }
2014   has_pending_exception = result.is_null();
2015   if (has_pending_exception) isolate->ReportPendingMessages();
2016   RETURN_ON_FAILED_EXECUTION(Script);
2017
2018   source->info->clear_script();  // because script goes out of scope.
2019
2020   Local<UnboundScript> generic = ToApiHandle<UnboundScript>(result);
2021   if (generic.IsEmpty()) return Local<Script>();
2022   Local<Script> bound = generic->BindToCurrentContext();
2023   if (bound.IsEmpty()) return Local<Script>();
2024   RETURN_ESCAPED(bound);
2025 }
2026
2027
2028 Local<Script> ScriptCompiler::Compile(Isolate* v8_isolate,
2029                                       StreamedSource* v8_source,
2030                                       Local<String> full_source_string,
2031                                       const ScriptOrigin& origin) {
2032   auto context = v8_isolate->GetCurrentContext();
2033   RETURN_TO_LOCAL_UNCHECKED(
2034       Compile(context, v8_source, full_source_string, origin), Script);
2035 }
2036
2037
2038 uint32_t ScriptCompiler::CachedDataVersionTag() {
2039   return static_cast<uint32_t>(base::hash_combine(
2040       internal::Version::Hash(), internal::FlagList::Hash(),
2041       static_cast<uint32_t>(internal::CpuFeatures::SupportedFeatures())));
2042 }
2043
2044
2045 MaybeLocal<Script> Script::Compile(Local<Context> context, Local<String> source,
2046                                    ScriptOrigin* origin) {
2047   if (origin) {
2048     ScriptCompiler::Source script_source(source, *origin);
2049     return ScriptCompiler::Compile(context, &script_source);
2050   }
2051   ScriptCompiler::Source script_source(source);
2052   return ScriptCompiler::Compile(context, &script_source);
2053 }
2054
2055
2056 Local<Script> Script::Compile(v8::Local<String> source,
2057                               v8::ScriptOrigin* origin) {
2058   auto str = Utils::OpenHandle(*source);
2059   auto context = ContextFromHeapObject(str);
2060   RETURN_TO_LOCAL_UNCHECKED(Compile(context, source, origin), Script);
2061 }
2062
2063
2064 Local<Script> Script::Compile(v8::Local<String> source,
2065                               v8::Local<String> file_name) {
2066   auto str = Utils::OpenHandle(*source);
2067   auto context = ContextFromHeapObject(str);
2068   ScriptOrigin origin(file_name);
2069   return Compile(context, source, &origin).FromMaybe(Local<Script>());
2070 }
2071
2072
2073 // --- E x c e p t i o n s ---
2074
2075
2076 v8::TryCatch::TryCatch()
2077     : isolate_(i::Isolate::Current()),
2078       next_(isolate_->try_catch_handler()),
2079       is_verbose_(false),
2080       can_continue_(true),
2081       capture_message_(true),
2082       rethrow_(false),
2083       has_terminated_(false) {
2084   ResetInternal();
2085   // Special handling for simulators which have a separate JS stack.
2086   js_stack_comparable_address_ =
2087       reinterpret_cast<void*>(v8::internal::SimulatorStack::RegisterCTryCatch(
2088           v8::internal::GetCurrentStackPosition()));
2089   isolate_->RegisterTryCatchHandler(this);
2090 }
2091
2092
2093 v8::TryCatch::TryCatch(v8::Isolate* isolate)
2094     : isolate_(reinterpret_cast<i::Isolate*>(isolate)),
2095       next_(isolate_->try_catch_handler()),
2096       is_verbose_(false),
2097       can_continue_(true),
2098       capture_message_(true),
2099       rethrow_(false),
2100       has_terminated_(false) {
2101   ResetInternal();
2102   // Special handling for simulators which have a separate JS stack.
2103   js_stack_comparable_address_ =
2104       reinterpret_cast<void*>(v8::internal::SimulatorStack::RegisterCTryCatch(
2105           v8::internal::GetCurrentStackPosition()));
2106   isolate_->RegisterTryCatchHandler(this);
2107 }
2108
2109
2110 v8::TryCatch::~TryCatch() {
2111   if (rethrow_) {
2112     v8::Isolate* isolate = reinterpret_cast<Isolate*>(isolate_);
2113     v8::HandleScope scope(isolate);
2114     v8::Local<v8::Value> exc = v8::Local<v8::Value>::New(isolate, Exception());
2115     if (HasCaught() && capture_message_) {
2116       // If an exception was caught and rethrow_ is indicated, the saved
2117       // message, script, and location need to be restored to Isolate TLS
2118       // for reuse.  capture_message_ needs to be disabled so that Throw()
2119       // does not create a new message.
2120       isolate_->thread_local_top()->rethrowing_message_ = true;
2121       isolate_->RestorePendingMessageFromTryCatch(this);
2122     }
2123     isolate_->UnregisterTryCatchHandler(this);
2124     v8::internal::SimulatorStack::UnregisterCTryCatch();
2125     reinterpret_cast<Isolate*>(isolate_)->ThrowException(exc);
2126     DCHECK(!isolate_->thread_local_top()->rethrowing_message_);
2127   } else {
2128     if (HasCaught() && isolate_->has_scheduled_exception()) {
2129       // If an exception was caught but is still scheduled because no API call
2130       // promoted it, then it is canceled to prevent it from being propagated.
2131       // Note that this will not cancel termination exceptions.
2132       isolate_->CancelScheduledExceptionFromTryCatch(this);
2133     }
2134     isolate_->UnregisterTryCatchHandler(this);
2135     v8::internal::SimulatorStack::UnregisterCTryCatch();
2136   }
2137 }
2138
2139
2140 bool v8::TryCatch::HasCaught() const {
2141   return !reinterpret_cast<i::Object*>(exception_)->IsTheHole();
2142 }
2143
2144
2145 bool v8::TryCatch::CanContinue() const {
2146   return can_continue_;
2147 }
2148
2149
2150 bool v8::TryCatch::HasTerminated() const {
2151   return has_terminated_;
2152 }
2153
2154
2155 v8::Local<v8::Value> v8::TryCatch::ReThrow() {
2156   if (!HasCaught()) return v8::Local<v8::Value>();
2157   rethrow_ = true;
2158   return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate_));
2159 }
2160
2161
2162 v8::Local<Value> v8::TryCatch::Exception() const {
2163   if (HasCaught()) {
2164     // Check for out of memory exception.
2165     i::Object* exception = reinterpret_cast<i::Object*>(exception_);
2166     return v8::Utils::ToLocal(i::Handle<i::Object>(exception, isolate_));
2167   } else {
2168     return v8::Local<Value>();
2169   }
2170 }
2171
2172
2173 MaybeLocal<Value> v8::TryCatch::StackTrace(Local<Context> context) const {
2174   if (!HasCaught()) return v8::Local<Value>();
2175   i::Object* raw_obj = reinterpret_cast<i::Object*>(exception_);
2176   if (!raw_obj->IsJSObject()) return v8::Local<Value>();
2177   PREPARE_FOR_EXECUTION(context, "v8::TryCatch::StackTrace", Value);
2178   i::Handle<i::JSObject> obj(i::JSObject::cast(raw_obj), isolate_);
2179   i::Handle<i::String> name = isolate->factory()->stack_string();
2180   Maybe<bool> maybe = i::JSReceiver::HasProperty(obj, name);
2181   has_pending_exception = !maybe.IsJust();
2182   RETURN_ON_FAILED_EXECUTION(Value);
2183   if (!maybe.FromJust()) return v8::Local<Value>();
2184   Local<Value> result;
2185   has_pending_exception =
2186       !ToLocal<Value>(i::Object::GetProperty(obj, name), &result);
2187   RETURN_ON_FAILED_EXECUTION(Value);
2188   RETURN_ESCAPED(result);
2189 }
2190
2191
2192 v8::Local<Value> v8::TryCatch::StackTrace() const {
2193   auto context = reinterpret_cast<v8::Isolate*>(isolate_)->GetCurrentContext();
2194   RETURN_TO_LOCAL_UNCHECKED(StackTrace(context), Value);
2195 }
2196
2197
2198 v8::Local<v8::Message> v8::TryCatch::Message() const {
2199   i::Object* message = reinterpret_cast<i::Object*>(message_obj_);
2200   DCHECK(message->IsJSMessageObject() || message->IsTheHole());
2201   if (HasCaught() && !message->IsTheHole()) {
2202     return v8::Utils::MessageToLocal(i::Handle<i::Object>(message, isolate_));
2203   } else {
2204     return v8::Local<v8::Message>();
2205   }
2206 }
2207
2208
2209 void v8::TryCatch::Reset() {
2210   if (!rethrow_ && HasCaught() && isolate_->has_scheduled_exception()) {
2211     // If an exception was caught but is still scheduled because no API call
2212     // promoted it, then it is canceled to prevent it from being propagated.
2213     // Note that this will not cancel termination exceptions.
2214     isolate_->CancelScheduledExceptionFromTryCatch(this);
2215   }
2216   ResetInternal();
2217 }
2218
2219
2220 void v8::TryCatch::ResetInternal() {
2221   i::Object* the_hole = isolate_->heap()->the_hole_value();
2222   exception_ = the_hole;
2223   message_obj_ = the_hole;
2224 }
2225
2226
2227 void v8::TryCatch::SetVerbose(bool value) {
2228   is_verbose_ = value;
2229 }
2230
2231
2232 void v8::TryCatch::SetCaptureMessage(bool value) {
2233   capture_message_ = value;
2234 }
2235
2236
2237 // --- M e s s a g e ---
2238
2239
2240 Local<String> Message::Get() const {
2241   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2242   ENTER_V8(isolate);
2243   EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
2244   i::Handle<i::Object> obj = Utils::OpenHandle(this);
2245   i::Handle<i::String> raw_result = i::MessageHandler::GetMessage(isolate, obj);
2246   Local<String> result = Utils::ToLocal(raw_result);
2247   return scope.Escape(result);
2248 }
2249
2250
2251 ScriptOrigin Message::GetScriptOrigin() const {
2252   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2253   auto message = i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this));
2254   auto script_wraper = i::Handle<i::Object>(message->script(), isolate);
2255   auto script_value = i::Handle<i::JSValue>::cast(script_wraper);
2256   i::Handle<i::Script> script(i::Script::cast(script_value->value()));
2257   return GetScriptOriginForScript(isolate, script);
2258 }
2259
2260
2261 v8::Local<Value> Message::GetScriptResourceName() const {
2262   return GetScriptOrigin().ResourceName();
2263 }
2264
2265
2266 v8::Local<v8::StackTrace> Message::GetStackTrace() const {
2267   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2268   ENTER_V8(isolate);
2269   EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
2270   auto message = i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this));
2271   i::Handle<i::Object> stackFramesObj(message->stack_frames(), isolate);
2272   if (!stackFramesObj->IsJSArray()) return v8::Local<v8::StackTrace>();
2273   auto stackTrace = i::Handle<i::JSArray>::cast(stackFramesObj);
2274   return scope.Escape(Utils::StackTraceToLocal(stackTrace));
2275 }
2276
2277
2278 Maybe<int> Message::GetLineNumber(Local<Context> context) const {
2279   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Message::GetLineNumber()", int);
2280   i::Handle<i::JSFunction> fun = isolate->message_get_line_number();
2281   i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
2282   i::Handle<i::Object> args[] = {Utils::OpenHandle(this)};
2283   i::Handle<i::Object> result;
2284   has_pending_exception =
2285       !i::Execution::Call(isolate, fun, undefined, arraysize(args), args)
2286            .ToHandle(&result);
2287   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(int);
2288   return Just(static_cast<int>(result->Number()));
2289 }
2290
2291
2292 int Message::GetLineNumber() const {
2293   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
2294   return GetLineNumber(context).FromMaybe(0);
2295 }
2296
2297
2298 int Message::GetStartPosition() const {
2299   auto self = Utils::OpenHandle(this);
2300   return self->start_position();
2301 }
2302
2303
2304 int Message::GetEndPosition() const {
2305   auto self = Utils::OpenHandle(this);
2306   return self->end_position();
2307 }
2308
2309
2310 Maybe<int> Message::GetStartColumn(Local<Context> context) const {
2311   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Message::GetStartColumn()",
2312                                   int);
2313   i::Handle<i::JSFunction> fun = isolate->message_get_column_number();
2314   i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
2315   i::Handle<i::Object> args[] = {Utils::OpenHandle(this)};
2316   i::Handle<i::Object> result;
2317   has_pending_exception =
2318       !i::Execution::Call(isolate, fun, undefined, arraysize(args), args)
2319            .ToHandle(&result);
2320   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(int);
2321   return Just(static_cast<int>(result->Number()));
2322 }
2323
2324
2325 int Message::GetStartColumn() const {
2326   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
2327   const int default_value = kNoColumnInfo;
2328   return GetStartColumn(context).FromMaybe(default_value);
2329 }
2330
2331
2332 Maybe<int> Message::GetEndColumn(Local<Context> context) const {
2333   auto self = Utils::OpenHandle(this);
2334   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Message::GetEndColumn()", int);
2335   i::Handle<i::JSFunction> fun = isolate->message_get_column_number();
2336   i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
2337   i::Handle<i::Object> args[] = {self};
2338   i::Handle<i::Object> result;
2339   has_pending_exception =
2340       !i::Execution::Call(isolate, fun, undefined, arraysize(args), args)
2341            .ToHandle(&result);
2342   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(int);
2343   int start = self->start_position();
2344   int end = self->end_position();
2345   return Just(static_cast<int>(result->Number()) + (end - start));
2346 }
2347
2348
2349 int Message::GetEndColumn() const {
2350   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
2351   const int default_value = kNoColumnInfo;
2352   return GetEndColumn(context).FromMaybe(default_value);
2353 }
2354
2355
2356 bool Message::IsSharedCrossOrigin() const {
2357   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2358   ENTER_V8(isolate);
2359   auto self = Utils::OpenHandle(this);
2360   auto script = i::Handle<i::JSValue>::cast(
2361       i::Handle<i::Object>(self->script(), isolate));
2362   return i::Script::cast(script->value())
2363       ->origin_options()
2364       .IsSharedCrossOrigin();
2365 }
2366
2367 bool Message::IsOpaque() const {
2368   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2369   ENTER_V8(isolate);
2370   auto self = Utils::OpenHandle(this);
2371   auto script = i::Handle<i::JSValue>::cast(
2372       i::Handle<i::Object>(self->script(), isolate));
2373   return i::Script::cast(script->value())->origin_options().IsOpaque();
2374 }
2375
2376
2377 MaybeLocal<String> Message::GetSourceLine(Local<Context> context) const {
2378   PREPARE_FOR_EXECUTION(context, "v8::Message::GetSourceLine()", String);
2379   i::Handle<i::JSFunction> fun = isolate->message_get_source_line();
2380   i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
2381   i::Handle<i::Object> args[] = {Utils::OpenHandle(this)};
2382   i::Handle<i::Object> result;
2383   has_pending_exception =
2384       !i::Execution::Call(isolate, fun, undefined, arraysize(args), args)
2385            .ToHandle(&result);
2386   RETURN_ON_FAILED_EXECUTION(String);
2387   Local<String> str;
2388   if (result->IsString()) {
2389     str = Utils::ToLocal(i::Handle<i::String>::cast(result));
2390   }
2391   RETURN_ESCAPED(str);
2392 }
2393
2394
2395 Local<String> Message::GetSourceLine() const {
2396   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
2397   RETURN_TO_LOCAL_UNCHECKED(GetSourceLine(context), String)
2398 }
2399
2400
2401 void Message::PrintCurrentStackTrace(Isolate* isolate, FILE* out) {
2402   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
2403   ENTER_V8(i_isolate);
2404   i_isolate->PrintCurrentStackTrace(out);
2405 }
2406
2407
2408 // --- S t a c k T r a c e ---
2409
2410 Local<StackFrame> StackTrace::GetFrame(uint32_t index) const {
2411   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2412   ENTER_V8(isolate);
2413   EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
2414   auto self = Utils::OpenHandle(this);
2415   auto obj = i::Object::GetElement(isolate, self, index).ToHandleChecked();
2416   auto jsobj = i::Handle<i::JSObject>::cast(obj);
2417   return scope.Escape(Utils::StackFrameToLocal(jsobj));
2418 }
2419
2420
2421 int StackTrace::GetFrameCount() const {
2422   return i::Smi::cast(Utils::OpenHandle(this)->length())->value();
2423 }
2424
2425
2426 Local<Array> StackTrace::AsArray() {
2427   return Utils::ToLocal(Utils::OpenHandle(this));
2428 }
2429
2430
2431 Local<StackTrace> StackTrace::CurrentStackTrace(
2432     Isolate* isolate,
2433     int frame_limit,
2434     StackTraceOptions options) {
2435   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
2436   ENTER_V8(i_isolate);
2437   // TODO(dcarney): remove when ScriptDebugServer is fixed.
2438   options = static_cast<StackTraceOptions>(
2439       static_cast<int>(options) | kExposeFramesAcrossSecurityOrigins);
2440   i::Handle<i::JSArray> stackTrace =
2441       i_isolate->CaptureCurrentStackTrace(frame_limit, options);
2442   return Utils::StackTraceToLocal(stackTrace);
2443 }
2444
2445
2446 // --- S t a c k F r a m e ---
2447
2448 static int getIntProperty(const StackFrame* f, const char* propertyName,
2449                           int defaultValue) {
2450   i::Isolate* isolate = Utils::OpenHandle(f)->GetIsolate();
2451   ENTER_V8(isolate);
2452   i::HandleScope scope(isolate);
2453   i::Handle<i::JSObject> self = Utils::OpenHandle(f);
2454   i::Handle<i::Object> obj =
2455       i::Object::GetProperty(isolate, self, propertyName).ToHandleChecked();
2456   return obj->IsSmi() ? i::Smi::cast(*obj)->value() : defaultValue;
2457 }
2458
2459
2460 int StackFrame::GetLineNumber() const {
2461   return getIntProperty(this, "lineNumber", Message::kNoLineNumberInfo);
2462 }
2463
2464
2465 int StackFrame::GetColumn() const {
2466   return getIntProperty(this, "column", Message::kNoColumnInfo);
2467 }
2468
2469
2470 int StackFrame::GetScriptId() const {
2471   return getIntProperty(this, "scriptId", Message::kNoScriptIdInfo);
2472 }
2473
2474
2475 static Local<String> getStringProperty(const StackFrame* f,
2476                                        const char* propertyName) {
2477   i::Isolate* isolate = Utils::OpenHandle(f)->GetIsolate();
2478   ENTER_V8(isolate);
2479   EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
2480   i::Handle<i::JSObject> self = Utils::OpenHandle(f);
2481   i::Handle<i::Object> obj =
2482       i::Object::GetProperty(isolate, self, propertyName).ToHandleChecked();
2483   return obj->IsString()
2484              ? scope.Escape(Local<String>::Cast(Utils::ToLocal(obj)))
2485              : Local<String>();
2486 }
2487
2488
2489 Local<String> StackFrame::GetScriptName() const {
2490   return getStringProperty(this, "scriptName");
2491 }
2492
2493
2494 Local<String> StackFrame::GetScriptNameOrSourceURL() const {
2495   return getStringProperty(this, "scriptNameOrSourceURL");
2496 }
2497
2498
2499 Local<String> StackFrame::GetFunctionName() const {
2500   return getStringProperty(this, "functionName");
2501 }
2502
2503
2504 static bool getBoolProperty(const StackFrame* f, const char* propertyName) {
2505   i::Isolate* isolate = Utils::OpenHandle(f)->GetIsolate();
2506   ENTER_V8(isolate);
2507   i::HandleScope scope(isolate);
2508   i::Handle<i::JSObject> self = Utils::OpenHandle(f);
2509   i::Handle<i::Object> obj =
2510       i::Object::GetProperty(isolate, self, propertyName).ToHandleChecked();
2511   return obj->IsTrue();
2512 }
2513
2514 bool StackFrame::IsEval() const { return getBoolProperty(this, "isEval"); }
2515
2516
2517 bool StackFrame::IsConstructor() const {
2518   return getBoolProperty(this, "isConstructor");
2519 }
2520
2521
2522 // --- N a t i v e W e a k M a p ---
2523
2524 Local<NativeWeakMap> NativeWeakMap::New(Isolate* v8_isolate) {
2525   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
2526   ENTER_V8(isolate);
2527   i::Handle<i::JSWeakMap> weakmap = isolate->factory()->NewJSWeakMap();
2528   i::JSWeakCollection::Initialize(weakmap, isolate);
2529   return Utils::NativeWeakMapToLocal(weakmap);
2530 }
2531
2532
2533 void NativeWeakMap::Set(Local<Value> v8_key, Local<Value> v8_value) {
2534   i::Handle<i::JSWeakMap> weak_collection = Utils::OpenHandle(this);
2535   i::Isolate* isolate = weak_collection->GetIsolate();
2536   ENTER_V8(isolate);
2537   i::HandleScope scope(isolate);
2538   i::Handle<i::Object> key = Utils::OpenHandle(*v8_key);
2539   i::Handle<i::Object> value = Utils::OpenHandle(*v8_value);
2540   if (!key->IsJSReceiver() && !key->IsSymbol()) {
2541     DCHECK(false);
2542     return;
2543   }
2544   i::Handle<i::ObjectHashTable> table(
2545       i::ObjectHashTable::cast(weak_collection->table()));
2546   if (!table->IsKey(*key)) {
2547     DCHECK(false);
2548     return;
2549   }
2550   int32_t hash = i::Object::GetOrCreateHash(isolate, key)->value();
2551   i::JSWeakCollection::Set(weak_collection, key, value, hash);
2552 }
2553
2554
2555 Local<Value> NativeWeakMap::Get(Local<Value> v8_key) {
2556   i::Handle<i::JSWeakMap> weak_collection = Utils::OpenHandle(this);
2557   i::Isolate* isolate = weak_collection->GetIsolate();
2558   ENTER_V8(isolate);
2559   i::Handle<i::Object> key = Utils::OpenHandle(*v8_key);
2560   if (!key->IsJSReceiver() && !key->IsSymbol()) {
2561     DCHECK(false);
2562     return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
2563   }
2564   i::Handle<i::ObjectHashTable> table(
2565       i::ObjectHashTable::cast(weak_collection->table()));
2566   if (!table->IsKey(*key)) {
2567     DCHECK(false);
2568     return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
2569   }
2570   i::Handle<i::Object> lookup(table->Lookup(key), isolate);
2571   if (lookup->IsTheHole())
2572     return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
2573   return Utils::ToLocal(lookup);
2574 }
2575
2576
2577 bool NativeWeakMap::Has(Local<Value> v8_key) {
2578   i::Handle<i::JSWeakMap> weak_collection = Utils::OpenHandle(this);
2579   i::Isolate* isolate = weak_collection->GetIsolate();
2580   ENTER_V8(isolate);
2581   i::HandleScope scope(isolate);
2582   i::Handle<i::Object> key = Utils::OpenHandle(*v8_key);
2583   if (!key->IsJSReceiver() && !key->IsSymbol()) {
2584     DCHECK(false);
2585     return false;
2586   }
2587   i::Handle<i::ObjectHashTable> table(
2588       i::ObjectHashTable::cast(weak_collection->table()));
2589   if (!table->IsKey(*key)) {
2590     DCHECK(false);
2591     return false;
2592   }
2593   i::Handle<i::Object> lookup(table->Lookup(key), isolate);
2594   return !lookup->IsTheHole();
2595 }
2596
2597
2598 bool NativeWeakMap::Delete(Local<Value> v8_key) {
2599   i::Handle<i::JSWeakMap> weak_collection = Utils::OpenHandle(this);
2600   i::Isolate* isolate = weak_collection->GetIsolate();
2601   ENTER_V8(isolate);
2602   i::HandleScope scope(isolate);
2603   i::Handle<i::Object> key = Utils::OpenHandle(*v8_key);
2604   if (!key->IsJSReceiver() && !key->IsSymbol()) {
2605     DCHECK(false);
2606     return false;
2607   }
2608   i::Handle<i::ObjectHashTable> table(
2609       i::ObjectHashTable::cast(weak_collection->table()));
2610   if (!table->IsKey(*key)) {
2611     DCHECK(false);
2612     return false;
2613   }
2614   int32_t hash = i::Object::GetOrCreateHash(isolate, key)->value();
2615   return i::JSWeakCollection::Delete(weak_collection, key, hash);
2616 }
2617
2618
2619 // --- J S O N ---
2620
2621 MaybeLocal<Value> JSON::Parse(Isolate* v8_isolate, Local<String> json_string) {
2622   auto isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
2623   PREPARE_FOR_EXECUTION_WITH_ISOLATE(isolate, "JSON::Parse", Value);
2624   i::Handle<i::String> string = Utils::OpenHandle(*json_string);
2625   i::Handle<i::String> source = i::String::Flatten(string);
2626   auto maybe = source->IsSeqOneByteString()
2627                    ? i::JsonParser<true>::Parse(source)
2628                    : i::JsonParser<false>::Parse(source);
2629   Local<Value> result;
2630   has_pending_exception = !ToLocal<Value>(maybe, &result);
2631   RETURN_ON_FAILED_EXECUTION(Value);
2632   RETURN_ESCAPED(result);
2633 }
2634
2635
2636 Local<Value> JSON::Parse(Local<String> json_string) {
2637   auto isolate = reinterpret_cast<v8::Isolate*>(
2638       Utils::OpenHandle(*json_string)->GetIsolate());
2639   RETURN_TO_LOCAL_UNCHECKED(Parse(isolate, json_string), Value);
2640 }
2641
2642
2643 // --- D a t a ---
2644
2645 bool Value::FullIsUndefined() const {
2646   bool result = Utils::OpenHandle(this)->IsUndefined();
2647   DCHECK_EQ(result, QuickIsUndefined());
2648   return result;
2649 }
2650
2651
2652 bool Value::FullIsNull() const {
2653   bool result = Utils::OpenHandle(this)->IsNull();
2654   DCHECK_EQ(result, QuickIsNull());
2655   return result;
2656 }
2657
2658
2659 bool Value::IsTrue() const {
2660   return Utils::OpenHandle(this)->IsTrue();
2661 }
2662
2663
2664 bool Value::IsFalse() const {
2665   return Utils::OpenHandle(this)->IsFalse();
2666 }
2667
2668
2669 bool Value::IsFunction() const {
2670   return Utils::OpenHandle(this)->IsJSFunction();
2671 }
2672
2673
2674 bool Value::IsName() const {
2675   return Utils::OpenHandle(this)->IsName();
2676 }
2677
2678
2679 bool Value::FullIsString() const {
2680   bool result = Utils::OpenHandle(this)->IsString();
2681   DCHECK_EQ(result, QuickIsString());
2682   return result;
2683 }
2684
2685
2686 bool Value::IsSymbol() const {
2687   return Utils::OpenHandle(this)->IsSymbol();
2688 }
2689
2690
2691 bool Value::IsArray() const {
2692   return Utils::OpenHandle(this)->IsJSArray();
2693 }
2694
2695
2696 bool Value::IsArrayBuffer() const {
2697   i::Handle<i::Object> obj = Utils::OpenHandle(this);
2698   return obj->IsJSArrayBuffer() && !i::JSArrayBuffer::cast(*obj)->is_shared();
2699 }
2700
2701
2702 bool Value::IsArrayBufferView() const {
2703   return Utils::OpenHandle(this)->IsJSArrayBufferView();
2704 }
2705
2706
2707 bool Value::IsTypedArray() const {
2708   return Utils::OpenHandle(this)->IsJSTypedArray();
2709 }
2710
2711
2712 #define VALUE_IS_TYPED_ARRAY(Type, typeName, TYPE, ctype, size)              \
2713   bool Value::Is##Type##Array() const {                                      \
2714     i::Handle<i::Object> obj = Utils::OpenHandle(this);                      \
2715     return obj->IsJSTypedArray() &&                                          \
2716            i::JSTypedArray::cast(*obj)->type() == i::kExternal##Type##Array; \
2717   }
2718
2719
2720 TYPED_ARRAYS(VALUE_IS_TYPED_ARRAY)
2721
2722 #undef VALUE_IS_TYPED_ARRAY
2723
2724
2725 bool Value::IsDataView() const {
2726   return Utils::OpenHandle(this)->IsJSDataView();
2727 }
2728
2729
2730 bool Value::IsSharedArrayBuffer() const {
2731   i::Handle<i::Object> obj = Utils::OpenHandle(this);
2732   return obj->IsJSArrayBuffer() && i::JSArrayBuffer::cast(*obj)->is_shared();
2733 }
2734
2735
2736 bool Value::IsObject() const {
2737   return Utils::OpenHandle(this)->IsJSObject();
2738 }
2739
2740
2741 bool Value::IsNumber() const {
2742   return Utils::OpenHandle(this)->IsNumber();
2743 }
2744
2745
2746 #define VALUE_IS_SPECIFIC_TYPE(Type, Class)                            \
2747   bool Value::Is##Type() const {                                       \
2748     i::Handle<i::Object> obj = Utils::OpenHandle(this);                \
2749     if (!obj->IsHeapObject()) return false;                            \
2750     i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();     \
2751     return obj->HasSpecificClassOf(isolate->heap()->Class##_string()); \
2752   }
2753
2754 VALUE_IS_SPECIFIC_TYPE(ArgumentsObject, Arguments)
2755 VALUE_IS_SPECIFIC_TYPE(BooleanObject, Boolean)
2756 VALUE_IS_SPECIFIC_TYPE(NumberObject, Number)
2757 VALUE_IS_SPECIFIC_TYPE(StringObject, String)
2758 VALUE_IS_SPECIFIC_TYPE(SymbolObject, Symbol)
2759 VALUE_IS_SPECIFIC_TYPE(Date, Date)
2760 VALUE_IS_SPECIFIC_TYPE(Map, Map)
2761 VALUE_IS_SPECIFIC_TYPE(Set, Set)
2762 VALUE_IS_SPECIFIC_TYPE(WeakMap, WeakMap)
2763 VALUE_IS_SPECIFIC_TYPE(WeakSet, WeakSet)
2764
2765 #undef VALUE_IS_SPECIFIC_TYPE
2766
2767
2768 bool Value::IsBoolean() const {
2769   return Utils::OpenHandle(this)->IsBoolean();
2770 }
2771
2772
2773 bool Value::IsExternal() const {
2774   return Utils::OpenHandle(this)->IsExternal();
2775 }
2776
2777
2778 bool Value::IsInt32() const {
2779   i::Handle<i::Object> obj = Utils::OpenHandle(this);
2780   if (obj->IsSmi()) return true;
2781   if (obj->IsNumber()) {
2782     return i::IsInt32Double(obj->Number());
2783   }
2784   return false;
2785 }
2786
2787
2788 bool Value::IsUint32() const {
2789   i::Handle<i::Object> obj = Utils::OpenHandle(this);
2790   if (obj->IsSmi()) return i::Smi::cast(*obj)->value() >= 0;
2791   if (obj->IsNumber()) {
2792     double value = obj->Number();
2793     return !i::IsMinusZero(value) &&
2794         value >= 0 &&
2795         value <= i::kMaxUInt32 &&
2796         value == i::FastUI2D(i::FastD2UI(value));
2797   }
2798   return false;
2799 }
2800
2801
2802 bool Value::IsNativeError() const {
2803   i::Handle<i::Object> obj = Utils::OpenHandle(this);
2804   if (!obj->IsJSObject()) return false;
2805   i::Handle<i::JSObject> js_obj = i::Handle<i::JSObject>::cast(obj);
2806   i::Isolate* isolate = js_obj->GetIsolate();
2807   i::Handle<i::Object> constructor(js_obj->map()->GetConstructor(), isolate);
2808   if (!constructor->IsJSFunction()) return false;
2809   i::Handle<i::JSFunction> function =
2810       i::Handle<i::JSFunction>::cast(constructor);
2811   if (!function->shared()->native()) return false;
2812   return function.is_identical_to(isolate->error_function()) ||
2813          function.is_identical_to(isolate->eval_error_function()) ||
2814          function.is_identical_to(isolate->range_error_function()) ||
2815          function.is_identical_to(isolate->reference_error_function()) ||
2816          function.is_identical_to(isolate->syntax_error_function()) ||
2817          function.is_identical_to(isolate->type_error_function()) ||
2818          function.is_identical_to(isolate->uri_error_function());
2819 }
2820
2821
2822 bool Value::IsRegExp() const {
2823   i::Handle<i::Object> obj = Utils::OpenHandle(this);
2824   return obj->IsJSRegExp();
2825 }
2826
2827
2828 bool Value::IsGeneratorFunction() const {
2829   i::Handle<i::Object> obj = Utils::OpenHandle(this);
2830   if (!obj->IsJSFunction()) return false;
2831   i::Handle<i::JSFunction> func = i::Handle<i::JSFunction>::cast(obj);
2832   return func->shared()->is_generator();
2833 }
2834
2835
2836 bool Value::IsGeneratorObject() const {
2837   return Utils::OpenHandle(this)->IsJSGeneratorObject();
2838 }
2839
2840
2841 bool Value::IsMapIterator() const {
2842   return Utils::OpenHandle(this)->IsJSMapIterator();
2843 }
2844
2845
2846 bool Value::IsSetIterator() const {
2847   return Utils::OpenHandle(this)->IsJSSetIterator();
2848 }
2849
2850
2851 MaybeLocal<String> Value::ToString(Local<Context> context) const {
2852   auto obj = Utils::OpenHandle(this);
2853   if (obj->IsString()) return ToApiHandle<String>(obj);
2854   PREPARE_FOR_EXECUTION(context, "ToString", String);
2855   Local<String> result;
2856   has_pending_exception =
2857       !ToLocal<String>(i::Execution::ToString(isolate, obj), &result);
2858   RETURN_ON_FAILED_EXECUTION(String);
2859   RETURN_ESCAPED(result);
2860 }
2861
2862
2863 Local<String> Value::ToString(Isolate* isolate) const {
2864   RETURN_TO_LOCAL_UNCHECKED(ToString(isolate->GetCurrentContext()), String);
2865 }
2866
2867
2868 MaybeLocal<String> Value::ToDetailString(Local<Context> context) const {
2869   auto obj = Utils::OpenHandle(this);
2870   if (obj->IsString()) return ToApiHandle<String>(obj);
2871   PREPARE_FOR_EXECUTION(context, "ToDetailString", String);
2872   Local<String> result;
2873   has_pending_exception =
2874       !ToLocal<String>(i::Execution::ToDetailString(isolate, obj), &result);
2875   RETURN_ON_FAILED_EXECUTION(String);
2876   RETURN_ESCAPED(result);
2877 }
2878
2879
2880 Local<String> Value::ToDetailString(Isolate* isolate) const {
2881   RETURN_TO_LOCAL_UNCHECKED(ToDetailString(isolate->GetCurrentContext()),
2882                             String);
2883 }
2884
2885
2886 MaybeLocal<Object> Value::ToObject(Local<Context> context) const {
2887   auto obj = Utils::OpenHandle(this);
2888   if (obj->IsJSObject()) return ToApiHandle<Object>(obj);
2889   PREPARE_FOR_EXECUTION(context, "ToObject", Object);
2890   Local<Object> result;
2891   has_pending_exception =
2892       !ToLocal<Object>(i::Execution::ToObject(isolate, obj), &result);
2893   RETURN_ON_FAILED_EXECUTION(Object);
2894   RETURN_ESCAPED(result);
2895 }
2896
2897
2898 Local<v8::Object> Value::ToObject(Isolate* isolate) const {
2899   RETURN_TO_LOCAL_UNCHECKED(ToObject(isolate->GetCurrentContext()), Object);
2900 }
2901
2902
2903 MaybeLocal<Boolean> Value::ToBoolean(Local<Context> context) const {
2904   auto obj = Utils::OpenHandle(this);
2905   if (obj->IsBoolean()) return ToApiHandle<Boolean>(obj);
2906   auto isolate = reinterpret_cast<i::Isolate*>(context->GetIsolate());
2907   auto val = isolate->factory()->ToBoolean(obj->BooleanValue());
2908   return ToApiHandle<Boolean>(val);
2909 }
2910
2911
2912 Local<Boolean> Value::ToBoolean(Isolate* v8_isolate) const {
2913   return ToBoolean(v8_isolate->GetCurrentContext()).ToLocalChecked();
2914 }
2915
2916
2917 MaybeLocal<Number> Value::ToNumber(Local<Context> context) const {
2918   auto obj = Utils::OpenHandle(this);
2919   if (obj->IsNumber()) return ToApiHandle<Number>(obj);
2920   PREPARE_FOR_EXECUTION(context, "ToNumber", Number);
2921   Local<Number> result;
2922   has_pending_exception =
2923       !ToLocal<Number>(i::Execution::ToNumber(isolate, obj), &result);
2924   RETURN_ON_FAILED_EXECUTION(Number);
2925   RETURN_ESCAPED(result);
2926 }
2927
2928
2929 Local<Number> Value::ToNumber(Isolate* isolate) const {
2930   RETURN_TO_LOCAL_UNCHECKED(ToNumber(isolate->GetCurrentContext()), Number);
2931 }
2932
2933
2934 MaybeLocal<Integer> Value::ToInteger(Local<Context> context) const {
2935   auto obj = Utils::OpenHandle(this);
2936   if (obj->IsSmi()) return ToApiHandle<Integer>(obj);
2937   PREPARE_FOR_EXECUTION(context, "ToInteger", Integer);
2938   Local<Integer> result;
2939   has_pending_exception =
2940       !ToLocal<Integer>(i::Execution::ToInteger(isolate, obj), &result);
2941   RETURN_ON_FAILED_EXECUTION(Integer);
2942   RETURN_ESCAPED(result);
2943 }
2944
2945
2946 Local<Integer> Value::ToInteger(Isolate* isolate) const {
2947   RETURN_TO_LOCAL_UNCHECKED(ToInteger(isolate->GetCurrentContext()), Integer);
2948 }
2949
2950
2951 MaybeLocal<Int32> Value::ToInt32(Local<Context> context) const {
2952   auto obj = Utils::OpenHandle(this);
2953   if (obj->IsSmi()) return ToApiHandle<Int32>(obj);
2954   Local<Int32> result;
2955   PREPARE_FOR_EXECUTION(context, "ToInt32", Int32);
2956   has_pending_exception =
2957       !ToLocal<Int32>(i::Execution::ToInt32(isolate, obj), &result);
2958   RETURN_ON_FAILED_EXECUTION(Int32);
2959   RETURN_ESCAPED(result);
2960 }
2961
2962
2963 Local<Int32> Value::ToInt32(Isolate* isolate) const {
2964   RETURN_TO_LOCAL_UNCHECKED(ToInt32(isolate->GetCurrentContext()), Int32);
2965 }
2966
2967
2968 MaybeLocal<Uint32> Value::ToUint32(Local<Context> context) const {
2969   auto obj = Utils::OpenHandle(this);
2970   if (obj->IsSmi()) return ToApiHandle<Uint32>(obj);
2971   Local<Uint32> result;
2972   PREPARE_FOR_EXECUTION(context, "ToUInt32", Uint32);
2973   has_pending_exception =
2974       !ToLocal<Uint32>(i::Execution::ToUint32(isolate, obj), &result);
2975   RETURN_ON_FAILED_EXECUTION(Uint32);
2976   RETURN_ESCAPED(result);
2977 }
2978
2979
2980 Local<Uint32> Value::ToUint32(Isolate* isolate) const {
2981   RETURN_TO_LOCAL_UNCHECKED(ToUint32(isolate->GetCurrentContext()), Uint32);
2982 }
2983
2984
2985 void i::Internals::CheckInitializedImpl(v8::Isolate* external_isolate) {
2986   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(external_isolate);
2987   Utils::ApiCheck(isolate != NULL &&
2988                   !isolate->IsDead(),
2989                   "v8::internal::Internals::CheckInitialized()",
2990                   "Isolate is not initialized or V8 has died");
2991 }
2992
2993
2994 void External::CheckCast(v8::Value* that) {
2995   Utils::ApiCheck(Utils::OpenHandle(that)->IsExternal(),
2996                   "v8::External::Cast()",
2997                   "Could not convert to external");
2998 }
2999
3000
3001 void v8::Object::CheckCast(Value* that) {
3002   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3003   Utils::ApiCheck(obj->IsJSObject(),
3004                   "v8::Object::Cast()",
3005                   "Could not convert to object");
3006 }
3007
3008
3009 void v8::Function::CheckCast(Value* that) {
3010   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3011   Utils::ApiCheck(obj->IsJSFunction(),
3012                   "v8::Function::Cast()",
3013                   "Could not convert to function");
3014 }
3015
3016
3017 void v8::Boolean::CheckCast(v8::Value* that) {
3018   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3019   Utils::ApiCheck(obj->IsBoolean(),
3020                   "v8::Boolean::Cast()",
3021                   "Could not convert to boolean");
3022 }
3023
3024
3025 void v8::Name::CheckCast(v8::Value* that) {
3026   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3027   Utils::ApiCheck(obj->IsName(),
3028                   "v8::Name::Cast()",
3029                   "Could not convert to name");
3030 }
3031
3032
3033 void v8::String::CheckCast(v8::Value* that) {
3034   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3035   Utils::ApiCheck(obj->IsString(),
3036                   "v8::String::Cast()",
3037                   "Could not convert to string");
3038 }
3039
3040
3041 void v8::Symbol::CheckCast(v8::Value* that) {
3042   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3043   Utils::ApiCheck(obj->IsSymbol(),
3044                   "v8::Symbol::Cast()",
3045                   "Could not convert to symbol");
3046 }
3047
3048
3049 void v8::Number::CheckCast(v8::Value* that) {
3050   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3051   Utils::ApiCheck(obj->IsNumber(),
3052                   "v8::Number::Cast()",
3053                   "Could not convert to number");
3054 }
3055
3056
3057 void v8::Integer::CheckCast(v8::Value* that) {
3058   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3059   Utils::ApiCheck(obj->IsNumber(),
3060                   "v8::Integer::Cast()",
3061                   "Could not convert to number");
3062 }
3063
3064
3065 void v8::Int32::CheckCast(v8::Value* that) {
3066   Utils::ApiCheck(that->IsInt32(), "v8::Int32::Cast()",
3067                   "Could not convert to 32-bit signed integer");
3068 }
3069
3070
3071 void v8::Uint32::CheckCast(v8::Value* that) {
3072   Utils::ApiCheck(that->IsUint32(), "v8::Uint32::Cast()",
3073                   "Could not convert to 32-bit unsigned integer");
3074 }
3075
3076
3077 void v8::Array::CheckCast(Value* that) {
3078   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3079   Utils::ApiCheck(obj->IsJSArray(),
3080                   "v8::Array::Cast()",
3081                   "Could not convert to array");
3082 }
3083
3084
3085 void v8::Map::CheckCast(Value* that) {
3086   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3087   Utils::ApiCheck(obj->IsJSMap(), "v8::Map::Cast()",
3088                   "Could not convert to Map");
3089 }
3090
3091
3092 void v8::Set::CheckCast(Value* that) {
3093   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3094   Utils::ApiCheck(obj->IsJSSet(), "v8::Set::Cast()",
3095                   "Could not convert to Set");
3096 }
3097
3098
3099 void v8::Promise::CheckCast(Value* that) {
3100   Utils::ApiCheck(that->IsPromise(),
3101                   "v8::Promise::Cast()",
3102                   "Could not convert to promise");
3103 }
3104
3105
3106 void v8::Promise::Resolver::CheckCast(Value* that) {
3107   Utils::ApiCheck(that->IsPromise(),
3108                   "v8::Promise::Resolver::Cast()",
3109                   "Could not convert to promise resolver");
3110 }
3111
3112
3113 void v8::ArrayBuffer::CheckCast(Value* that) {
3114   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3115   Utils::ApiCheck(
3116       obj->IsJSArrayBuffer() && !i::JSArrayBuffer::cast(*obj)->is_shared(),
3117       "v8::ArrayBuffer::Cast()", "Could not convert to ArrayBuffer");
3118 }
3119
3120
3121 void v8::ArrayBufferView::CheckCast(Value* that) {
3122   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3123   Utils::ApiCheck(obj->IsJSArrayBufferView(),
3124                   "v8::ArrayBufferView::Cast()",
3125                   "Could not convert to ArrayBufferView");
3126 }
3127
3128
3129 void v8::TypedArray::CheckCast(Value* that) {
3130   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3131   Utils::ApiCheck(obj->IsJSTypedArray(),
3132                   "v8::TypedArray::Cast()",
3133                   "Could not convert to TypedArray");
3134 }
3135
3136
3137 #define CHECK_TYPED_ARRAY_CAST(Type, typeName, TYPE, ctype, size)             \
3138   void v8::Type##Array::CheckCast(Value* that) {                              \
3139     i::Handle<i::Object> obj = Utils::OpenHandle(that);                       \
3140     Utils::ApiCheck(                                                          \
3141         obj->IsJSTypedArray() &&                                              \
3142             i::JSTypedArray::cast(*obj)->type() == i::kExternal##Type##Array, \
3143         "v8::" #Type "Array::Cast()", "Could not convert to " #Type "Array"); \
3144   }
3145
3146
3147 TYPED_ARRAYS(CHECK_TYPED_ARRAY_CAST)
3148
3149 #undef CHECK_TYPED_ARRAY_CAST
3150
3151
3152 void v8::DataView::CheckCast(Value* that) {
3153   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3154   Utils::ApiCheck(obj->IsJSDataView(),
3155                   "v8::DataView::Cast()",
3156                   "Could not convert to DataView");
3157 }
3158
3159
3160 void v8::SharedArrayBuffer::CheckCast(Value* that) {
3161   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3162   Utils::ApiCheck(
3163       obj->IsJSArrayBuffer() && i::JSArrayBuffer::cast(*obj)->is_shared(),
3164       "v8::SharedArrayBuffer::Cast()",
3165       "Could not convert to SharedArrayBuffer");
3166 }
3167
3168
3169 void v8::Date::CheckCast(v8::Value* that) {
3170   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3171   i::Isolate* isolate = NULL;
3172   if (obj->IsHeapObject()) isolate = i::HeapObject::cast(*obj)->GetIsolate();
3173   Utils::ApiCheck(isolate != NULL &&
3174                   obj->HasSpecificClassOf(isolate->heap()->Date_string()),
3175                   "v8::Date::Cast()",
3176                   "Could not convert to date");
3177 }
3178
3179
3180 void v8::StringObject::CheckCast(v8::Value* that) {
3181   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3182   i::Isolate* isolate = NULL;
3183   if (obj->IsHeapObject()) isolate = i::HeapObject::cast(*obj)->GetIsolate();
3184   Utils::ApiCheck(isolate != NULL &&
3185                   obj->HasSpecificClassOf(isolate->heap()->String_string()),
3186                   "v8::StringObject::Cast()",
3187                   "Could not convert to StringObject");
3188 }
3189
3190
3191 void v8::SymbolObject::CheckCast(v8::Value* that) {
3192   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3193   i::Isolate* isolate = NULL;
3194   if (obj->IsHeapObject()) isolate = i::HeapObject::cast(*obj)->GetIsolate();
3195   Utils::ApiCheck(isolate != NULL &&
3196                   obj->HasSpecificClassOf(isolate->heap()->Symbol_string()),
3197                   "v8::SymbolObject::Cast()",
3198                   "Could not convert to SymbolObject");
3199 }
3200
3201
3202 void v8::NumberObject::CheckCast(v8::Value* that) {
3203   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3204   i::Isolate* isolate = NULL;
3205   if (obj->IsHeapObject()) isolate = i::HeapObject::cast(*obj)->GetIsolate();
3206   Utils::ApiCheck(isolate != NULL &&
3207                   obj->HasSpecificClassOf(isolate->heap()->Number_string()),
3208                   "v8::NumberObject::Cast()",
3209                   "Could not convert to NumberObject");
3210 }
3211
3212
3213 void v8::BooleanObject::CheckCast(v8::Value* that) {
3214   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3215   i::Isolate* isolate = NULL;
3216   if (obj->IsHeapObject()) isolate = i::HeapObject::cast(*obj)->GetIsolate();
3217   Utils::ApiCheck(isolate != NULL &&
3218                   obj->HasSpecificClassOf(isolate->heap()->Boolean_string()),
3219                   "v8::BooleanObject::Cast()",
3220                   "Could not convert to BooleanObject");
3221 }
3222
3223
3224 void v8::RegExp::CheckCast(v8::Value* that) {
3225   i::Handle<i::Object> obj = Utils::OpenHandle(that);
3226   Utils::ApiCheck(obj->IsJSRegExp(),
3227                   "v8::RegExp::Cast()",
3228                   "Could not convert to regular expression");
3229 }
3230
3231
3232 Maybe<bool> Value::BooleanValue(Local<Context> context) const {
3233   return Just(Utils::OpenHandle(this)->BooleanValue());
3234 }
3235
3236
3237 bool Value::BooleanValue() const {
3238   return Utils::OpenHandle(this)->BooleanValue();
3239 }
3240
3241
3242 Maybe<double> Value::NumberValue(Local<Context> context) const {
3243   auto obj = Utils::OpenHandle(this);
3244   if (obj->IsNumber()) return Just(obj->Number());
3245   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "NumberValue", double);
3246   i::Handle<i::Object> num;
3247   has_pending_exception = !i::Execution::ToNumber(isolate, obj).ToHandle(&num);
3248   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(double);
3249   return Just(num->Number());
3250 }
3251
3252
3253 double Value::NumberValue() const {
3254   auto obj = Utils::OpenHandle(this);
3255   if (obj->IsNumber()) return obj->Number();
3256   return NumberValue(ContextFromHeapObject(obj))
3257       .FromMaybe(std::numeric_limits<double>::quiet_NaN());
3258 }
3259
3260
3261 Maybe<int64_t> Value::IntegerValue(Local<Context> context) const {
3262   auto obj = Utils::OpenHandle(this);
3263   i::Handle<i::Object> num;
3264   if (obj->IsNumber()) {
3265     num = obj;
3266   } else {
3267     PREPARE_FOR_EXECUTION_PRIMITIVE(context, "IntegerValue", int64_t);
3268     has_pending_exception =
3269         !i::Execution::ToInteger(isolate, obj).ToHandle(&num);
3270     RETURN_ON_FAILED_EXECUTION_PRIMITIVE(int64_t);
3271   }
3272   return Just(num->IsSmi() ? static_cast<int64_t>(i::Smi::cast(*num)->value())
3273                            : static_cast<int64_t>(num->Number()));
3274 }
3275
3276
3277 int64_t Value::IntegerValue() const {
3278   auto obj = Utils::OpenHandle(this);
3279   if (obj->IsNumber()) {
3280     if (obj->IsSmi()) {
3281       return i::Smi::cast(*obj)->value();
3282     } else {
3283       return static_cast<int64_t>(obj->Number());
3284     }
3285   }
3286   return IntegerValue(ContextFromHeapObject(obj)).FromMaybe(0);
3287 }
3288
3289
3290 Maybe<int32_t> Value::Int32Value(Local<Context> context) const {
3291   auto obj = Utils::OpenHandle(this);
3292   if (obj->IsNumber()) return Just(NumberToInt32(*obj));
3293   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "Int32Value", int32_t);
3294   i::Handle<i::Object> num;
3295   has_pending_exception = !i::Execution::ToInt32(isolate, obj).ToHandle(&num);
3296   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(int32_t);
3297   return Just(num->IsSmi() ? i::Smi::cast(*num)->value()
3298                            : static_cast<int32_t>(num->Number()));
3299 }
3300
3301
3302 int32_t Value::Int32Value() const {
3303   auto obj = Utils::OpenHandle(this);
3304   if (obj->IsNumber()) return NumberToInt32(*obj);
3305   return Int32Value(ContextFromHeapObject(obj)).FromMaybe(0);
3306 }
3307
3308
3309 Maybe<uint32_t> Value::Uint32Value(Local<Context> context) const {
3310   auto obj = Utils::OpenHandle(this);
3311   if (obj->IsNumber()) return Just(NumberToUint32(*obj));
3312   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "Uint32Value", uint32_t);
3313   i::Handle<i::Object> num;
3314   has_pending_exception = !i::Execution::ToUint32(isolate, obj).ToHandle(&num);
3315   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(uint32_t);
3316   return Just(num->IsSmi() ? static_cast<uint32_t>(i::Smi::cast(*num)->value())
3317                            : static_cast<uint32_t>(num->Number()));
3318 }
3319
3320
3321 uint32_t Value::Uint32Value() const {
3322   auto obj = Utils::OpenHandle(this);
3323   if (obj->IsNumber()) return NumberToUint32(*obj);
3324   return Uint32Value(ContextFromHeapObject(obj)).FromMaybe(0);
3325 }
3326
3327
3328 MaybeLocal<Uint32> Value::ToArrayIndex(Local<Context> context) const {
3329   auto self = Utils::OpenHandle(this);
3330   if (self->IsSmi()) {
3331     if (i::Smi::cast(*self)->value() >= 0) return Utils::Uint32ToLocal(self);
3332     return Local<Uint32>();
3333   }
3334   PREPARE_FOR_EXECUTION(context, "ToArrayIndex", Uint32);
3335   i::Handle<i::Object> string_obj;
3336   has_pending_exception =
3337       !i::Execution::ToString(isolate, self).ToHandle(&string_obj);
3338   RETURN_ON_FAILED_EXECUTION(Uint32);
3339   i::Handle<i::String> str = i::Handle<i::String>::cast(string_obj);
3340   uint32_t index;
3341   if (str->AsArrayIndex(&index)) {
3342     i::Handle<i::Object> value;
3343     if (index <= static_cast<uint32_t>(i::Smi::kMaxValue)) {
3344       value = i::Handle<i::Object>(i::Smi::FromInt(index), isolate);
3345     } else {
3346       value = isolate->factory()->NewNumber(index);
3347     }
3348     RETURN_ESCAPED(Utils::Uint32ToLocal(value));
3349   }
3350   return Local<Uint32>();
3351 }
3352
3353
3354 Local<Uint32> Value::ToArrayIndex() const {
3355   auto self = Utils::OpenHandle(this);
3356   if (self->IsSmi()) {
3357     if (i::Smi::cast(*self)->value() >= 0) return Utils::Uint32ToLocal(self);
3358     return Local<Uint32>();
3359   }
3360   auto context = ContextFromHeapObject(self);
3361   RETURN_TO_LOCAL_UNCHECKED(ToArrayIndex(context), Uint32);
3362 }
3363
3364
3365 Maybe<bool> Value::Equals(Local<Context> context, Local<Value> that) const {
3366   auto self = Utils::OpenHandle(this);
3367   auto other = Utils::OpenHandle(*that);
3368   if (self->IsSmi() && other->IsSmi()) {
3369     return Just(self->Number() == other->Number());
3370   }
3371   if (self->IsJSObject() && other->IsJSObject()) {
3372     return Just(*self == *other);
3373   }
3374   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Value::Equals()", bool);
3375   i::Handle<i::Object> args[] = { other };
3376   i::Handle<i::JSFunction> fun = isolate->equals_builtin();
3377   i::Handle<i::Object> result;
3378   has_pending_exception =
3379       !i::Execution::Call(isolate, fun, self, arraysize(args), args)
3380            .ToHandle(&result);
3381   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3382   return Just(*result == i::Smi::FromInt(i::EQUAL));
3383 }
3384
3385
3386 bool Value::Equals(Local<Value> that) const {
3387   auto self = Utils::OpenHandle(this);
3388   auto other = Utils::OpenHandle(*that);
3389   if (self->IsSmi() && other->IsSmi()) {
3390     return self->Number() == other->Number();
3391   }
3392   if (self->IsJSObject() && other->IsJSObject()) {
3393     return *self == *other;
3394   }
3395   auto heap_object = self->IsSmi() ? other : self;
3396   auto context = ContextFromHeapObject(heap_object);
3397   return Equals(context, that).FromMaybe(false);
3398 }
3399
3400
3401 bool Value::StrictEquals(Local<Value> that) const {
3402   auto self = Utils::OpenHandle(this);
3403   auto other = Utils::OpenHandle(*that);
3404   return self->StrictEquals(*other);
3405 }
3406
3407
3408 bool Value::SameValue(Local<Value> that) const {
3409   auto self = Utils::OpenHandle(this);
3410   auto other = Utils::OpenHandle(*that);
3411   return self->SameValue(*other);
3412 }
3413
3414
3415 Maybe<bool> v8::Object::Set(v8::Local<v8::Context> context,
3416                             v8::Local<Value> key, v8::Local<Value> value) {
3417   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::Set()", bool);
3418   auto self = Utils::OpenHandle(this);
3419   auto key_obj = Utils::OpenHandle(*key);
3420   auto value_obj = Utils::OpenHandle(*value);
3421   has_pending_exception =
3422       i::Runtime::SetObjectProperty(isolate, self, key_obj, value_obj,
3423                                     i::SLOPPY).is_null();
3424   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3425   return Just(true);
3426 }
3427
3428
3429 bool v8::Object::Set(v8::Local<Value> key, v8::Local<Value> value) {
3430   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3431   return Set(context, key, value).FromMaybe(false);
3432 }
3433
3434
3435 Maybe<bool> v8::Object::Set(v8::Local<v8::Context> context, uint32_t index,
3436                             v8::Local<Value> value) {
3437   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::Set()", bool);
3438   auto self = Utils::OpenHandle(this);
3439   auto value_obj = Utils::OpenHandle(*value);
3440   has_pending_exception = i::Object::SetElement(isolate, self, index, value_obj,
3441                                                 i::SLOPPY).is_null();
3442   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3443   return Just(true);
3444 }
3445
3446
3447 bool v8::Object::Set(uint32_t index, v8::Local<Value> value) {
3448   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3449   return Set(context, index, value).FromMaybe(false);
3450 }
3451
3452
3453 Maybe<bool> v8::Object::CreateDataProperty(v8::Local<v8::Context> context,
3454                                            v8::Local<Name> key,
3455                                            v8::Local<Value> value) {
3456   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::CreateDataProperty()",
3457                                   bool);
3458   i::Handle<i::JSObject> self = Utils::OpenHandle(this);
3459   i::Handle<i::Name> key_obj = Utils::OpenHandle(*key);
3460   i::Handle<i::Object> value_obj = Utils::OpenHandle(*value);
3461
3462   i::LookupIterator it = i::LookupIterator::PropertyOrElement(
3463       isolate, self, key_obj, i::LookupIterator::OWN);
3464   Maybe<bool> result = i::JSObject::CreateDataProperty(&it, value_obj);
3465   has_pending_exception = result.IsNothing();
3466   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3467   return result;
3468 }
3469
3470
3471 Maybe<bool> v8::Object::CreateDataProperty(v8::Local<v8::Context> context,
3472                                            uint32_t index,
3473                                            v8::Local<Value> value) {
3474   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::CreateDataProperty()",
3475                                   bool);
3476   i::Handle<i::JSObject> self = Utils::OpenHandle(this);
3477   i::Handle<i::Object> value_obj = Utils::OpenHandle(*value);
3478
3479   i::LookupIterator it(isolate, self, index, i::LookupIterator::OWN);
3480   Maybe<bool> result = i::JSObject::CreateDataProperty(&it, value_obj);
3481   has_pending_exception = result.IsNothing();
3482   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3483   return result;
3484 }
3485
3486
3487 Maybe<bool> v8::Object::DefineOwnProperty(v8::Local<v8::Context> context,
3488                                           v8::Local<Name> key,
3489                                           v8::Local<Value> value,
3490                                           v8::PropertyAttribute attributes) {
3491   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::DefineOwnProperty()",
3492                                   bool);
3493   auto self = Utils::OpenHandle(this);
3494   auto key_obj = Utils::OpenHandle(*key);
3495   auto value_obj = Utils::OpenHandle(*value);
3496
3497   if (self->IsAccessCheckNeeded() && !isolate->MayAccess(self)) {
3498     isolate->ReportFailedAccessCheck(self);
3499     return Nothing<bool>();
3500   }
3501
3502   i::Handle<i::FixedArray> desc = isolate->factory()->NewFixedArray(3);
3503   desc->set(0, isolate->heap()->ToBoolean(!(attributes & v8::ReadOnly)));
3504   desc->set(1, isolate->heap()->ToBoolean(!(attributes & v8::DontEnum)));
3505   desc->set(2, isolate->heap()->ToBoolean(!(attributes & v8::DontDelete)));
3506   i::Handle<i::JSArray> desc_array =
3507       isolate->factory()->NewJSArrayWithElements(desc, i::FAST_ELEMENTS, 3);
3508   i::Handle<i::Object> args[] = {self, key_obj, value_obj, desc_array};
3509   i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
3510   i::Handle<i::JSFunction> fun = isolate->object_define_own_property();
3511   i::Handle<i::Object> result;
3512   has_pending_exception =
3513       !i::Execution::Call(isolate, fun, undefined, arraysize(args), args)
3514            .ToHandle(&result);
3515   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3516   return Just(result->BooleanValue());
3517 }
3518
3519
3520 MUST_USE_RESULT
3521 static i::MaybeHandle<i::Object> DefineObjectProperty(
3522     i::Handle<i::JSObject> js_object, i::Handle<i::Object> key,
3523     i::Handle<i::Object> value, PropertyAttributes attrs) {
3524   i::Isolate* isolate = js_object->GetIsolate();
3525   // Check if the given key is an array index.
3526   uint32_t index = 0;
3527   if (key->ToArrayIndex(&index)) {
3528     return i::JSObject::SetOwnElementIgnoreAttributes(js_object, index, value,
3529                                                       attrs);
3530   }
3531
3532   i::Handle<i::Name> name;
3533   ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, name,
3534                                    i::Object::ToName(isolate, key),
3535                                    i::MaybeHandle<i::Object>());
3536
3537   return i::JSObject::DefinePropertyOrElementIgnoreAttributes(js_object, name,
3538                                                               value, attrs);
3539 }
3540
3541
3542 Maybe<bool> v8::Object::ForceSet(v8::Local<v8::Context> context,
3543                                  v8::Local<Value> key, v8::Local<Value> value,
3544                                  v8::PropertyAttribute attribs) {
3545   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::Set()", bool);
3546   auto self = Utils::OpenHandle(this);
3547   auto key_obj = Utils::OpenHandle(*key);
3548   auto value_obj = Utils::OpenHandle(*value);
3549   has_pending_exception =
3550       DefineObjectProperty(self, key_obj, value_obj,
3551                            static_cast<PropertyAttributes>(attribs)).is_null();
3552   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3553   return Just(true);
3554 }
3555
3556
3557 bool v8::Object::ForceSet(v8::Local<Value> key, v8::Local<Value> value,
3558                           v8::PropertyAttribute attribs) {
3559   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
3560   PREPARE_FOR_EXECUTION_GENERIC(isolate, Local<Context>(),
3561                                 "v8::Object::ForceSet", false, i::HandleScope,
3562                                 false);
3563   i::Handle<i::JSObject> self = Utils::OpenHandle(this);
3564   i::Handle<i::Object> key_obj = Utils::OpenHandle(*key);
3565   i::Handle<i::Object> value_obj = Utils::OpenHandle(*value);
3566   has_pending_exception =
3567       DefineObjectProperty(self, key_obj, value_obj,
3568                            static_cast<PropertyAttributes>(attribs)).is_null();
3569   EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, false);
3570   return true;
3571 }
3572
3573
3574 MaybeLocal<Value> v8::Object::Get(Local<v8::Context> context,
3575                                   Local<Value> key) {
3576   PREPARE_FOR_EXECUTION(context, "v8::Object::Get()", Value);
3577   auto self = Utils::OpenHandle(this);
3578   auto key_obj = Utils::OpenHandle(*key);
3579   i::Handle<i::Object> result;
3580   has_pending_exception =
3581       !i::Runtime::GetObjectProperty(isolate, self, key_obj).ToHandle(&result);
3582   RETURN_ON_FAILED_EXECUTION(Value);
3583   RETURN_ESCAPED(Utils::ToLocal(result));
3584 }
3585
3586
3587 Local<Value> v8::Object::Get(v8::Local<Value> key) {
3588   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3589   RETURN_TO_LOCAL_UNCHECKED(Get(context, key), Value);
3590 }
3591
3592
3593 MaybeLocal<Value> v8::Object::Get(Local<Context> context, uint32_t index) {
3594   PREPARE_FOR_EXECUTION(context, "v8::Object::Get()", Value);
3595   auto self = Utils::OpenHandle(this);
3596   i::Handle<i::Object> result;
3597   has_pending_exception =
3598       !i::Object::GetElement(isolate, self, index).ToHandle(&result);
3599   RETURN_ON_FAILED_EXECUTION(Value);
3600   RETURN_ESCAPED(Utils::ToLocal(result));
3601 }
3602
3603
3604 Local<Value> v8::Object::Get(uint32_t index) {
3605   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3606   RETURN_TO_LOCAL_UNCHECKED(Get(context, index), Value);
3607 }
3608
3609
3610 Maybe<PropertyAttribute> v8::Object::GetPropertyAttributes(
3611     Local<Context> context, Local<Value> key) {
3612   PREPARE_FOR_EXECUTION_PRIMITIVE(
3613       context, "v8::Object::GetPropertyAttributes()", PropertyAttribute);
3614   auto self = Utils::OpenHandle(this);
3615   auto key_obj = Utils::OpenHandle(*key);
3616   if (!key_obj->IsName()) {
3617     has_pending_exception = !i::Execution::ToString(
3618         isolate, key_obj).ToHandle(&key_obj);
3619     RETURN_ON_FAILED_EXECUTION_PRIMITIVE(PropertyAttribute);
3620   }
3621   auto key_name = i::Handle<i::Name>::cast(key_obj);
3622   auto result = i::JSReceiver::GetPropertyAttributes(self, key_name);
3623   has_pending_exception = result.IsNothing();
3624   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(PropertyAttribute);
3625   if (result.FromJust() == ABSENT) {
3626     return Just(static_cast<PropertyAttribute>(NONE));
3627   }
3628   return Just(static_cast<PropertyAttribute>(result.FromJust()));
3629 }
3630
3631
3632 PropertyAttribute v8::Object::GetPropertyAttributes(v8::Local<Value> key) {
3633   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3634   return GetPropertyAttributes(context, key)
3635       .FromMaybe(static_cast<PropertyAttribute>(NONE));
3636 }
3637
3638
3639 MaybeLocal<Value> v8::Object::GetOwnPropertyDescriptor(Local<Context> context,
3640                                                        Local<String> key) {
3641   PREPARE_FOR_EXECUTION(context, "v8::Object::GetOwnPropertyDescriptor()",
3642                         Value);
3643   auto obj = Utils::OpenHandle(this);
3644   auto key_name = Utils::OpenHandle(*key);
3645   i::Handle<i::Object> args[] = { obj, key_name };
3646   i::Handle<i::JSFunction> fun = isolate->object_get_own_property_descriptor();
3647   i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
3648   i::Handle<i::Object> result;
3649   has_pending_exception =
3650       !i::Execution::Call(isolate, fun, undefined, arraysize(args), args)
3651            .ToHandle(&result);
3652   RETURN_ON_FAILED_EXECUTION(Value);
3653   RETURN_ESCAPED(Utils::ToLocal(result));
3654 }
3655
3656
3657 Local<Value> v8::Object::GetOwnPropertyDescriptor(Local<String> key) {
3658   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3659   RETURN_TO_LOCAL_UNCHECKED(GetOwnPropertyDescriptor(context, key), Value);
3660 }
3661
3662
3663 Local<Value> v8::Object::GetPrototype() {
3664   auto isolate = Utils::OpenHandle(this)->GetIsolate();
3665   auto self = Utils::OpenHandle(this);
3666   i::PrototypeIterator iter(isolate, self);
3667   return Utils::ToLocal(i::PrototypeIterator::GetCurrent(iter));
3668 }
3669
3670
3671 Maybe<bool> v8::Object::SetPrototype(Local<Context> context,
3672                                      Local<Value> value) {
3673   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::SetPrototype()", bool);
3674   auto self = Utils::OpenHandle(this);
3675   auto value_obj = Utils::OpenHandle(*value);
3676   // We do not allow exceptions thrown while setting the prototype
3677   // to propagate outside.
3678   TryCatch try_catch(reinterpret_cast<v8::Isolate*>(isolate));
3679   auto result = i::JSObject::SetPrototype(self, value_obj, false);
3680   has_pending_exception = result.is_null();
3681   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3682   return Just(true);
3683 }
3684
3685
3686 bool v8::Object::SetPrototype(Local<Value> value) {
3687   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3688   return SetPrototype(context, value).FromMaybe(false);
3689 }
3690
3691
3692 Local<Object> v8::Object::FindInstanceInPrototypeChain(
3693     v8::Local<FunctionTemplate> tmpl) {
3694   auto isolate = Utils::OpenHandle(this)->GetIsolate();
3695   i::PrototypeIterator iter(isolate, *Utils::OpenHandle(this),
3696                             i::PrototypeIterator::START_AT_RECEIVER);
3697   auto tmpl_info = *Utils::OpenHandle(*tmpl);
3698   while (!tmpl_info->IsTemplateFor(iter.GetCurrent())) {
3699     iter.Advance();
3700     if (iter.IsAtEnd()) {
3701       return Local<Object>();
3702     }
3703   }
3704   return Utils::ToLocal(
3705       i::handle(i::JSObject::cast(iter.GetCurrent()), isolate));
3706 }
3707
3708
3709 MaybeLocal<Array> v8::Object::GetPropertyNames(Local<Context> context) {
3710   PREPARE_FOR_EXECUTION(context, "v8::Object::GetPropertyNames()", Array);
3711   auto self = Utils::OpenHandle(this);
3712   i::Handle<i::FixedArray> value;
3713   has_pending_exception = !i::JSReceiver::GetKeys(
3714       self, i::JSReceiver::INCLUDE_PROTOS).ToHandle(&value);
3715   RETURN_ON_FAILED_EXECUTION(Array);
3716   // Because we use caching to speed up enumeration it is important
3717   // to never change the result of the basic enumeration function so
3718   // we clone the result.
3719   auto elms = isolate->factory()->CopyFixedArray(value);
3720   auto result = isolate->factory()->NewJSArrayWithElements(elms);
3721   RETURN_ESCAPED(Utils::ToLocal(result));
3722 }
3723
3724
3725 Local<Array> v8::Object::GetPropertyNames() {
3726   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3727   RETURN_TO_LOCAL_UNCHECKED(GetPropertyNames(context), Array);
3728 }
3729
3730
3731 MaybeLocal<Array> v8::Object::GetOwnPropertyNames(Local<Context> context) {
3732   PREPARE_FOR_EXECUTION(context, "v8::Object::GetOwnPropertyNames()", Array);
3733   auto self = Utils::OpenHandle(this);
3734   i::Handle<i::FixedArray> value;
3735   has_pending_exception = !i::JSReceiver::GetKeys(
3736       self, i::JSReceiver::OWN_ONLY).ToHandle(&value);
3737   RETURN_ON_FAILED_EXECUTION(Array);
3738   // Because we use caching to speed up enumeration it is important
3739   // to never change the result of the basic enumeration function so
3740   // we clone the result.
3741   auto elms = isolate->factory()->CopyFixedArray(value);
3742   auto result = isolate->factory()->NewJSArrayWithElements(elms);
3743   RETURN_ESCAPED(Utils::ToLocal(result));
3744 }
3745
3746
3747 Local<Array> v8::Object::GetOwnPropertyNames() {
3748   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3749   RETURN_TO_LOCAL_UNCHECKED(GetOwnPropertyNames(context), Array);
3750 }
3751
3752
3753 MaybeLocal<String> v8::Object::ObjectProtoToString(Local<Context> context) {
3754   auto self = Utils::OpenHandle(this);
3755   auto isolate = self->GetIsolate();
3756   auto v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
3757   i::Handle<i::Object> name(self->class_name(), isolate);
3758   i::Handle<i::Object> tag;
3759
3760   // Native implementation of Object.prototype.toString (v8natives.js):
3761   //   var c = %_ClassOf(this);
3762   //   if (c === 'Arguments') c  = 'Object';
3763   //   return "[object " + c + "]";
3764
3765   if (!name->IsString()) {
3766     return v8::String::NewFromUtf8(v8_isolate, "[object ]",
3767                                    NewStringType::kNormal);
3768   }
3769   auto class_name = i::Handle<i::String>::cast(name);
3770   if (i::String::Equals(class_name, isolate->factory()->Arguments_string())) {
3771     return v8::String::NewFromUtf8(v8_isolate, "[object Object]",
3772                                    NewStringType::kNormal);
3773   }
3774   if (internal::FLAG_harmony_tostring) {
3775     PREPARE_FOR_EXECUTION(context, "v8::Object::ObjectProtoToString()", String);
3776     auto toStringTag = isolate->factory()->to_string_tag_symbol();
3777     has_pending_exception = !i::Runtime::GetObjectProperty(
3778                                  isolate, self, toStringTag).ToHandle(&tag);
3779     RETURN_ON_FAILED_EXECUTION(String);
3780     if (tag->IsString()) {
3781       class_name = Utils::OpenHandle(*handle_scope.Escape(
3782           Utils::ToLocal(i::Handle<i::String>::cast(tag))));
3783     }
3784   }
3785   const char* prefix = "[object ";
3786   Local<String> str = Utils::ToLocal(class_name);
3787   const char* postfix = "]";
3788
3789   int prefix_len = i::StrLength(prefix);
3790   int str_len = str->Utf8Length();
3791   int postfix_len = i::StrLength(postfix);
3792
3793   int buf_len = prefix_len + str_len + postfix_len;
3794   i::ScopedVector<char> buf(buf_len);
3795
3796   // Write prefix.
3797   char* ptr = buf.start();
3798   i::MemCopy(ptr, prefix, prefix_len * v8::internal::kCharSize);
3799   ptr += prefix_len;
3800
3801   // Write real content.
3802   str->WriteUtf8(ptr, str_len);
3803   ptr += str_len;
3804
3805   // Write postfix.
3806   i::MemCopy(ptr, postfix, postfix_len * v8::internal::kCharSize);
3807
3808   // Copy the buffer into a heap-allocated string and return it.
3809   return v8::String::NewFromUtf8(v8_isolate, buf.start(),
3810                                  NewStringType::kNormal, buf_len);
3811 }
3812
3813
3814 Local<String> v8::Object::ObjectProtoToString() {
3815   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3816   RETURN_TO_LOCAL_UNCHECKED(ObjectProtoToString(context), String);
3817 }
3818
3819
3820 Local<String> v8::Object::GetConstructorName() {
3821   auto self = Utils::OpenHandle(this);
3822   i::Handle<i::String> name(self->constructor_name());
3823   return Utils::ToLocal(name);
3824 }
3825
3826
3827 Maybe<bool> v8::Object::Delete(Local<Context> context, Local<Value> key) {
3828   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::Delete()", bool);
3829   auto self = Utils::OpenHandle(this);
3830   auto key_obj = Utils::OpenHandle(*key);
3831   i::Handle<i::Object> obj;
3832   has_pending_exception =
3833       !i::Runtime::DeleteObjectProperty(isolate, self, key_obj, i::SLOPPY)
3834            .ToHandle(&obj);
3835   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3836   return Just(obj->IsTrue());
3837 }
3838
3839
3840 bool v8::Object::Delete(v8::Local<Value> key) {
3841   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3842   return Delete(context, key).FromMaybe(false);
3843 }
3844
3845
3846 Maybe<bool> v8::Object::Has(Local<Context> context, Local<Value> key) {
3847   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::Get()", bool);
3848   auto self = Utils::OpenHandle(this);
3849   auto key_obj = Utils::OpenHandle(*key);
3850   Maybe<bool> maybe = Nothing<bool>();
3851   // Check if the given key is an array index.
3852   uint32_t index = 0;
3853   if (key_obj->ToArrayIndex(&index)) {
3854     maybe = i::JSReceiver::HasElement(self, index);
3855   } else {
3856     // Convert the key to a name - possibly by calling back into JavaScript.
3857     i::Handle<i::Name> name;
3858     if (i::Object::ToName(isolate, key_obj).ToHandle(&name)) {
3859       maybe = i::JSReceiver::HasProperty(self, name);
3860     }
3861   }
3862   has_pending_exception = maybe.IsNothing();
3863   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3864   return maybe;
3865 }
3866
3867
3868 bool v8::Object::Has(v8::Local<Value> key) {
3869   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3870   return Has(context, key).FromMaybe(false);
3871 }
3872
3873
3874 Maybe<bool> v8::Object::Delete(Local<Context> context, uint32_t index) {
3875   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::DeleteProperty()",
3876                                   bool);
3877   auto self = Utils::OpenHandle(this);
3878   i::Handle<i::Object> obj;
3879   has_pending_exception =
3880       !i::JSReceiver::DeleteElement(self, index).ToHandle(&obj);
3881   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3882   return Just(obj->IsTrue());
3883 }
3884
3885
3886 bool v8::Object::Delete(uint32_t index) {
3887   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3888   return Delete(context, index).FromMaybe(false);
3889 }
3890
3891
3892 Maybe<bool> v8::Object::Has(Local<Context> context, uint32_t index) {
3893   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::Get()", bool);
3894   auto self = Utils::OpenHandle(this);
3895   auto maybe = i::JSReceiver::HasElement(self, index);
3896   has_pending_exception = maybe.IsNothing();
3897   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3898   return maybe;
3899 }
3900
3901
3902 bool v8::Object::Has(uint32_t index) {
3903   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3904   return Has(context, index).FromMaybe(false);
3905 }
3906
3907
3908 template <typename Getter, typename Setter, typename Data>
3909 static Maybe<bool> ObjectSetAccessor(Local<Context> context, Object* obj,
3910                                      Local<Name> name, Getter getter,
3911                                      Setter setter, Data data,
3912                                      AccessControl settings,
3913                                      PropertyAttribute attributes) {
3914   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::SetAccessor()", bool);
3915   v8::Local<AccessorSignature> signature;
3916   auto info = MakeAccessorInfo(name, getter, setter, data, settings, attributes,
3917                                signature);
3918   if (info.is_null()) return Nothing<bool>();
3919   bool fast = Utils::OpenHandle(obj)->HasFastProperties();
3920   i::Handle<i::Object> result;
3921   has_pending_exception =
3922       !i::JSObject::SetAccessor(Utils::OpenHandle(obj), info).ToHandle(&result);
3923   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3924   if (result->IsUndefined()) return Nothing<bool>();
3925   if (fast) {
3926     i::JSObject::MigrateSlowToFast(Utils::OpenHandle(obj), 0, "APISetAccessor");
3927   }
3928   return Just(true);
3929 }
3930
3931
3932 Maybe<bool> Object::SetAccessor(Local<Context> context, Local<Name> name,
3933                                 AccessorNameGetterCallback getter,
3934                                 AccessorNameSetterCallback setter,
3935                                 MaybeLocal<Value> data, AccessControl settings,
3936                                 PropertyAttribute attribute) {
3937   return ObjectSetAccessor(context, this, name, getter, setter,
3938                            data.FromMaybe(Local<Value>()), settings, attribute);
3939 }
3940
3941
3942 bool Object::SetAccessor(Local<String> name, AccessorGetterCallback getter,
3943                          AccessorSetterCallback setter, v8::Local<Value> data,
3944                          AccessControl settings, PropertyAttribute attributes) {
3945   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3946   return ObjectSetAccessor(context, this, name, getter, setter, data, settings,
3947                            attributes).FromMaybe(false);
3948 }
3949
3950
3951 bool Object::SetAccessor(Local<Name> name, AccessorNameGetterCallback getter,
3952                          AccessorNameSetterCallback setter,
3953                          v8::Local<Value> data, AccessControl settings,
3954                          PropertyAttribute attributes) {
3955   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3956   return ObjectSetAccessor(context, this, name, getter, setter, data, settings,
3957                            attributes).FromMaybe(false);
3958 }
3959
3960
3961 void Object::SetAccessorProperty(Local<Name> name, Local<Function> getter,
3962                                  Local<Function> setter,
3963                                  PropertyAttribute attribute,
3964                                  AccessControl settings) {
3965   // TODO(verwaest): Remove |settings|.
3966   DCHECK_EQ(v8::DEFAULT, settings);
3967   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
3968   ENTER_V8(isolate);
3969   i::HandleScope scope(isolate);
3970   i::Handle<i::Object> getter_i = v8::Utils::OpenHandle(*getter);
3971   i::Handle<i::Object> setter_i = v8::Utils::OpenHandle(*setter, true);
3972   if (setter_i.is_null()) setter_i = isolate->factory()->null_value();
3973   i::JSObject::DefineAccessor(v8::Utils::OpenHandle(this),
3974                               v8::Utils::OpenHandle(*name),
3975                               getter_i,
3976                               setter_i,
3977                               static_cast<PropertyAttributes>(attribute));
3978 }
3979
3980
3981 Maybe<bool> v8::Object::HasOwnProperty(Local<Context> context,
3982                                        Local<Name> key) {
3983   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::HasOwnProperty()",
3984                                   bool);
3985   auto self = Utils::OpenHandle(this);
3986   auto key_val = Utils::OpenHandle(*key);
3987   auto result = i::JSReceiver::HasOwnProperty(self, key_val);
3988   has_pending_exception = result.IsNothing();
3989   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3990   return result;
3991 }
3992
3993
3994 bool v8::Object::HasOwnProperty(Local<String> key) {
3995   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
3996   return HasOwnProperty(context, key).FromMaybe(false);
3997 }
3998
3999
4000 Maybe<bool> v8::Object::HasRealNamedProperty(Local<Context> context,
4001                                              Local<Name> key) {
4002   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::HasRealNamedProperty()",
4003                                   bool);
4004   auto self = Utils::OpenHandle(this);
4005   auto key_val = Utils::OpenHandle(*key);
4006   auto result = i::JSObject::HasRealNamedProperty(self, key_val);
4007   has_pending_exception = result.IsNothing();
4008   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4009   return result;
4010 }
4011
4012
4013 bool v8::Object::HasRealNamedProperty(Local<String> key) {
4014   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4015   return HasRealNamedProperty(context, key).FromMaybe(false);
4016 }
4017
4018
4019 Maybe<bool> v8::Object::HasRealIndexedProperty(Local<Context> context,
4020                                                uint32_t index) {
4021   PREPARE_FOR_EXECUTION_PRIMITIVE(context,
4022                                   "v8::Object::HasRealIndexedProperty()", bool);
4023   auto self = Utils::OpenHandle(this);
4024   auto result = i::JSObject::HasRealElementProperty(self, index);
4025   has_pending_exception = result.IsNothing();
4026   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4027   return result;
4028 }
4029
4030
4031 bool v8::Object::HasRealIndexedProperty(uint32_t index) {
4032   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4033   return HasRealIndexedProperty(context, index).FromMaybe(false);
4034 }
4035
4036
4037 Maybe<bool> v8::Object::HasRealNamedCallbackProperty(Local<Context> context,
4038                                                      Local<Name> key) {
4039   PREPARE_FOR_EXECUTION_PRIMITIVE(
4040       context, "v8::Object::HasRealNamedCallbackProperty()", bool);
4041   auto self = Utils::OpenHandle(this);
4042   auto key_val = Utils::OpenHandle(*key);
4043   auto result = i::JSObject::HasRealNamedCallbackProperty(self, key_val);
4044   has_pending_exception = result.IsNothing();
4045   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4046   return result;
4047 }
4048
4049
4050 bool v8::Object::HasRealNamedCallbackProperty(Local<String> key) {
4051   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4052   return HasRealNamedCallbackProperty(context, key).FromMaybe(false);
4053 }
4054
4055
4056 bool v8::Object::HasNamedLookupInterceptor() {
4057   auto self = Utils::OpenHandle(this);
4058   return self->HasNamedInterceptor();
4059 }
4060
4061
4062 bool v8::Object::HasIndexedLookupInterceptor() {
4063   auto self = Utils::OpenHandle(this);
4064   return self->HasIndexedInterceptor();
4065 }
4066
4067
4068 MaybeLocal<Value> v8::Object::GetRealNamedPropertyInPrototypeChain(
4069     Local<Context> context, Local<Name> key) {
4070   PREPARE_FOR_EXECUTION(
4071       context, "v8::Object::GetRealNamedPropertyInPrototypeChain()", Value);
4072   auto self = Utils::OpenHandle(this);
4073   auto key_obj = Utils::OpenHandle(*key);
4074   i::PrototypeIterator iter(isolate, self);
4075   if (iter.IsAtEnd()) return MaybeLocal<Value>();
4076   auto proto = i::PrototypeIterator::GetCurrent(iter);
4077   i::LookupIterator it = i::LookupIterator::PropertyOrElement(
4078       isolate, self, key_obj, i::Handle<i::JSReceiver>::cast(proto),
4079       i::LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
4080   Local<Value> result;
4081   has_pending_exception = !ToLocal<Value>(i::Object::GetProperty(&it), &result);
4082   RETURN_ON_FAILED_EXECUTION(Value);
4083   if (!it.IsFound()) return MaybeLocal<Value>();
4084   RETURN_ESCAPED(result);
4085 }
4086
4087
4088 Local<Value> v8::Object::GetRealNamedPropertyInPrototypeChain(
4089     Local<String> key) {
4090   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4091   RETURN_TO_LOCAL_UNCHECKED(GetRealNamedPropertyInPrototypeChain(context, key),
4092                             Value);
4093 }
4094
4095
4096 Maybe<PropertyAttribute>
4097 v8::Object::GetRealNamedPropertyAttributesInPrototypeChain(
4098     Local<Context> context, Local<Name> key) {
4099   PREPARE_FOR_EXECUTION_PRIMITIVE(
4100       context, "v8::Object::GetRealNamedPropertyAttributesInPrototypeChain()",
4101       PropertyAttribute);
4102   auto self = Utils::OpenHandle(this);
4103   auto key_obj = Utils::OpenHandle(*key);
4104   i::PrototypeIterator iter(isolate, self);
4105   if (iter.IsAtEnd()) return Nothing<PropertyAttribute>();
4106   auto proto = i::PrototypeIterator::GetCurrent(iter);
4107   i::LookupIterator it = i::LookupIterator::PropertyOrElement(
4108       isolate, self, key_obj, i::Handle<i::JSReceiver>::cast(proto),
4109       i::LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
4110   auto result = i::JSReceiver::GetPropertyAttributes(&it);
4111   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(PropertyAttribute);
4112   if (!it.IsFound()) return Nothing<PropertyAttribute>();
4113   if (result.FromJust() == ABSENT) {
4114     return Just(static_cast<PropertyAttribute>(NONE));
4115   }
4116   return Just<PropertyAttribute>(
4117       static_cast<PropertyAttribute>(result.FromJust()));
4118 }
4119
4120
4121 Maybe<PropertyAttribute>
4122 v8::Object::GetRealNamedPropertyAttributesInPrototypeChain(Local<String> key) {
4123   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4124   return GetRealNamedPropertyAttributesInPrototypeChain(context, key);
4125 }
4126
4127
4128 MaybeLocal<Value> v8::Object::GetRealNamedProperty(Local<Context> context,
4129                                                    Local<Name> key) {
4130   PREPARE_FOR_EXECUTION(context, "v8::Object::GetRealNamedProperty()", Value);
4131   auto self = Utils::OpenHandle(this);
4132   auto key_obj = Utils::OpenHandle(*key);
4133   i::LookupIterator it = i::LookupIterator::PropertyOrElement(
4134       isolate, self, key_obj,
4135       i::LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
4136   Local<Value> result;
4137   has_pending_exception = !ToLocal<Value>(i::Object::GetProperty(&it), &result);
4138   RETURN_ON_FAILED_EXECUTION(Value);
4139   if (!it.IsFound()) return MaybeLocal<Value>();
4140   RETURN_ESCAPED(result);
4141 }
4142
4143
4144 Local<Value> v8::Object::GetRealNamedProperty(Local<String> key) {
4145   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4146   RETURN_TO_LOCAL_UNCHECKED(GetRealNamedProperty(context, key), Value);
4147 }
4148
4149
4150 Maybe<PropertyAttribute> v8::Object::GetRealNamedPropertyAttributes(
4151     Local<Context> context, Local<Name> key) {
4152   PREPARE_FOR_EXECUTION_PRIMITIVE(
4153       context, "v8::Object::GetRealNamedPropertyAttributes()",
4154       PropertyAttribute);
4155   auto self = Utils::OpenHandle(this);
4156   auto key_obj = Utils::OpenHandle(*key);
4157   i::LookupIterator it = i::LookupIterator::PropertyOrElement(
4158       isolate, self, key_obj,
4159       i::LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
4160   auto result = i::JSReceiver::GetPropertyAttributes(&it);
4161   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(PropertyAttribute);
4162   if (!it.IsFound()) return Nothing<PropertyAttribute>();
4163   if (result.FromJust() == ABSENT) {
4164     return Just(static_cast<PropertyAttribute>(NONE));
4165   }
4166   return Just<PropertyAttribute>(
4167       static_cast<PropertyAttribute>(result.FromJust()));
4168 }
4169
4170
4171 Maybe<PropertyAttribute> v8::Object::GetRealNamedPropertyAttributes(
4172     Local<String> key) {
4173   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4174   return GetRealNamedPropertyAttributes(context, key);
4175 }
4176
4177
4178 Local<v8::Object> v8::Object::Clone() {
4179   auto self = Utils::OpenHandle(this);
4180   auto isolate = self->GetIsolate();
4181   ENTER_V8(isolate);
4182   auto result = isolate->factory()->CopyJSObject(self);
4183   CHECK(!result.is_null());
4184   return Utils::ToLocal(result);
4185 }
4186
4187
4188 Local<v8::Context> v8::Object::CreationContext() {
4189   auto self = Utils::OpenHandle(this);
4190   auto context = handle(self->GetCreationContext());
4191   return Utils::ToLocal(context);
4192 }
4193
4194
4195 int v8::Object::GetIdentityHash() {
4196   auto isolate = Utils::OpenHandle(this)->GetIsolate();
4197   i::HandleScope scope(isolate);
4198   auto self = Utils::OpenHandle(this);
4199   return i::JSReceiver::GetOrCreateIdentityHash(self)->value();
4200 }
4201
4202
4203 bool v8::Object::SetHiddenValue(v8::Local<v8::String> key,
4204                                 v8::Local<v8::Value> value) {
4205   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
4206   if (value.IsEmpty()) return DeleteHiddenValue(key);
4207   ENTER_V8(isolate);
4208   i::HandleScope scope(isolate);
4209   i::Handle<i::JSObject> self = Utils::OpenHandle(this);
4210   i::Handle<i::String> key_obj = Utils::OpenHandle(*key);
4211   i::Handle<i::String> key_string =
4212       isolate->factory()->InternalizeString(key_obj);
4213   i::Handle<i::Object> value_obj = Utils::OpenHandle(*value);
4214   i::Handle<i::Object> result =
4215       i::JSObject::SetHiddenProperty(self, key_string, value_obj);
4216   return *result == *self;
4217 }
4218
4219
4220 v8::Local<v8::Value> v8::Object::GetHiddenValue(v8::Local<v8::String> key) {
4221   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
4222   ENTER_V8(isolate);
4223   i::Handle<i::JSObject> self = Utils::OpenHandle(this);
4224   i::Handle<i::String> key_obj = Utils::OpenHandle(*key);
4225   i::Handle<i::String> key_string =
4226       isolate->factory()->InternalizeString(key_obj);
4227   i::Handle<i::Object> result(self->GetHiddenProperty(key_string), isolate);
4228   if (result->IsTheHole()) return v8::Local<v8::Value>();
4229   return Utils::ToLocal(result);
4230 }
4231
4232
4233 bool v8::Object::DeleteHiddenValue(v8::Local<v8::String> key) {
4234   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
4235   ENTER_V8(isolate);
4236   i::HandleScope scope(isolate);
4237   i::Handle<i::JSObject> self = Utils::OpenHandle(this);
4238   i::Handle<i::String> key_obj = Utils::OpenHandle(*key);
4239   i::Handle<i::String> key_string =
4240       isolate->factory()->InternalizeString(key_obj);
4241   i::JSObject::DeleteHiddenProperty(self, key_string);
4242   return true;
4243 }
4244
4245
4246 bool v8::Object::IsCallable() {
4247   auto self = Utils::OpenHandle(this);
4248   return self->IsCallable();
4249 }
4250
4251
4252 MaybeLocal<Value> Object::CallAsFunction(Local<Context> context,
4253                                          Local<Value> recv, int argc,
4254                                          Local<Value> argv[]) {
4255   PREPARE_FOR_EXECUTION_WITH_CALLBACK(context, "v8::Object::CallAsFunction()",
4256                                       Value);
4257   i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
4258   auto self = Utils::OpenHandle(this);
4259   auto recv_obj = Utils::OpenHandle(*recv);
4260   STATIC_ASSERT(sizeof(v8::Local<v8::Value>) == sizeof(i::Object**));
4261   i::Handle<i::Object>* args = reinterpret_cast<i::Handle<i::Object>*>(argv);
4262   i::Handle<i::JSFunction> fun;
4263   if (self->IsJSFunction()) {
4264     fun = i::Handle<i::JSFunction>::cast(self);
4265   } else {
4266     i::Handle<i::Object> delegate;
4267     has_pending_exception = !i::Execution::TryGetFunctionDelegate(isolate, self)
4268                                  .ToHandle(&delegate);
4269     RETURN_ON_FAILED_EXECUTION(Value);
4270     fun = i::Handle<i::JSFunction>::cast(delegate);
4271     recv_obj = self;
4272   }
4273   Local<Value> result;
4274   has_pending_exception =
4275       !ToLocal<Value>(
4276           i::Execution::Call(isolate, fun, recv_obj, argc, args, true),
4277           &result);
4278   RETURN_ON_FAILED_EXECUTION(Value);
4279   RETURN_ESCAPED(result);
4280 }
4281
4282
4283 Local<v8::Value> Object::CallAsFunction(v8::Local<v8::Value> recv, int argc,
4284                                         v8::Local<v8::Value> argv[]) {
4285   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4286   Local<Value>* argv_cast = reinterpret_cast<Local<Value>*>(argv);
4287   RETURN_TO_LOCAL_UNCHECKED(CallAsFunction(context, recv, argc, argv_cast),
4288                             Value);
4289 }
4290
4291
4292 MaybeLocal<Value> Object::CallAsConstructor(Local<Context> context, int argc,
4293                                             Local<Value> argv[]) {
4294   PREPARE_FOR_EXECUTION_WITH_CALLBACK(context,
4295                                       "v8::Object::CallAsConstructor()", Value);
4296   i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
4297   auto self = Utils::OpenHandle(this);
4298   STATIC_ASSERT(sizeof(v8::Local<v8::Value>) == sizeof(i::Object**));
4299   i::Handle<i::Object>* args = reinterpret_cast<i::Handle<i::Object>*>(argv);
4300   if (self->IsJSFunction()) {
4301     auto fun = i::Handle<i::JSFunction>::cast(self);
4302     Local<Value> result;
4303     has_pending_exception =
4304         !ToLocal<Value>(i::Execution::New(fun, argc, args), &result);
4305     RETURN_ON_FAILED_EXECUTION(Value);
4306     RETURN_ESCAPED(result);
4307   }
4308   i::Handle<i::Object> delegate;
4309   has_pending_exception = !i::Execution::TryGetConstructorDelegate(
4310                                isolate, self).ToHandle(&delegate);
4311   RETURN_ON_FAILED_EXECUTION(Value);
4312   if (!delegate->IsUndefined()) {
4313     auto fun = i::Handle<i::JSFunction>::cast(delegate);
4314     Local<Value> result;
4315     has_pending_exception =
4316         !ToLocal<Value>(i::Execution::Call(isolate, fun, self, argc, args),
4317                         &result);
4318     RETURN_ON_FAILED_EXECUTION(Value);
4319     DCHECK(!delegate->IsUndefined());
4320     RETURN_ESCAPED(result);
4321   }
4322   return MaybeLocal<Value>();
4323 }
4324
4325
4326 Local<v8::Value> Object::CallAsConstructor(int argc,
4327                                            v8::Local<v8::Value> argv[]) {
4328   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4329   Local<Value>* argv_cast = reinterpret_cast<Local<Value>*>(argv);
4330   RETURN_TO_LOCAL_UNCHECKED(CallAsConstructor(context, argc, argv_cast), Value);
4331 }
4332
4333
4334 MaybeLocal<Function> Function::New(Local<Context> context,
4335                                    FunctionCallback callback, Local<Value> data,
4336                                    int length) {
4337   i::Isolate* isolate = Utils::OpenHandle(*context)->GetIsolate();
4338   LOG_API(isolate, "Function::New");
4339   ENTER_V8(isolate);
4340   return FunctionTemplateNew(isolate, callback, data, Local<Signature>(),
4341                              length, true)->GetFunction(context);
4342 }
4343
4344
4345 Local<Function> Function::New(Isolate* v8_isolate, FunctionCallback callback,
4346                               Local<Value> data, int length) {
4347   return Function::New(v8_isolate->GetCurrentContext(), callback, data, length)
4348       .FromMaybe(Local<Function>());
4349 }
4350
4351
4352 Local<v8::Object> Function::NewInstance() const {
4353   return NewInstance(Isolate::GetCurrent()->GetCurrentContext(), 0, NULL)
4354       .FromMaybe(Local<Object>());
4355 }
4356
4357
4358 MaybeLocal<Object> Function::NewInstance(Local<Context> context, int argc,
4359                                          v8::Local<v8::Value> argv[]) const {
4360   PREPARE_FOR_EXECUTION_WITH_CALLBACK(context, "v8::Function::NewInstance()",
4361                                       Object);
4362   i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
4363   auto self = Utils::OpenHandle(this);
4364   STATIC_ASSERT(sizeof(v8::Local<v8::Value>) == sizeof(i::Object**));
4365   i::Handle<i::Object>* args = reinterpret_cast<i::Handle<i::Object>*>(argv);
4366   Local<Object> result;
4367   has_pending_exception =
4368       !ToLocal<Object>(i::Execution::New(self, argc, args), &result);
4369   RETURN_ON_FAILED_EXECUTION(Object);
4370   RETURN_ESCAPED(result);
4371 }
4372
4373
4374 Local<v8::Object> Function::NewInstance(int argc,
4375                                         v8::Local<v8::Value> argv[]) const {
4376   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4377   RETURN_TO_LOCAL_UNCHECKED(NewInstance(context, argc, argv), Object);
4378 }
4379
4380
4381 MaybeLocal<v8::Value> Function::Call(Local<Context> context,
4382                                      v8::Local<v8::Value> recv, int argc,
4383                                      v8::Local<v8::Value> argv[]) {
4384   PREPARE_FOR_EXECUTION_WITH_CALLBACK(context, "v8::Function::Call()", Value);
4385   i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
4386   auto self = Utils::OpenHandle(this);
4387   i::Handle<i::Object> recv_obj = Utils::OpenHandle(*recv);
4388   STATIC_ASSERT(sizeof(v8::Local<v8::Value>) == sizeof(i::Object**));
4389   i::Handle<i::Object>* args = reinterpret_cast<i::Handle<i::Object>*>(argv);
4390   Local<Value> result;
4391   has_pending_exception =
4392       !ToLocal<Value>(
4393           i::Execution::Call(isolate, self, recv_obj, argc, args, true),
4394           &result);
4395   RETURN_ON_FAILED_EXECUTION(Value);
4396   RETURN_ESCAPED(result);
4397 }
4398
4399
4400 Local<v8::Value> Function::Call(v8::Local<v8::Value> recv, int argc,
4401                                 v8::Local<v8::Value> argv[]) {
4402   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4403   RETURN_TO_LOCAL_UNCHECKED(Call(context, recv, argc, argv), Value);
4404 }
4405
4406
4407 void Function::SetName(v8::Local<v8::String> name) {
4408   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
4409   func->shared()->set_name(*Utils::OpenHandle(*name));
4410 }
4411
4412
4413 Local<Value> Function::GetName() const {
4414   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
4415   return Utils::ToLocal(i::Handle<i::Object>(func->shared()->name(),
4416                                              func->GetIsolate()));
4417 }
4418
4419
4420 Local<Value> Function::GetInferredName() const {
4421   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
4422   return Utils::ToLocal(i::Handle<i::Object>(func->shared()->inferred_name(),
4423                                              func->GetIsolate()));
4424 }
4425
4426
4427 Local<Value> Function::GetDisplayName() const {
4428   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
4429   ENTER_V8(isolate);
4430   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
4431   i::Handle<i::String> property_name =
4432       isolate->factory()->NewStringFromStaticChars("displayName");
4433   i::Handle<i::Object> value =
4434       i::JSReceiver::GetDataProperty(func, property_name);
4435   if (value->IsString()) {
4436     i::Handle<i::String> name = i::Handle<i::String>::cast(value);
4437     if (name->length() > 0) return Utils::ToLocal(name);
4438   }
4439   return ToApiHandle<Primitive>(isolate->factory()->undefined_value());
4440 }
4441
4442
4443 ScriptOrigin Function::GetScriptOrigin() const {
4444   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
4445   if (func->shared()->script()->IsScript()) {
4446     i::Handle<i::Script> script(i::Script::cast(func->shared()->script()));
4447     return GetScriptOriginForScript(func->GetIsolate(), script);
4448   }
4449   return v8::ScriptOrigin(Local<Value>());
4450 }
4451
4452
4453 const int Function::kLineOffsetNotFound = -1;
4454
4455
4456 int Function::GetScriptLineNumber() const {
4457   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
4458   if (func->shared()->script()->IsScript()) {
4459     i::Handle<i::Script> script(i::Script::cast(func->shared()->script()));
4460     return i::Script::GetLineNumber(script, func->shared()->start_position());
4461   }
4462   return kLineOffsetNotFound;
4463 }
4464
4465
4466 int Function::GetScriptColumnNumber() const {
4467   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
4468   if (func->shared()->script()->IsScript()) {
4469     i::Handle<i::Script> script(i::Script::cast(func->shared()->script()));
4470     return i::Script::GetColumnNumber(script, func->shared()->start_position());
4471   }
4472   return kLineOffsetNotFound;
4473 }
4474
4475
4476 bool Function::IsBuiltin() const {
4477   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
4478   return func->IsBuiltin();
4479 }
4480
4481
4482 int Function::ScriptId() const {
4483   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
4484   if (!func->shared()->script()->IsScript()) {
4485     return v8::UnboundScript::kNoScriptId;
4486   }
4487   i::Handle<i::Script> script(i::Script::cast(func->shared()->script()));
4488   return script->id()->value();
4489 }
4490
4491
4492 Local<v8::Value> Function::GetBoundFunction() const {
4493   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
4494   if (!func->shared()->bound()) {
4495     return v8::Undefined(reinterpret_cast<v8::Isolate*>(func->GetIsolate()));
4496   }
4497   i::Handle<i::FixedArray> bound_args = i::Handle<i::FixedArray>(
4498       i::FixedArray::cast(func->function_bindings()));
4499   i::Handle<i::Object> original(
4500       bound_args->get(i::JSFunction::kBoundFunctionIndex),
4501       func->GetIsolate());
4502   return Utils::ToLocal(i::Handle<i::JSFunction>::cast(original));
4503 }
4504
4505
4506 int Name::GetIdentityHash() {
4507   auto self = Utils::OpenHandle(this);
4508   return static_cast<int>(self->Hash());
4509 }
4510
4511
4512 int String::Length() const {
4513   i::Handle<i::String> str = Utils::OpenHandle(this);
4514   return str->length();
4515 }
4516
4517
4518 bool String::IsOneByte() const {
4519   i::Handle<i::String> str = Utils::OpenHandle(this);
4520   return str->HasOnlyOneByteChars();
4521 }
4522
4523
4524 // Helpers for ContainsOnlyOneByteHelper
4525 template<size_t size> struct OneByteMask;
4526 template<> struct OneByteMask<4> {
4527   static const uint32_t value = 0xFF00FF00;
4528 };
4529 template<> struct OneByteMask<8> {
4530   static const uint64_t value = V8_2PART_UINT64_C(0xFF00FF00, FF00FF00);
4531 };
4532 static const uintptr_t kOneByteMask = OneByteMask<sizeof(uintptr_t)>::value;
4533 static const uintptr_t kAlignmentMask = sizeof(uintptr_t) - 1;
4534 static inline bool Unaligned(const uint16_t* chars) {
4535   return reinterpret_cast<const uintptr_t>(chars) & kAlignmentMask;
4536 }
4537
4538
4539 static inline const uint16_t* Align(const uint16_t* chars) {
4540   return reinterpret_cast<uint16_t*>(
4541       reinterpret_cast<uintptr_t>(chars) & ~kAlignmentMask);
4542 }
4543
4544 class ContainsOnlyOneByteHelper {
4545  public:
4546   ContainsOnlyOneByteHelper() : is_one_byte_(true) {}
4547   bool Check(i::String* string) {
4548     i::ConsString* cons_string = i::String::VisitFlat(this, string, 0);
4549     if (cons_string == NULL) return is_one_byte_;
4550     return CheckCons(cons_string);
4551   }
4552   void VisitOneByteString(const uint8_t* chars, int length) {
4553     // Nothing to do.
4554   }
4555   void VisitTwoByteString(const uint16_t* chars, int length) {
4556     // Accumulated bits.
4557     uintptr_t acc = 0;
4558     // Align to uintptr_t.
4559     const uint16_t* end = chars + length;
4560     while (Unaligned(chars) && chars != end) {
4561       acc |= *chars++;
4562     }
4563     // Read word aligned in blocks,
4564     // checking the return value at the end of each block.
4565     const uint16_t* aligned_end = Align(end);
4566     const int increment = sizeof(uintptr_t)/sizeof(uint16_t);
4567     const int inner_loops = 16;
4568     while (chars + inner_loops*increment < aligned_end) {
4569       for (int i = 0; i < inner_loops; i++) {
4570         acc |= *reinterpret_cast<const uintptr_t*>(chars);
4571         chars += increment;
4572       }
4573       // Check for early return.
4574       if ((acc & kOneByteMask) != 0) {
4575         is_one_byte_ = false;
4576         return;
4577       }
4578     }
4579     // Read the rest.
4580     while (chars != end) {
4581       acc |= *chars++;
4582     }
4583     // Check result.
4584     if ((acc & kOneByteMask) != 0) is_one_byte_ = false;
4585   }
4586
4587  private:
4588   bool CheckCons(i::ConsString* cons_string) {
4589     while (true) {
4590       // Check left side if flat.
4591       i::String* left = cons_string->first();
4592       i::ConsString* left_as_cons =
4593           i::String::VisitFlat(this, left, 0);
4594       if (!is_one_byte_) return false;
4595       // Check right side if flat.
4596       i::String* right = cons_string->second();
4597       i::ConsString* right_as_cons =
4598           i::String::VisitFlat(this, right, 0);
4599       if (!is_one_byte_) return false;
4600       // Standard recurse/iterate trick.
4601       if (left_as_cons != NULL && right_as_cons != NULL) {
4602         if (left->length() < right->length()) {
4603           CheckCons(left_as_cons);
4604           cons_string = right_as_cons;
4605         } else {
4606           CheckCons(right_as_cons);
4607           cons_string = left_as_cons;
4608         }
4609         // Check fast return.
4610         if (!is_one_byte_) return false;
4611         continue;
4612       }
4613       // Descend left in place.
4614       if (left_as_cons != NULL) {
4615         cons_string = left_as_cons;
4616         continue;
4617       }
4618       // Descend right in place.
4619       if (right_as_cons != NULL) {
4620         cons_string = right_as_cons;
4621         continue;
4622       }
4623       // Terminate.
4624       break;
4625     }
4626     return is_one_byte_;
4627   }
4628   bool is_one_byte_;
4629   DISALLOW_COPY_AND_ASSIGN(ContainsOnlyOneByteHelper);
4630 };
4631
4632
4633 bool String::ContainsOnlyOneByte() const {
4634   i::Handle<i::String> str = Utils::OpenHandle(this);
4635   if (str->HasOnlyOneByteChars()) return true;
4636   ContainsOnlyOneByteHelper helper;
4637   return helper.Check(*str);
4638 }
4639
4640
4641 class Utf8LengthHelper : public i::AllStatic {
4642  public:
4643   enum State {
4644     kEndsWithLeadingSurrogate = 1 << 0,
4645     kStartsWithTrailingSurrogate = 1 << 1,
4646     kLeftmostEdgeIsCalculated = 1 << 2,
4647     kRightmostEdgeIsCalculated = 1 << 3,
4648     kLeftmostEdgeIsSurrogate = 1 << 4,
4649     kRightmostEdgeIsSurrogate = 1 << 5
4650   };
4651
4652   static const uint8_t kInitialState = 0;
4653
4654   static inline bool EndsWithSurrogate(uint8_t state) {
4655     return state & kEndsWithLeadingSurrogate;
4656   }
4657
4658   static inline bool StartsWithSurrogate(uint8_t state) {
4659     return state & kStartsWithTrailingSurrogate;
4660   }
4661
4662   class Visitor {
4663    public:
4664     Visitor() : utf8_length_(0), state_(kInitialState) {}
4665
4666     void VisitOneByteString(const uint8_t* chars, int length) {
4667       int utf8_length = 0;
4668       // Add in length 1 for each non-Latin1 character.
4669       for (int i = 0; i < length; i++) {
4670         utf8_length += *chars++ >> 7;
4671       }
4672       // Add in length 1 for each character.
4673       utf8_length_ = utf8_length + length;
4674       state_ = kInitialState;
4675     }
4676
4677     void VisitTwoByteString(const uint16_t* chars, int length) {
4678       int utf8_length = 0;
4679       int last_character = unibrow::Utf16::kNoPreviousCharacter;
4680       for (int i = 0; i < length; i++) {
4681         uint16_t c = chars[i];
4682         utf8_length += unibrow::Utf8::Length(c, last_character);
4683         last_character = c;
4684       }
4685       utf8_length_ = utf8_length;
4686       uint8_t state = 0;
4687       if (unibrow::Utf16::IsTrailSurrogate(chars[0])) {
4688         state |= kStartsWithTrailingSurrogate;
4689       }
4690       if (unibrow::Utf16::IsLeadSurrogate(chars[length-1])) {
4691         state |= kEndsWithLeadingSurrogate;
4692       }
4693       state_ = state;
4694     }
4695
4696     static i::ConsString* VisitFlat(i::String* string,
4697                                     int* length,
4698                                     uint8_t* state) {
4699       Visitor visitor;
4700       i::ConsString* cons_string = i::String::VisitFlat(&visitor, string);
4701       *length = visitor.utf8_length_;
4702       *state = visitor.state_;
4703       return cons_string;
4704     }
4705
4706    private:
4707     int utf8_length_;
4708     uint8_t state_;
4709     DISALLOW_COPY_AND_ASSIGN(Visitor);
4710   };
4711
4712   static inline void MergeLeafLeft(int* length,
4713                                    uint8_t* state,
4714                                    uint8_t leaf_state) {
4715     bool edge_surrogate = StartsWithSurrogate(leaf_state);
4716     if (!(*state & kLeftmostEdgeIsCalculated)) {
4717       DCHECK(!(*state & kLeftmostEdgeIsSurrogate));
4718       *state |= kLeftmostEdgeIsCalculated
4719           | (edge_surrogate ? kLeftmostEdgeIsSurrogate : 0);
4720     } else if (EndsWithSurrogate(*state) && edge_surrogate) {
4721       *length -= unibrow::Utf8::kBytesSavedByCombiningSurrogates;
4722     }
4723     if (EndsWithSurrogate(leaf_state)) {
4724       *state |= kEndsWithLeadingSurrogate;
4725     } else {
4726       *state &= ~kEndsWithLeadingSurrogate;
4727     }
4728   }
4729
4730   static inline void MergeLeafRight(int* length,
4731                                     uint8_t* state,
4732                                     uint8_t leaf_state) {
4733     bool edge_surrogate = EndsWithSurrogate(leaf_state);
4734     if (!(*state & kRightmostEdgeIsCalculated)) {
4735       DCHECK(!(*state & kRightmostEdgeIsSurrogate));
4736       *state |= (kRightmostEdgeIsCalculated
4737                  | (edge_surrogate ? kRightmostEdgeIsSurrogate : 0));
4738     } else if (edge_surrogate && StartsWithSurrogate(*state)) {
4739       *length -= unibrow::Utf8::kBytesSavedByCombiningSurrogates;
4740     }
4741     if (StartsWithSurrogate(leaf_state)) {
4742       *state |= kStartsWithTrailingSurrogate;
4743     } else {
4744       *state &= ~kStartsWithTrailingSurrogate;
4745     }
4746   }
4747
4748   static inline void MergeTerminal(int* length,
4749                                    uint8_t state,
4750                                    uint8_t* state_out) {
4751     DCHECK((state & kLeftmostEdgeIsCalculated) &&
4752            (state & kRightmostEdgeIsCalculated));
4753     if (EndsWithSurrogate(state) && StartsWithSurrogate(state)) {
4754       *length -= unibrow::Utf8::kBytesSavedByCombiningSurrogates;
4755     }
4756     *state_out = kInitialState |
4757         (state & kLeftmostEdgeIsSurrogate ? kStartsWithTrailingSurrogate : 0) |
4758         (state & kRightmostEdgeIsSurrogate ? kEndsWithLeadingSurrogate : 0);
4759   }
4760
4761   static int Calculate(i::ConsString* current, uint8_t* state_out) {
4762     using namespace internal;
4763     int total_length = 0;
4764     uint8_t state = kInitialState;
4765     while (true) {
4766       i::String* left = current->first();
4767       i::String* right = current->second();
4768       uint8_t right_leaf_state;
4769       uint8_t left_leaf_state;
4770       int leaf_length;
4771       ConsString* left_as_cons =
4772           Visitor::VisitFlat(left, &leaf_length, &left_leaf_state);
4773       if (left_as_cons == NULL) {
4774         total_length += leaf_length;
4775         MergeLeafLeft(&total_length, &state, left_leaf_state);
4776       }
4777       ConsString* right_as_cons =
4778           Visitor::VisitFlat(right, &leaf_length, &right_leaf_state);
4779       if (right_as_cons == NULL) {
4780         total_length += leaf_length;
4781         MergeLeafRight(&total_length, &state, right_leaf_state);
4782         if (left_as_cons != NULL) {
4783           // 1 Leaf node. Descend in place.
4784           current = left_as_cons;
4785           continue;
4786         } else {
4787           // Terminal node.
4788           MergeTerminal(&total_length, state, state_out);
4789           return total_length;
4790         }
4791       } else if (left_as_cons == NULL) {
4792         // 1 Leaf node. Descend in place.
4793         current = right_as_cons;
4794         continue;
4795       }
4796       // Both strings are ConsStrings.
4797       // Recurse on smallest.
4798       if (left->length() < right->length()) {
4799         total_length += Calculate(left_as_cons, &left_leaf_state);
4800         MergeLeafLeft(&total_length, &state, left_leaf_state);
4801         current = right_as_cons;
4802       } else {
4803         total_length += Calculate(right_as_cons, &right_leaf_state);
4804         MergeLeafRight(&total_length, &state, right_leaf_state);
4805         current = left_as_cons;
4806       }
4807     }
4808     UNREACHABLE();
4809     return 0;
4810   }
4811
4812   static inline int Calculate(i::ConsString* current) {
4813     uint8_t state = kInitialState;
4814     return Calculate(current, &state);
4815   }
4816
4817  private:
4818   DISALLOW_IMPLICIT_CONSTRUCTORS(Utf8LengthHelper);
4819 };
4820
4821
4822 static int Utf8Length(i::String* str, i::Isolate* isolate) {
4823   int length = str->length();
4824   if (length == 0) return 0;
4825   uint8_t state;
4826   i::ConsString* cons_string =
4827       Utf8LengthHelper::Visitor::VisitFlat(str, &length, &state);
4828   if (cons_string == NULL) return length;
4829   return Utf8LengthHelper::Calculate(cons_string);
4830 }
4831
4832
4833 int String::Utf8Length() const {
4834   i::Handle<i::String> str = Utils::OpenHandle(this);
4835   i::Isolate* isolate = str->GetIsolate();
4836   return v8::Utf8Length(*str, isolate);
4837 }
4838
4839
4840 class Utf8WriterVisitor {
4841  public:
4842   Utf8WriterVisitor(
4843       char* buffer,
4844       int capacity,
4845       bool skip_capacity_check,
4846       bool replace_invalid_utf8)
4847     : early_termination_(false),
4848       last_character_(unibrow::Utf16::kNoPreviousCharacter),
4849       buffer_(buffer),
4850       start_(buffer),
4851       capacity_(capacity),
4852       skip_capacity_check_(capacity == -1 || skip_capacity_check),
4853       replace_invalid_utf8_(replace_invalid_utf8),
4854       utf16_chars_read_(0) {
4855   }
4856
4857   static int WriteEndCharacter(uint16_t character,
4858                                int last_character,
4859                                int remaining,
4860                                char* const buffer,
4861                                bool replace_invalid_utf8) {
4862     using namespace unibrow;
4863     DCHECK(remaining > 0);
4864     // We can't use a local buffer here because Encode needs to modify
4865     // previous characters in the stream.  We know, however, that
4866     // exactly one character will be advanced.
4867     if (Utf16::IsSurrogatePair(last_character, character)) {
4868       int written = Utf8::Encode(buffer,
4869                                  character,
4870                                  last_character,
4871                                  replace_invalid_utf8);
4872       DCHECK(written == 1);
4873       return written;
4874     }
4875     // Use a scratch buffer to check the required characters.
4876     char temp_buffer[Utf8::kMaxEncodedSize];
4877     // Can't encode using last_character as gcc has array bounds issues.
4878     int written = Utf8::Encode(temp_buffer,
4879                                character,
4880                                Utf16::kNoPreviousCharacter,
4881                                replace_invalid_utf8);
4882     // Won't fit.
4883     if (written > remaining) return 0;
4884     // Copy over the character from temp_buffer.
4885     for (int j = 0; j < written; j++) {
4886       buffer[j] = temp_buffer[j];
4887     }
4888     return written;
4889   }
4890
4891   // Visit writes out a group of code units (chars) of a v8::String to the
4892   // internal buffer_. This is done in two phases. The first phase calculates a
4893   // pesimistic estimate (writable_length) on how many code units can be safely
4894   // written without exceeding the buffer capacity and without writing the last
4895   // code unit (it could be a lead surrogate). The estimated number of code
4896   // units is then written out in one go, and the reported byte usage is used
4897   // to correct the estimate. This is repeated until the estimate becomes <= 0
4898   // or all code units have been written out. The second phase writes out code
4899   // units until the buffer capacity is reached, would be exceeded by the next
4900   // unit, or all units have been written out.
4901   template<typename Char>
4902   void Visit(const Char* chars, const int length) {
4903     using namespace unibrow;
4904     DCHECK(!early_termination_);
4905     if (length == 0) return;
4906     // Copy state to stack.
4907     char* buffer = buffer_;
4908     int last_character =
4909         sizeof(Char) == 1 ? Utf16::kNoPreviousCharacter : last_character_;
4910     int i = 0;
4911     // Do a fast loop where there is no exit capacity check.
4912     while (true) {
4913       int fast_length;
4914       if (skip_capacity_check_) {
4915         fast_length = length;
4916       } else {
4917         int remaining_capacity = capacity_ - static_cast<int>(buffer - start_);
4918         // Need enough space to write everything but one character.
4919         STATIC_ASSERT(Utf16::kMaxExtraUtf8BytesForOneUtf16CodeUnit == 3);
4920         int max_size_per_char =  sizeof(Char) == 1 ? 2 : 3;
4921         int writable_length =
4922             (remaining_capacity - max_size_per_char)/max_size_per_char;
4923         // Need to drop into slow loop.
4924         if (writable_length <= 0) break;
4925         fast_length = i + writable_length;
4926         if (fast_length > length) fast_length = length;
4927       }
4928       // Write the characters to the stream.
4929       if (sizeof(Char) == 1) {
4930         for (; i < fast_length; i++) {
4931           buffer +=
4932               Utf8::EncodeOneByte(buffer, static_cast<uint8_t>(*chars++));
4933           DCHECK(capacity_ == -1 || (buffer - start_) <= capacity_);
4934         }
4935       } else {
4936         for (; i < fast_length; i++) {
4937           uint16_t character = *chars++;
4938           buffer += Utf8::Encode(buffer,
4939                                  character,
4940                                  last_character,
4941                                  replace_invalid_utf8_);
4942           last_character = character;
4943           DCHECK(capacity_ == -1 || (buffer - start_) <= capacity_);
4944         }
4945       }
4946       // Array is fully written. Exit.
4947       if (fast_length == length) {
4948         // Write state back out to object.
4949         last_character_ = last_character;
4950         buffer_ = buffer;
4951         utf16_chars_read_ += length;
4952         return;
4953       }
4954     }
4955     DCHECK(!skip_capacity_check_);
4956     // Slow loop. Must check capacity on each iteration.
4957     int remaining_capacity = capacity_ - static_cast<int>(buffer - start_);
4958     DCHECK(remaining_capacity >= 0);
4959     for (; i < length && remaining_capacity > 0; i++) {
4960       uint16_t character = *chars++;
4961       // remaining_capacity is <= 3 bytes at this point, so we do not write out
4962       // an umatched lead surrogate.
4963       if (replace_invalid_utf8_ && Utf16::IsLeadSurrogate(character)) {
4964         early_termination_ = true;
4965         break;
4966       }
4967       int written = WriteEndCharacter(character,
4968                                       last_character,
4969                                       remaining_capacity,
4970                                       buffer,
4971                                       replace_invalid_utf8_);
4972       if (written == 0) {
4973         early_termination_ = true;
4974         break;
4975       }
4976       buffer += written;
4977       remaining_capacity -= written;
4978       last_character = character;
4979     }
4980     // Write state back out to object.
4981     last_character_ = last_character;
4982     buffer_ = buffer;
4983     utf16_chars_read_ += i;
4984   }
4985
4986   inline bool IsDone() {
4987     return early_termination_;
4988   }
4989
4990   inline void VisitOneByteString(const uint8_t* chars, int length) {
4991     Visit(chars, length);
4992   }
4993
4994   inline void VisitTwoByteString(const uint16_t* chars, int length) {
4995     Visit(chars, length);
4996   }
4997
4998   int CompleteWrite(bool write_null, int* utf16_chars_read_out) {
4999     // Write out number of utf16 characters written to the stream.
5000     if (utf16_chars_read_out != NULL) {
5001       *utf16_chars_read_out = utf16_chars_read_;
5002     }
5003     // Only null terminate if all of the string was written and there's space.
5004     if (write_null &&
5005         !early_termination_ &&
5006         (capacity_ == -1 || (buffer_ - start_) < capacity_)) {
5007       *buffer_++ = '\0';
5008     }
5009     return static_cast<int>(buffer_ - start_);
5010   }
5011
5012  private:
5013   bool early_termination_;
5014   int last_character_;
5015   char* buffer_;
5016   char* const start_;
5017   int capacity_;
5018   bool const skip_capacity_check_;
5019   bool const replace_invalid_utf8_;
5020   int utf16_chars_read_;
5021   DISALLOW_IMPLICIT_CONSTRUCTORS(Utf8WriterVisitor);
5022 };
5023
5024
5025 static bool RecursivelySerializeToUtf8(i::String* current,
5026                                        Utf8WriterVisitor* writer,
5027                                        int recursion_budget) {
5028   while (!writer->IsDone()) {
5029     i::ConsString* cons_string = i::String::VisitFlat(writer, current);
5030     if (cons_string == NULL) return true;  // Leaf node.
5031     if (recursion_budget <= 0) return false;
5032     // Must write the left branch first.
5033     i::String* first = cons_string->first();
5034     bool success = RecursivelySerializeToUtf8(first,
5035                                               writer,
5036                                               recursion_budget - 1);
5037     if (!success) return false;
5038     // Inline tail recurse for right branch.
5039     current = cons_string->second();
5040   }
5041   return true;
5042 }
5043
5044
5045 int String::WriteUtf8(char* buffer,
5046                       int capacity,
5047                       int* nchars_ref,
5048                       int options) const {
5049   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
5050   LOG_API(isolate, "String::WriteUtf8");
5051   ENTER_V8(isolate);
5052   i::Handle<i::String> str = Utils::OpenHandle(this);
5053   if (options & HINT_MANY_WRITES_EXPECTED) {
5054     str = i::String::Flatten(str);  // Flatten the string for efficiency.
5055   }
5056   const int string_length = str->length();
5057   bool write_null = !(options & NO_NULL_TERMINATION);
5058   bool replace_invalid_utf8 = (options & REPLACE_INVALID_UTF8);
5059   int max16BitCodeUnitSize = unibrow::Utf8::kMax16BitCodeUnitSize;
5060   // First check if we can just write the string without checking capacity.
5061   if (capacity == -1 || capacity / max16BitCodeUnitSize >= string_length) {
5062     Utf8WriterVisitor writer(buffer, capacity, true, replace_invalid_utf8);
5063     const int kMaxRecursion = 100;
5064     bool success = RecursivelySerializeToUtf8(*str, &writer, kMaxRecursion);
5065     if (success) return writer.CompleteWrite(write_null, nchars_ref);
5066   } else if (capacity >= string_length) {
5067     // First check that the buffer is large enough.
5068     int utf8_bytes = v8::Utf8Length(*str, str->GetIsolate());
5069     if (utf8_bytes <= capacity) {
5070       // one-byte fast path.
5071       if (utf8_bytes == string_length) {
5072         WriteOneByte(reinterpret_cast<uint8_t*>(buffer), 0, capacity, options);
5073         if (nchars_ref != NULL) *nchars_ref = string_length;
5074         if (write_null && (utf8_bytes+1 <= capacity)) {
5075           return string_length + 1;
5076         }
5077         return string_length;
5078       }
5079       if (write_null && (utf8_bytes+1 > capacity)) {
5080         options |= NO_NULL_TERMINATION;
5081       }
5082       // Recurse once without a capacity limit.
5083       // This will get into the first branch above.
5084       // TODO(dcarney) Check max left rec. in Utf8Length and fall through.
5085       return WriteUtf8(buffer, -1, nchars_ref, options);
5086     }
5087   }
5088   // Recursive slow path can potentially be unreasonable slow. Flatten.
5089   str = i::String::Flatten(str);
5090   Utf8WriterVisitor writer(buffer, capacity, false, replace_invalid_utf8);
5091   i::String::VisitFlat(&writer, *str);
5092   return writer.CompleteWrite(write_null, nchars_ref);
5093 }
5094
5095
5096 template<typename CharType>
5097 static inline int WriteHelper(const String* string,
5098                               CharType* buffer,
5099                               int start,
5100                               int length,
5101                               int options) {
5102   i::Isolate* isolate = Utils::OpenHandle(string)->GetIsolate();
5103   LOG_API(isolate, "String::Write");
5104   ENTER_V8(isolate);
5105   DCHECK(start >= 0 && length >= -1);
5106   i::Handle<i::String> str = Utils::OpenHandle(string);
5107   if (options & String::HINT_MANY_WRITES_EXPECTED) {
5108     // Flatten the string for efficiency.  This applies whether we are
5109     // using StringCharacterStream or Get(i) to access the characters.
5110     str = i::String::Flatten(str);
5111   }
5112   int end = start + length;
5113   if ((length == -1) || (length > str->length() - start) )
5114     end = str->length();
5115   if (end < 0) return 0;
5116   i::String::WriteToFlat(*str, buffer, start, end);
5117   if (!(options & String::NO_NULL_TERMINATION) &&
5118       (length == -1 || end - start < length)) {
5119     buffer[end - start] = '\0';
5120   }
5121   return end - start;
5122 }
5123
5124
5125 int String::WriteOneByte(uint8_t* buffer,
5126                          int start,
5127                          int length,
5128                          int options) const {
5129   return WriteHelper(this, buffer, start, length, options);
5130 }
5131
5132
5133 int String::Write(uint16_t* buffer,
5134                   int start,
5135                   int length,
5136                   int options) const {
5137   return WriteHelper(this, buffer, start, length, options);
5138 }
5139
5140
5141 bool v8::String::IsExternal() const {
5142   i::Handle<i::String> str = Utils::OpenHandle(this);
5143   return i::StringShape(*str).IsExternalTwoByte();
5144 }
5145
5146
5147 bool v8::String::IsExternalOneByte() const {
5148   i::Handle<i::String> str = Utils::OpenHandle(this);
5149   return i::StringShape(*str).IsExternalOneByte();
5150 }
5151
5152
5153 void v8::String::VerifyExternalStringResource(
5154     v8::String::ExternalStringResource* value) const {
5155   i::Handle<i::String> str = Utils::OpenHandle(this);
5156   const v8::String::ExternalStringResource* expected;
5157   if (i::StringShape(*str).IsExternalTwoByte()) {
5158     const void* resource =
5159         i::Handle<i::ExternalTwoByteString>::cast(str)->resource();
5160     expected = reinterpret_cast<const ExternalStringResource*>(resource);
5161   } else {
5162     expected = NULL;
5163   }
5164   CHECK_EQ(expected, value);
5165 }
5166
5167 void v8::String::VerifyExternalStringResourceBase(
5168     v8::String::ExternalStringResourceBase* value, Encoding encoding) const {
5169   i::Handle<i::String> str = Utils::OpenHandle(this);
5170   const v8::String::ExternalStringResourceBase* expected;
5171   Encoding expectedEncoding;
5172   if (i::StringShape(*str).IsExternalOneByte()) {
5173     const void* resource =
5174         i::Handle<i::ExternalOneByteString>::cast(str)->resource();
5175     expected = reinterpret_cast<const ExternalStringResourceBase*>(resource);
5176     expectedEncoding = ONE_BYTE_ENCODING;
5177   } else if (i::StringShape(*str).IsExternalTwoByte()) {
5178     const void* resource =
5179         i::Handle<i::ExternalTwoByteString>::cast(str)->resource();
5180     expected = reinterpret_cast<const ExternalStringResourceBase*>(resource);
5181     expectedEncoding = TWO_BYTE_ENCODING;
5182   } else {
5183     expected = NULL;
5184     expectedEncoding =
5185         str->IsOneByteRepresentation() ? ONE_BYTE_ENCODING : TWO_BYTE_ENCODING;
5186   }
5187   CHECK_EQ(expected, value);
5188   CHECK_EQ(expectedEncoding, encoding);
5189 }
5190
5191 const v8::String::ExternalOneByteStringResource*
5192 v8::String::GetExternalOneByteStringResource() const {
5193   i::Handle<i::String> str = Utils::OpenHandle(this);
5194   if (i::StringShape(*str).IsExternalOneByte()) {
5195     const void* resource =
5196         i::Handle<i::ExternalOneByteString>::cast(str)->resource();
5197     return reinterpret_cast<const ExternalOneByteStringResource*>(resource);
5198   } else {
5199     return NULL;
5200   }
5201 }
5202
5203
5204 Local<Value> Symbol::Name() const {
5205   i::Handle<i::Symbol> sym = Utils::OpenHandle(this);
5206   i::Handle<i::Object> name(sym->name(), sym->GetIsolate());
5207   return Utils::ToLocal(name);
5208 }
5209
5210
5211 double Number::Value() const {
5212   i::Handle<i::Object> obj = Utils::OpenHandle(this);
5213   return obj->Number();
5214 }
5215
5216
5217 bool Boolean::Value() const {
5218   i::Handle<i::Object> obj = Utils::OpenHandle(this);
5219   return obj->IsTrue();
5220 }
5221
5222
5223 int64_t Integer::Value() const {
5224   i::Handle<i::Object> obj = Utils::OpenHandle(this);
5225   if (obj->IsSmi()) {
5226     return i::Smi::cast(*obj)->value();
5227   } else {
5228     return static_cast<int64_t>(obj->Number());
5229   }
5230 }
5231
5232
5233 int32_t Int32::Value() const {
5234   i::Handle<i::Object> obj = Utils::OpenHandle(this);
5235   if (obj->IsSmi()) {
5236     return i::Smi::cast(*obj)->value();
5237   } else {
5238     return static_cast<int32_t>(obj->Number());
5239   }
5240 }
5241
5242
5243 uint32_t Uint32::Value() const {
5244   i::Handle<i::Object> obj = Utils::OpenHandle(this);
5245   if (obj->IsSmi()) {
5246     return i::Smi::cast(*obj)->value();
5247   } else {
5248     return static_cast<uint32_t>(obj->Number());
5249   }
5250 }
5251
5252
5253 int v8::Object::InternalFieldCount() {
5254   i::Handle<i::JSObject> obj = Utils::OpenHandle(this);
5255   return obj->GetInternalFieldCount();
5256 }
5257
5258
5259 static bool InternalFieldOK(i::Handle<i::JSObject> obj,
5260                             int index,
5261                             const char* location) {
5262   return Utils::ApiCheck(index < obj->GetInternalFieldCount(),
5263                          location,
5264                          "Internal field out of bounds");
5265 }
5266
5267
5268 Local<Value> v8::Object::SlowGetInternalField(int index) {
5269   i::Handle<i::JSObject> obj = Utils::OpenHandle(this);
5270   const char* location = "v8::Object::GetInternalField()";
5271   if (!InternalFieldOK(obj, index, location)) return Local<Value>();
5272   i::Handle<i::Object> value(obj->GetInternalField(index), obj->GetIsolate());
5273   return Utils::ToLocal(value);
5274 }
5275
5276
5277 void v8::Object::SetInternalField(int index, v8::Local<Value> value) {
5278   i::Handle<i::JSObject> obj = Utils::OpenHandle(this);
5279   const char* location = "v8::Object::SetInternalField()";
5280   if (!InternalFieldOK(obj, index, location)) return;
5281   i::Handle<i::Object> val = Utils::OpenHandle(*value);
5282   obj->SetInternalField(index, *val);
5283 }
5284
5285
5286 void* v8::Object::SlowGetAlignedPointerFromInternalField(int index) {
5287   i::Handle<i::JSObject> obj = Utils::OpenHandle(this);
5288   const char* location = "v8::Object::GetAlignedPointerFromInternalField()";
5289   if (!InternalFieldOK(obj, index, location)) return NULL;
5290   return DecodeSmiToAligned(obj->GetInternalField(index), location);
5291 }
5292
5293
5294 void v8::Object::SetAlignedPointerInInternalField(int index, void* value) {
5295   i::Handle<i::JSObject> obj = Utils::OpenHandle(this);
5296   const char* location = "v8::Object::SetAlignedPointerInInternalField()";
5297   if (!InternalFieldOK(obj, index, location)) return;
5298   obj->SetInternalField(index, EncodeAlignedAsSmi(value, location));
5299   DCHECK_EQ(value, GetAlignedPointerFromInternalField(index));
5300 }
5301
5302
5303 static void* ExternalValue(i::Object* obj) {
5304   // Obscure semantics for undefined, but somehow checked in our unit tests...
5305   if (obj->IsUndefined()) return NULL;
5306   i::Object* foreign = i::JSObject::cast(obj)->GetInternalField(0);
5307   return i::Foreign::cast(foreign)->foreign_address();
5308 }
5309
5310
5311 // --- E n v i r o n m e n t ---
5312
5313
5314 void v8::V8::InitializePlatform(Platform* platform) {
5315   i::V8::InitializePlatform(platform);
5316 }
5317
5318
5319 void v8::V8::ShutdownPlatform() {
5320   i::V8::ShutdownPlatform();
5321 }
5322
5323
5324 bool v8::V8::Initialize() {
5325   i::V8::Initialize();
5326 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
5327   i::ReadNatives();
5328 #endif
5329   return true;
5330 }
5331
5332
5333 void v8::V8::SetEntropySource(EntropySource entropy_source) {
5334   base::RandomNumberGenerator::SetEntropySource(entropy_source);
5335 }
5336
5337
5338 void v8::V8::SetReturnAddressLocationResolver(
5339     ReturnAddressLocationResolver return_address_resolver) {
5340   i::StackFrame::SetReturnAddressLocationResolver(return_address_resolver);
5341 }
5342
5343
5344 bool v8::V8::Dispose() {
5345   i::V8::TearDown();
5346 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
5347   i::DisposeNatives();
5348 #endif
5349   return true;
5350 }
5351
5352
5353 HeapStatistics::HeapStatistics(): total_heap_size_(0),
5354                                   total_heap_size_executable_(0),
5355                                   total_physical_size_(0),
5356                                   used_heap_size_(0),
5357                                   heap_size_limit_(0) { }
5358
5359
5360 HeapSpaceStatistics::HeapSpaceStatistics(): space_name_(0),
5361                                             space_size_(0),
5362                                             space_used_size_(0),
5363                                             space_available_size_(0),
5364                                             physical_space_size_(0) { }
5365
5366
5367 HeapObjectStatistics::HeapObjectStatistics()
5368     : object_type_(nullptr),
5369       object_sub_type_(nullptr),
5370       object_count_(0),
5371       object_size_(0) {}
5372
5373
5374 bool v8::V8::InitializeICU(const char* icu_data_file) {
5375   return i::InitializeICU(icu_data_file);
5376 }
5377
5378
5379 void v8::V8::InitializeExternalStartupData(const char* directory_path) {
5380   i::InitializeExternalStartupData(directory_path);
5381 }
5382
5383
5384 void v8::V8::InitializeExternalStartupData(const char* natives_blob,
5385                                            const char* snapshot_blob) {
5386   i::InitializeExternalStartupData(natives_blob, snapshot_blob);
5387 }
5388
5389
5390 const char* v8::V8::GetVersion() {
5391   return i::Version::GetVersion();
5392 }
5393
5394
5395 static i::Handle<i::Context> CreateEnvironment(
5396     i::Isolate* isolate, v8::ExtensionConfiguration* extensions,
5397     v8::Local<ObjectTemplate> global_template,
5398     v8::Local<Value> maybe_global_proxy) {
5399   i::Handle<i::Context> env;
5400
5401   // Enter V8 via an ENTER_V8 scope.
5402   {
5403     ENTER_V8(isolate);
5404     v8::Local<ObjectTemplate> proxy_template = global_template;
5405     i::Handle<i::FunctionTemplateInfo> proxy_constructor;
5406     i::Handle<i::FunctionTemplateInfo> global_constructor;
5407
5408     if (!global_template.IsEmpty()) {
5409       // Make sure that the global_template has a constructor.
5410       global_constructor = EnsureConstructor(isolate, *global_template);
5411
5412       // Create a fresh template for the global proxy object.
5413       proxy_template = ObjectTemplate::New(
5414           reinterpret_cast<v8::Isolate*>(isolate));
5415       proxy_constructor = EnsureConstructor(isolate, *proxy_template);
5416
5417       // Set the global template to be the prototype template of
5418       // global proxy template.
5419       proxy_constructor->set_prototype_template(
5420           *Utils::OpenHandle(*global_template));
5421
5422       // Migrate security handlers from global_template to
5423       // proxy_template.  Temporarily removing access check
5424       // information from the global template.
5425       if (!global_constructor->access_check_info()->IsUndefined()) {
5426         proxy_constructor->set_access_check_info(
5427             global_constructor->access_check_info());
5428         proxy_constructor->set_needs_access_check(
5429             global_constructor->needs_access_check());
5430         global_constructor->set_needs_access_check(false);
5431         global_constructor->set_access_check_info(
5432             isolate->heap()->undefined_value());
5433       }
5434     }
5435
5436     i::Handle<i::Object> proxy = Utils::OpenHandle(*maybe_global_proxy, true);
5437     i::MaybeHandle<i::JSGlobalProxy> maybe_proxy;
5438     if (!proxy.is_null()) {
5439       maybe_proxy = i::Handle<i::JSGlobalProxy>::cast(proxy);
5440     }
5441     // Create the environment.
5442     env = isolate->bootstrapper()->CreateEnvironment(
5443         maybe_proxy, proxy_template, extensions);
5444
5445     // Restore the access check info on the global template.
5446     if (!global_template.IsEmpty()) {
5447       DCHECK(!global_constructor.is_null());
5448       DCHECK(!proxy_constructor.is_null());
5449       global_constructor->set_access_check_info(
5450           proxy_constructor->access_check_info());
5451       global_constructor->set_needs_access_check(
5452           proxy_constructor->needs_access_check());
5453     }
5454   }
5455   // Leave V8.
5456
5457   return env;
5458 }
5459
5460 Local<Context> v8::Context::New(v8::Isolate* external_isolate,
5461                                 v8::ExtensionConfiguration* extensions,
5462                                 v8::Local<ObjectTemplate> global_template,
5463                                 v8::Local<Value> global_object) {
5464   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(external_isolate);
5465   LOG_API(isolate, "Context::New");
5466   i::HandleScope scope(isolate);
5467   ExtensionConfiguration no_extensions;
5468   if (extensions == NULL) extensions = &no_extensions;
5469   i::Handle<i::Context> env =
5470       CreateEnvironment(isolate, extensions, global_template, global_object);
5471   if (env.is_null()) {
5472     if (isolate->has_pending_exception()) {
5473       isolate->OptionalRescheduleException(true);
5474     }
5475     return Local<Context>();
5476   }
5477   return Utils::ToLocal(scope.CloseAndEscape(env));
5478 }
5479
5480
5481 void v8::Context::SetSecurityToken(Local<Value> token) {
5482   i::Handle<i::Context> env = Utils::OpenHandle(this);
5483   i::Handle<i::Object> token_handle = Utils::OpenHandle(*token);
5484   env->set_security_token(*token_handle);
5485 }
5486
5487
5488 void v8::Context::UseDefaultSecurityToken() {
5489   i::Handle<i::Context> env = Utils::OpenHandle(this);
5490   env->set_security_token(env->global_object());
5491 }
5492
5493
5494 Local<Value> v8::Context::GetSecurityToken() {
5495   i::Handle<i::Context> env = Utils::OpenHandle(this);
5496   i::Isolate* isolate = env->GetIsolate();
5497   i::Object* security_token = env->security_token();
5498   i::Handle<i::Object> token_handle(security_token, isolate);
5499   return Utils::ToLocal(token_handle);
5500 }
5501
5502
5503 v8::Isolate* Context::GetIsolate() {
5504   i::Handle<i::Context> env = Utils::OpenHandle(this);
5505   return reinterpret_cast<Isolate*>(env->GetIsolate());
5506 }
5507
5508
5509 v8::Local<v8::Object> Context::Global() {
5510   i::Handle<i::Context> context = Utils::OpenHandle(this);
5511   i::Isolate* isolate = context->GetIsolate();
5512   i::Handle<i::Object> global(context->global_proxy(), isolate);
5513   // TODO(dcarney): This should always return the global proxy
5514   // but can't presently as calls to GetProtoype will return the wrong result.
5515   if (i::Handle<i::JSGlobalProxy>::cast(
5516           global)->IsDetachedFrom(context->global_object())) {
5517     global = i::Handle<i::Object>(context->global_object(), isolate);
5518   }
5519   return Utils::ToLocal(i::Handle<i::JSObject>::cast(global));
5520 }
5521
5522
5523 void Context::DetachGlobal() {
5524   i::Handle<i::Context> context = Utils::OpenHandle(this);
5525   i::Isolate* isolate = context->GetIsolate();
5526   ENTER_V8(isolate);
5527   isolate->bootstrapper()->DetachGlobal(context);
5528 }
5529
5530
5531 Local<v8::Object> Context::GetExtrasBindingObject() {
5532   i::Handle<i::Context> context = Utils::OpenHandle(this);
5533   i::Isolate* isolate = context->GetIsolate();
5534   i::Handle<i::JSObject> binding(context->extras_binding_object(), isolate);
5535   return Utils::ToLocal(binding);
5536 }
5537
5538
5539 void Context::AllowCodeGenerationFromStrings(bool allow) {
5540   i::Handle<i::Context> context = Utils::OpenHandle(this);
5541   i::Isolate* isolate = context->GetIsolate();
5542   ENTER_V8(isolate);
5543   context->set_allow_code_gen_from_strings(
5544       allow ? isolate->heap()->true_value() : isolate->heap()->false_value());
5545 }
5546
5547
5548 bool Context::IsCodeGenerationFromStringsAllowed() {
5549   i::Handle<i::Context> context = Utils::OpenHandle(this);
5550   return !context->allow_code_gen_from_strings()->IsFalse();
5551 }
5552
5553
5554 void Context::SetErrorMessageForCodeGenerationFromStrings(Local<String> error) {
5555   i::Handle<i::Context> context = Utils::OpenHandle(this);
5556   i::Handle<i::String> error_handle = Utils::OpenHandle(*error);
5557   context->set_error_message_for_code_gen_from_strings(*error_handle);
5558 }
5559
5560
5561 size_t Context::EstimatedSize() {
5562   return static_cast<size_t>(
5563       i::ContextMeasure(*Utils::OpenHandle(this)).Size());
5564 }
5565
5566
5567 MaybeLocal<v8::Object> ObjectTemplate::NewInstance(Local<Context> context) {
5568   PREPARE_FOR_EXECUTION(context, "v8::ObjectTemplate::NewInstance()", Object);
5569   auto self = Utils::OpenHandle(this);
5570   Local<Object> result;
5571   has_pending_exception =
5572       !ToLocal<Object>(i::ApiNatives::InstantiateObject(self), &result);
5573   RETURN_ON_FAILED_EXECUTION(Object);
5574   RETURN_ESCAPED(result);
5575 }
5576
5577
5578 Local<v8::Object> ObjectTemplate::NewInstance() {
5579   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
5580   RETURN_TO_LOCAL_UNCHECKED(NewInstance(context), Object);
5581 }
5582
5583
5584 MaybeLocal<v8::Function> FunctionTemplate::GetFunction(Local<Context> context) {
5585   PREPARE_FOR_EXECUTION(context, "v8::FunctionTemplate::GetFunction()",
5586                         Function);
5587   auto self = Utils::OpenHandle(this);
5588   Local<Function> result;
5589   has_pending_exception =
5590       !ToLocal<Function>(i::ApiNatives::InstantiateFunction(self), &result);
5591   RETURN_ON_FAILED_EXECUTION(Function);
5592   RETURN_ESCAPED(result);
5593 }
5594
5595
5596 Local<v8::Function> FunctionTemplate::GetFunction() {
5597   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
5598   RETURN_TO_LOCAL_UNCHECKED(GetFunction(context), Function);
5599 }
5600
5601
5602 bool FunctionTemplate::HasInstance(v8::Local<v8::Value> value) {
5603   auto self = Utils::OpenHandle(this);
5604   auto obj = Utils::OpenHandle(*value);
5605   return self->IsTemplateFor(*obj);
5606 }
5607
5608
5609 Local<External> v8::External::New(Isolate* isolate, void* value) {
5610   STATIC_ASSERT(sizeof(value) == sizeof(i::Address));
5611   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
5612   LOG_API(i_isolate, "External::New");
5613   ENTER_V8(i_isolate);
5614   i::Handle<i::JSObject> external = i_isolate->factory()->NewExternal(value);
5615   return Utils::ExternalToLocal(external);
5616 }
5617
5618
5619 void* External::Value() const {
5620   return ExternalValue(*Utils::OpenHandle(this));
5621 }
5622
5623
5624 // anonymous namespace for string creation helper functions
5625 namespace {
5626
5627 inline int StringLength(const char* string) {
5628   return i::StrLength(string);
5629 }
5630
5631
5632 inline int StringLength(const uint8_t* string) {
5633   return i::StrLength(reinterpret_cast<const char*>(string));
5634 }
5635
5636
5637 inline int StringLength(const uint16_t* string) {
5638   int length = 0;
5639   while (string[length] != '\0')
5640     length++;
5641   return length;
5642 }
5643
5644
5645 MUST_USE_RESULT
5646 inline i::MaybeHandle<i::String> NewString(i::Factory* factory,
5647                                            v8::NewStringType type,
5648                                            i::Vector<const char> string) {
5649   if (type == v8::NewStringType::kInternalized) {
5650     return factory->InternalizeUtf8String(string);
5651   }
5652   return factory->NewStringFromUtf8(string);
5653 }
5654
5655
5656 MUST_USE_RESULT
5657 inline i::MaybeHandle<i::String> NewString(i::Factory* factory,
5658                                            v8::NewStringType type,
5659                                            i::Vector<const uint8_t> string) {
5660   if (type == v8::NewStringType::kInternalized) {
5661     return factory->InternalizeOneByteString(string);
5662   }
5663   return factory->NewStringFromOneByte(string);
5664 }
5665
5666
5667 MUST_USE_RESULT
5668 inline i::MaybeHandle<i::String> NewString(i::Factory* factory,
5669                                            v8::NewStringType type,
5670                                            i::Vector<const uint16_t> string) {
5671   if (type == v8::NewStringType::kInternalized) {
5672     return factory->InternalizeTwoByteString(string);
5673   }
5674   return factory->NewStringFromTwoByte(string);
5675 }
5676
5677
5678 STATIC_ASSERT(v8::String::kMaxLength == i::String::kMaxLength);
5679
5680
5681 template <typename Char>
5682 inline MaybeLocal<String> NewString(Isolate* v8_isolate, const char* location,
5683                                     const char* env, const Char* data,
5684                                     v8::NewStringType type, int length) {
5685   i::Isolate* isolate = reinterpret_cast<internal::Isolate*>(v8_isolate);
5686   if (length == 0) return String::Empty(v8_isolate);
5687   // TODO(dcarney): throw a context free exception.
5688   if (length > i::String::kMaxLength) return MaybeLocal<String>();
5689   ENTER_V8(isolate);
5690   LOG_API(isolate, env);
5691   if (length < 0) length = StringLength(data);
5692   i::Handle<i::String> result =
5693       NewString(isolate->factory(), type, i::Vector<const Char>(data, length))
5694           .ToHandleChecked();
5695   return Utils::ToLocal(result);
5696 }
5697
5698 }  // anonymous namespace
5699
5700
5701 Local<String> String::NewFromUtf8(Isolate* isolate,
5702                                   const char* data,
5703                                   NewStringType type,
5704                                   int length) {
5705   RETURN_TO_LOCAL_UNCHECKED(
5706       NewString(isolate, "v8::String::NewFromUtf8()", "String::NewFromUtf8",
5707                 data, static_cast<v8::NewStringType>(type), length),
5708       String);
5709 }
5710
5711
5712 MaybeLocal<String> String::NewFromUtf8(Isolate* isolate, const char* data,
5713                                        v8::NewStringType type, int length) {
5714   return NewString(isolate, "v8::String::NewFromUtf8()", "String::NewFromUtf8",
5715                    data, type, length);
5716 }
5717
5718
5719 Local<String> String::NewFromOneByte(Isolate* isolate,
5720                                      const uint8_t* data,
5721                                      NewStringType type,
5722                                      int length) {
5723   RETURN_TO_LOCAL_UNCHECKED(
5724       NewString(isolate, "v8::String::NewFromOneByte()",
5725                 "String::NewFromOneByte", data,
5726                 static_cast<v8::NewStringType>(type), length),
5727       String);
5728 }
5729
5730
5731 MaybeLocal<String> String::NewFromOneByte(Isolate* isolate, const uint8_t* data,
5732                                           v8::NewStringType type, int length) {
5733   return NewString(isolate, "v8::String::NewFromOneByte()",
5734                    "String::NewFromOneByte", data, type, length);
5735 }
5736
5737
5738 Local<String> String::NewFromTwoByte(Isolate* isolate,
5739                                      const uint16_t* data,
5740                                      NewStringType type,
5741                                      int length) {
5742   RETURN_TO_LOCAL_UNCHECKED(
5743       NewString(isolate, "v8::String::NewFromTwoByte()",
5744                 "String::NewFromTwoByte", data,
5745                 static_cast<v8::NewStringType>(type), length),
5746       String);
5747 }
5748
5749
5750 MaybeLocal<String> String::NewFromTwoByte(Isolate* isolate,
5751                                           const uint16_t* data,
5752                                           v8::NewStringType type, int length) {
5753   return NewString(isolate, "v8::String::NewFromTwoByte()",
5754                    "String::NewFromTwoByte", data, type, length);
5755 }
5756
5757
5758 Local<String> v8::String::Concat(Local<String> left, Local<String> right) {
5759   i::Handle<i::String> left_string = Utils::OpenHandle(*left);
5760   i::Isolate* isolate = left_string->GetIsolate();
5761   ENTER_V8(isolate);
5762   LOG_API(isolate, "v8::String::Concat");
5763   i::Handle<i::String> right_string = Utils::OpenHandle(*right);
5764   // If we are steering towards a range error, do not wait for the error to be
5765   // thrown, and return the null handle instead.
5766   if (left_string->length() + right_string->length() > i::String::kMaxLength) {
5767     return Local<String>();
5768   }
5769   i::Handle<i::String> result = isolate->factory()->NewConsString(
5770       left_string, right_string).ToHandleChecked();
5771   return Utils::ToLocal(result);
5772 }
5773
5774
5775 MaybeLocal<String> v8::String::NewExternalTwoByte(
5776     Isolate* isolate, v8::String::ExternalStringResource* resource) {
5777   CHECK(resource && resource->data());
5778   // TODO(dcarney): throw a context free exception.
5779   if (resource->length() > static_cast<size_t>(i::String::kMaxLength)) {
5780     return MaybeLocal<String>();
5781   }
5782   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
5783   ENTER_V8(i_isolate);
5784   LOG_API(i_isolate, "String::NewExternalTwoByte");
5785   i::Handle<i::String> string = i_isolate->factory()
5786                                     ->NewExternalStringFromTwoByte(resource)
5787                                     .ToHandleChecked();
5788   i_isolate->heap()->RegisterExternalString(*string);
5789   return Utils::ToLocal(string);
5790 }
5791
5792
5793 Local<String> v8::String::NewExternal(
5794     Isolate* isolate, v8::String::ExternalStringResource* resource) {
5795   RETURN_TO_LOCAL_UNCHECKED(NewExternalTwoByte(isolate, resource), String);
5796 }
5797
5798
5799 MaybeLocal<String> v8::String::NewExternalOneByte(
5800     Isolate* isolate, v8::String::ExternalOneByteStringResource* resource) {
5801   CHECK(resource && resource->data());
5802   // TODO(dcarney): throw a context free exception.
5803   if (resource->length() > static_cast<size_t>(i::String::kMaxLength)) {
5804     return MaybeLocal<String>();
5805   }
5806   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
5807   ENTER_V8(i_isolate);
5808   LOG_API(i_isolate, "String::NewExternalOneByte");
5809   i::Handle<i::String> string = i_isolate->factory()
5810                                     ->NewExternalStringFromOneByte(resource)
5811                                     .ToHandleChecked();
5812   i_isolate->heap()->RegisterExternalString(*string);
5813   return Utils::ToLocal(string);
5814 }
5815
5816
5817 Local<String> v8::String::NewExternal(
5818     Isolate* isolate, v8::String::ExternalOneByteStringResource* resource) {
5819   RETURN_TO_LOCAL_UNCHECKED(NewExternalOneByte(isolate, resource), String);
5820 }
5821
5822
5823 bool v8::String::MakeExternal(v8::String::ExternalStringResource* resource) {
5824   i::Handle<i::String> obj = Utils::OpenHandle(this);
5825   i::Isolate* isolate = obj->GetIsolate();
5826   if (i::StringShape(*obj).IsExternal()) {
5827     return false;  // Already an external string.
5828   }
5829   ENTER_V8(isolate);
5830   if (isolate->heap()->IsInGCPostProcessing()) {
5831     return false;
5832   }
5833   CHECK(resource && resource->data());
5834
5835   bool result = obj->MakeExternal(resource);
5836   // Assert that if CanMakeExternal(), then externalizing actually succeeds.
5837   DCHECK(!CanMakeExternal() || result);
5838   if (result) {
5839     DCHECK(obj->IsExternalString());
5840     isolate->heap()->RegisterExternalString(*obj);
5841   }
5842   return result;
5843 }
5844
5845
5846 bool v8::String::MakeExternal(
5847     v8::String::ExternalOneByteStringResource* resource) {
5848   i::Handle<i::String> obj = Utils::OpenHandle(this);
5849   i::Isolate* isolate = obj->GetIsolate();
5850   if (i::StringShape(*obj).IsExternal()) {
5851     return false;  // Already an external string.
5852   }
5853   ENTER_V8(isolate);
5854   if (isolate->heap()->IsInGCPostProcessing()) {
5855     return false;
5856   }
5857   CHECK(resource && resource->data());
5858
5859   bool result = obj->MakeExternal(resource);
5860   // Assert that if CanMakeExternal(), then externalizing actually succeeds.
5861   DCHECK(!CanMakeExternal() || result);
5862   if (result) {
5863     DCHECK(obj->IsExternalString());
5864     isolate->heap()->RegisterExternalString(*obj);
5865   }
5866   return result;
5867 }
5868
5869
5870 bool v8::String::CanMakeExternal() {
5871   i::Handle<i::String> obj = Utils::OpenHandle(this);
5872   i::Isolate* isolate = obj->GetIsolate();
5873
5874   // Old space strings should be externalized.
5875   if (!isolate->heap()->new_space()->Contains(*obj)) return true;
5876   int size = obj->Size();  // Byte size of the original string.
5877   if (size <= i::ExternalString::kShortSize) return false;
5878   i::StringShape shape(*obj);
5879   return !shape.IsExternal();
5880 }
5881
5882
5883 Isolate* v8::Object::GetIsolate() {
5884   i::Isolate* i_isolate = Utils::OpenHandle(this)->GetIsolate();
5885   return reinterpret_cast<Isolate*>(i_isolate);
5886 }
5887
5888
5889 Local<v8::Object> v8::Object::New(Isolate* isolate) {
5890   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
5891   LOG_API(i_isolate, "Object::New");
5892   ENTER_V8(i_isolate);
5893   i::Handle<i::JSObject> obj =
5894       i_isolate->factory()->NewJSObject(i_isolate->object_function());
5895   return Utils::ToLocal(obj);
5896 }
5897
5898
5899 Local<v8::Value> v8::NumberObject::New(Isolate* isolate, double value) {
5900   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
5901   LOG_API(i_isolate, "NumberObject::New");
5902   ENTER_V8(i_isolate);
5903   i::Handle<i::Object> number = i_isolate->factory()->NewNumber(value);
5904   i::Handle<i::Object> obj =
5905       i::Object::ToObject(i_isolate, number).ToHandleChecked();
5906   return Utils::ToLocal(obj);
5907 }
5908
5909
5910 double v8::NumberObject::ValueOf() const {
5911   i::Handle<i::Object> obj = Utils::OpenHandle(this);
5912   i::Handle<i::JSValue> jsvalue = i::Handle<i::JSValue>::cast(obj);
5913   i::Isolate* isolate = jsvalue->GetIsolate();
5914   LOG_API(isolate, "NumberObject::NumberValue");
5915   return jsvalue->value()->Number();
5916 }
5917
5918
5919 Local<v8::Value> v8::BooleanObject::New(bool value) {
5920   i::Isolate* isolate = i::Isolate::Current();
5921   LOG_API(isolate, "BooleanObject::New");
5922   ENTER_V8(isolate);
5923   i::Handle<i::Object> boolean(value
5924                                ? isolate->heap()->true_value()
5925                                : isolate->heap()->false_value(),
5926                                isolate);
5927   i::Handle<i::Object> obj =
5928       i::Object::ToObject(isolate, boolean).ToHandleChecked();
5929   return Utils::ToLocal(obj);
5930 }
5931
5932
5933 bool v8::BooleanObject::ValueOf() const {
5934   i::Handle<i::Object> obj = Utils::OpenHandle(this);
5935   i::Handle<i::JSValue> jsvalue = i::Handle<i::JSValue>::cast(obj);
5936   i::Isolate* isolate = jsvalue->GetIsolate();
5937   LOG_API(isolate, "BooleanObject::BooleanValue");
5938   return jsvalue->value()->IsTrue();
5939 }
5940
5941
5942 Local<v8::Value> v8::StringObject::New(Local<String> value) {
5943   i::Handle<i::String> string = Utils::OpenHandle(*value);
5944   i::Isolate* isolate = string->GetIsolate();
5945   LOG_API(isolate, "StringObject::New");
5946   ENTER_V8(isolate);
5947   i::Handle<i::Object> obj =
5948       i::Object::ToObject(isolate, string).ToHandleChecked();
5949   return Utils::ToLocal(obj);
5950 }
5951
5952
5953 Local<v8::String> v8::StringObject::ValueOf() const {
5954   i::Handle<i::Object> obj = Utils::OpenHandle(this);
5955   i::Handle<i::JSValue> jsvalue = i::Handle<i::JSValue>::cast(obj);
5956   i::Isolate* isolate = jsvalue->GetIsolate();
5957   LOG_API(isolate, "StringObject::StringValue");
5958   return Utils::ToLocal(
5959       i::Handle<i::String>(i::String::cast(jsvalue->value())));
5960 }
5961
5962
5963 Local<v8::Value> v8::SymbolObject::New(Isolate* isolate, Local<Symbol> value) {
5964   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
5965   LOG_API(i_isolate, "SymbolObject::New");
5966   ENTER_V8(i_isolate);
5967   i::Handle<i::Object> obj = i::Object::ToObject(
5968       i_isolate, Utils::OpenHandle(*value)).ToHandleChecked();
5969   return Utils::ToLocal(obj);
5970 }
5971
5972
5973 Local<v8::Symbol> v8::SymbolObject::ValueOf() const {
5974   i::Handle<i::Object> obj = Utils::OpenHandle(this);
5975   i::Handle<i::JSValue> jsvalue = i::Handle<i::JSValue>::cast(obj);
5976   i::Isolate* isolate = jsvalue->GetIsolate();
5977   LOG_API(isolate, "SymbolObject::SymbolValue");
5978   return Utils::ToLocal(
5979       i::Handle<i::Symbol>(i::Symbol::cast(jsvalue->value())));
5980 }
5981
5982
5983 MaybeLocal<v8::Value> v8::Date::New(Local<Context> context, double time) {
5984   if (std::isnan(time)) {
5985     // Introduce only canonical NaN value into the VM, to avoid signaling NaNs.
5986     time = std::numeric_limits<double>::quiet_NaN();
5987   }
5988   PREPARE_FOR_EXECUTION(context, "Date::New", Value);
5989   Local<Value> result;
5990   has_pending_exception =
5991       !ToLocal<Value>(i::Execution::NewDate(isolate, time), &result);
5992   RETURN_ON_FAILED_EXECUTION(Value);
5993   RETURN_ESCAPED(result);
5994 }
5995
5996
5997 Local<v8::Value> v8::Date::New(Isolate* isolate, double time) {
5998   auto context = isolate->GetCurrentContext();
5999   RETURN_TO_LOCAL_UNCHECKED(New(context, time), Value);
6000 }
6001
6002
6003 double v8::Date::ValueOf() const {
6004   i::Handle<i::Object> obj = Utils::OpenHandle(this);
6005   i::Handle<i::JSDate> jsdate = i::Handle<i::JSDate>::cast(obj);
6006   i::Isolate* isolate = jsdate->GetIsolate();
6007   LOG_API(isolate, "Date::NumberValue");
6008   return jsdate->value()->Number();
6009 }
6010
6011
6012 void v8::Date::DateTimeConfigurationChangeNotification(Isolate* isolate) {
6013   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6014   LOG_API(i_isolate, "Date::DateTimeConfigurationChangeNotification");
6015   ENTER_V8(i_isolate);
6016   i_isolate->date_cache()->ResetDateCache();
6017   if (!i_isolate->eternal_handles()->Exists(
6018           i::EternalHandles::DATE_CACHE_VERSION)) {
6019     return;
6020   }
6021   i::Handle<i::FixedArray> date_cache_version =
6022       i::Handle<i::FixedArray>::cast(i_isolate->eternal_handles()->GetSingleton(
6023           i::EternalHandles::DATE_CACHE_VERSION));
6024   DCHECK_EQ(1, date_cache_version->length());
6025   CHECK(date_cache_version->get(0)->IsSmi());
6026   date_cache_version->set(
6027       0,
6028       i::Smi::FromInt(i::Smi::cast(date_cache_version->get(0))->value() + 1));
6029 }
6030
6031
6032 static i::Handle<i::String> RegExpFlagsToString(RegExp::Flags flags) {
6033   i::Isolate* isolate = i::Isolate::Current();
6034   uint8_t flags_buf[3];
6035   int num_flags = 0;
6036   if ((flags & RegExp::kGlobal) != 0) flags_buf[num_flags++] = 'g';
6037   if ((flags & RegExp::kMultiline) != 0) flags_buf[num_flags++] = 'm';
6038   if ((flags & RegExp::kIgnoreCase) != 0) flags_buf[num_flags++] = 'i';
6039   DCHECK(num_flags <= static_cast<int>(arraysize(flags_buf)));
6040   return isolate->factory()->InternalizeOneByteString(
6041       i::Vector<const uint8_t>(flags_buf, num_flags));
6042 }
6043
6044
6045 MaybeLocal<v8::RegExp> v8::RegExp::New(Local<Context> context,
6046                                        Local<String> pattern, Flags flags) {
6047   PREPARE_FOR_EXECUTION(context, "RegExp::New", RegExp);
6048   Local<v8::RegExp> result;
6049   has_pending_exception =
6050       !ToLocal<RegExp>(i::Execution::NewJSRegExp(Utils::OpenHandle(*pattern),
6051                                                  RegExpFlagsToString(flags)),
6052                        &result);
6053   RETURN_ON_FAILED_EXECUTION(RegExp);
6054   RETURN_ESCAPED(result);
6055 }
6056
6057
6058 Local<v8::RegExp> v8::RegExp::New(Local<String> pattern, Flags flags) {
6059   auto isolate =
6060       reinterpret_cast<Isolate*>(Utils::OpenHandle(*pattern)->GetIsolate());
6061   auto context = isolate->GetCurrentContext();
6062   RETURN_TO_LOCAL_UNCHECKED(New(context, pattern, flags), RegExp);
6063 }
6064
6065
6066 Local<v8::String> v8::RegExp::GetSource() const {
6067   i::Handle<i::JSRegExp> obj = Utils::OpenHandle(this);
6068   return Utils::ToLocal(i::Handle<i::String>(obj->Pattern()));
6069 }
6070
6071
6072 // Assert that the static flags cast in GetFlags is valid.
6073 #define REGEXP_FLAG_ASSERT_EQ(api_flag, internal_flag)          \
6074   STATIC_ASSERT(static_cast<int>(v8::RegExp::api_flag) ==       \
6075                 static_cast<int>(i::JSRegExp::internal_flag))
6076 REGEXP_FLAG_ASSERT_EQ(kNone, NONE);
6077 REGEXP_FLAG_ASSERT_EQ(kGlobal, GLOBAL);
6078 REGEXP_FLAG_ASSERT_EQ(kIgnoreCase, IGNORE_CASE);
6079 REGEXP_FLAG_ASSERT_EQ(kMultiline, MULTILINE);
6080 #undef REGEXP_FLAG_ASSERT_EQ
6081
6082 v8::RegExp::Flags v8::RegExp::GetFlags() const {
6083   i::Handle<i::JSRegExp> obj = Utils::OpenHandle(this);
6084   return static_cast<RegExp::Flags>(obj->GetFlags().value());
6085 }
6086
6087
6088 Local<v8::Array> v8::Array::New(Isolate* isolate, int length) {
6089   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6090   LOG_API(i_isolate, "Array::New");
6091   ENTER_V8(i_isolate);
6092   int real_length = length > 0 ? length : 0;
6093   i::Handle<i::JSArray> obj = i_isolate->factory()->NewJSArray(real_length);
6094   i::Handle<i::Object> length_obj =
6095       i_isolate->factory()->NewNumberFromInt(real_length);
6096   obj->set_length(*length_obj);
6097   return Utils::ToLocal(obj);
6098 }
6099
6100
6101 uint32_t v8::Array::Length() const {
6102   i::Handle<i::JSArray> obj = Utils::OpenHandle(this);
6103   i::Object* length = obj->length();
6104   if (length->IsSmi()) {
6105     return i::Smi::cast(length)->value();
6106   } else {
6107     return static_cast<uint32_t>(length->Number());
6108   }
6109 }
6110
6111
6112 MaybeLocal<Object> Array::CloneElementAt(Local<Context> context,
6113                                          uint32_t index) {
6114   PREPARE_FOR_EXECUTION(context, "v8::Array::CloneElementAt()", Object);
6115   auto self = Utils::OpenHandle(this);
6116   if (!self->HasFastObjectElements()) return Local<Object>();
6117   i::FixedArray* elms = i::FixedArray::cast(self->elements());
6118   i::Object* paragon = elms->get(index);
6119   if (!paragon->IsJSObject()) return Local<Object>();
6120   i::Handle<i::JSObject> paragon_handle(i::JSObject::cast(paragon));
6121   Local<Object> result;
6122   has_pending_exception =
6123       !ToLocal<Object>(isolate->factory()->CopyJSObject(paragon_handle),
6124                        &result);
6125   RETURN_ON_FAILED_EXECUTION(Object);
6126   RETURN_ESCAPED(result);
6127 }
6128
6129
6130 Local<Object> Array::CloneElementAt(uint32_t index) {
6131   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
6132   RETURN_TO_LOCAL_UNCHECKED(CloneElementAt(context, index), Object);
6133 }
6134
6135
6136 Local<v8::Map> v8::Map::New(Isolate* isolate) {
6137   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6138   LOG_API(i_isolate, "Map::New");
6139   ENTER_V8(i_isolate);
6140   i::Handle<i::JSMap> obj = i_isolate->factory()->NewJSMap();
6141   return Utils::ToLocal(obj);
6142 }
6143
6144
6145 size_t v8::Map::Size() const {
6146   i::Handle<i::JSMap> obj = Utils::OpenHandle(this);
6147   return i::OrderedHashMap::cast(obj->table())->NumberOfElements();
6148 }
6149
6150
6151 void Map::Clear() {
6152   auto self = Utils::OpenHandle(this);
6153   i::Isolate* isolate = self->GetIsolate();
6154   LOG_API(isolate, "Map::Clear");
6155   ENTER_V8(isolate);
6156   i::JSMap::Clear(self);
6157 }
6158
6159
6160 MaybeLocal<Value> Map::Get(Local<Context> context, Local<Value> key) {
6161   PREPARE_FOR_EXECUTION(context, "Map::Get", Value);
6162   auto self = Utils::OpenHandle(this);
6163   Local<Value> result;
6164   i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key)};
6165   has_pending_exception =
6166       !ToLocal<Value>(i::Execution::Call(isolate, isolate->map_get(), self,
6167                                          arraysize(argv), argv, false),
6168                       &result);
6169   RETURN_ON_FAILED_EXECUTION(Value);
6170   RETURN_ESCAPED(result);
6171 }
6172
6173
6174 MaybeLocal<Map> Map::Set(Local<Context> context, Local<Value> key,
6175                          Local<Value> value) {
6176   PREPARE_FOR_EXECUTION(context, "Map::Set", Map);
6177   auto self = Utils::OpenHandle(this);
6178   i::Handle<i::Object> result;
6179   i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key),
6180                                  Utils::OpenHandle(*value)};
6181   has_pending_exception =
6182       !i::Execution::Call(isolate, isolate->map_set(), self, arraysize(argv),
6183                           argv, false).ToHandle(&result);
6184   RETURN_ON_FAILED_EXECUTION(Map);
6185   RETURN_ESCAPED(Local<Map>::Cast(Utils::ToLocal(result)));
6186 }
6187
6188
6189 Maybe<bool> Map::Has(Local<Context> context, Local<Value> key) {
6190   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "Map::Has", bool);
6191   auto self = Utils::OpenHandle(this);
6192   i::Handle<i::Object> result;
6193   i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key)};
6194   has_pending_exception =
6195       !i::Execution::Call(isolate, isolate->map_has(), self, arraysize(argv),
6196                           argv, false).ToHandle(&result);
6197   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
6198   return Just(result->IsTrue());
6199 }
6200
6201
6202 Maybe<bool> Map::Delete(Local<Context> context, Local<Value> key) {
6203   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "Map::Delete", bool);
6204   auto self = Utils::OpenHandle(this);
6205   i::Handle<i::Object> result;
6206   i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key)};
6207   has_pending_exception =
6208       !i::Execution::Call(isolate, isolate->map_delete(), self, arraysize(argv),
6209                           argv, false).ToHandle(&result);
6210   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
6211   return Just(result->IsTrue());
6212 }
6213
6214
6215 Local<Array> Map::AsArray() const {
6216   i::Handle<i::JSMap> obj = Utils::OpenHandle(this);
6217   i::Isolate* isolate = obj->GetIsolate();
6218   i::Factory* factory = isolate->factory();
6219   LOG_API(isolate, "Map::AsArray");
6220   ENTER_V8(isolate);
6221   i::Handle<i::OrderedHashMap> table(i::OrderedHashMap::cast(obj->table()));
6222   int size = table->NumberOfElements();
6223   int length = size * 2;
6224   i::Handle<i::FixedArray> result = factory->NewFixedArray(length);
6225   for (int i = 0; i < size; ++i) {
6226     if (table->KeyAt(i)->IsTheHole()) continue;
6227     result->set(i * 2, table->KeyAt(i));
6228     result->set(i * 2 + 1, table->ValueAt(i));
6229   }
6230   i::Handle<i::JSArray> result_array =
6231       factory->NewJSArrayWithElements(result, i::FAST_ELEMENTS, length);
6232   return Utils::ToLocal(result_array);
6233 }
6234
6235
6236 MaybeLocal<Map> Map::FromArray(Local<Context> context, Local<Array> array) {
6237   PREPARE_FOR_EXECUTION(context, "Map::FromArray", Map);
6238   if (array->Length() % 2 != 0) {
6239     return MaybeLocal<Map>();
6240   }
6241   i::Handle<i::Object> result;
6242   i::Handle<i::Object> argv[] = {Utils::OpenHandle(*array)};
6243   has_pending_exception =
6244       !i::Execution::Call(isolate, isolate->map_from_array(),
6245                           isolate->factory()->undefined_value(),
6246                           arraysize(argv), argv, false).ToHandle(&result);
6247   RETURN_ON_FAILED_EXECUTION(Map);
6248   RETURN_ESCAPED(Local<Map>::Cast(Utils::ToLocal(result)));
6249 }
6250
6251
6252 Local<v8::Set> v8::Set::New(Isolate* isolate) {
6253   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6254   LOG_API(i_isolate, "Set::New");
6255   ENTER_V8(i_isolate);
6256   i::Handle<i::JSSet> obj = i_isolate->factory()->NewJSSet();
6257   return Utils::ToLocal(obj);
6258 }
6259
6260
6261 size_t v8::Set::Size() const {
6262   i::Handle<i::JSSet> obj = Utils::OpenHandle(this);
6263   return i::OrderedHashSet::cast(obj->table())->NumberOfElements();
6264 }
6265
6266
6267 void Set::Clear() {
6268   auto self = Utils::OpenHandle(this);
6269   i::Isolate* isolate = self->GetIsolate();
6270   LOG_API(isolate, "Set::Clear");
6271   ENTER_V8(isolate);
6272   i::JSSet::Clear(self);
6273 }
6274
6275
6276 MaybeLocal<Set> Set::Add(Local<Context> context, Local<Value> key) {
6277   PREPARE_FOR_EXECUTION(context, "Set::Add", Set);
6278   auto self = Utils::OpenHandle(this);
6279   i::Handle<i::Object> result;
6280   i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key)};
6281   has_pending_exception =
6282       !i::Execution::Call(isolate, isolate->set_add(), self, arraysize(argv),
6283                           argv, false).ToHandle(&result);
6284   RETURN_ON_FAILED_EXECUTION(Set);
6285   RETURN_ESCAPED(Local<Set>::Cast(Utils::ToLocal(result)));
6286 }
6287
6288
6289 Maybe<bool> Set::Has(Local<Context> context, Local<Value> key) {
6290   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "Set::Has", bool);
6291   auto self = Utils::OpenHandle(this);
6292   i::Handle<i::Object> result;
6293   i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key)};
6294   has_pending_exception =
6295       !i::Execution::Call(isolate, isolate->set_has(), self, arraysize(argv),
6296                           argv, false).ToHandle(&result);
6297   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
6298   return Just(result->IsTrue());
6299 }
6300
6301
6302 Maybe<bool> Set::Delete(Local<Context> context, Local<Value> key) {
6303   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "Set::Delete", bool);
6304   auto self = Utils::OpenHandle(this);
6305   i::Handle<i::Object> result;
6306   i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key)};
6307   has_pending_exception =
6308       !i::Execution::Call(isolate, isolate->set_delete(), self, arraysize(argv),
6309                           argv, false).ToHandle(&result);
6310   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
6311   return Just(result->IsTrue());
6312 }
6313
6314
6315 Local<Array> Set::AsArray() const {
6316   i::Handle<i::JSSet> obj = Utils::OpenHandle(this);
6317   i::Isolate* isolate = obj->GetIsolate();
6318   i::Factory* factory = isolate->factory();
6319   LOG_API(isolate, "Set::AsArray");
6320   ENTER_V8(isolate);
6321   i::Handle<i::OrderedHashSet> table(i::OrderedHashSet::cast(obj->table()));
6322   int length = table->NumberOfElements();
6323   i::Handle<i::FixedArray> result = factory->NewFixedArray(length);
6324   for (int i = 0; i < length; ++i) {
6325     i::Object* key = table->KeyAt(i);
6326     if (!key->IsTheHole()) {
6327       result->set(i, key);
6328     }
6329   }
6330   i::Handle<i::JSArray> result_array =
6331       factory->NewJSArrayWithElements(result, i::FAST_ELEMENTS, length);
6332   return Utils::ToLocal(result_array);
6333 }
6334
6335
6336 MaybeLocal<Set> Set::FromArray(Local<Context> context, Local<Array> array) {
6337   PREPARE_FOR_EXECUTION(context, "Set::FromArray", Set);
6338   i::Handle<i::Object> result;
6339   i::Handle<i::Object> argv[] = {Utils::OpenHandle(*array)};
6340   has_pending_exception =
6341       !i::Execution::Call(isolate, isolate->set_from_array(),
6342                           isolate->factory()->undefined_value(),
6343                           arraysize(argv), argv, false).ToHandle(&result);
6344   RETURN_ON_FAILED_EXECUTION(Set);
6345   RETURN_ESCAPED(Local<Set>::Cast(Utils::ToLocal(result)));
6346 }
6347
6348
6349 bool Value::IsPromise() const {
6350   auto self = Utils::OpenHandle(this);
6351   return i::Object::IsPromise(self);
6352 }
6353
6354
6355 MaybeLocal<Promise::Resolver> Promise::Resolver::New(Local<Context> context) {
6356   PREPARE_FOR_EXECUTION(context, "Promise::Resolver::New", Resolver);
6357   i::Handle<i::Object> result;
6358   has_pending_exception = !i::Execution::Call(
6359       isolate,
6360       isolate->promise_create(),
6361       isolate->factory()->undefined_value(),
6362       0, NULL,
6363       false).ToHandle(&result);
6364   RETURN_ON_FAILED_EXECUTION(Promise::Resolver);
6365   RETURN_ESCAPED(Local<Promise::Resolver>::Cast(Utils::ToLocal(result)));
6366 }
6367
6368
6369 Local<Promise::Resolver> Promise::Resolver::New(Isolate* isolate) {
6370   RETURN_TO_LOCAL_UNCHECKED(New(isolate->GetCurrentContext()),
6371                             Promise::Resolver);
6372 }
6373
6374
6375 Local<Promise> Promise::Resolver::GetPromise() {
6376   i::Handle<i::JSObject> promise = Utils::OpenHandle(this);
6377   return Local<Promise>::Cast(Utils::ToLocal(promise));
6378 }
6379
6380
6381 Maybe<bool> Promise::Resolver::Resolve(Local<Context> context,
6382                                        Local<Value> value) {
6383   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "Promise::Resolver::Resolve", bool);
6384   auto self = Utils::OpenHandle(this);
6385   i::Handle<i::Object> argv[] = {self, Utils::OpenHandle(*value)};
6386   has_pending_exception = i::Execution::Call(
6387       isolate,
6388       isolate->promise_resolve(),
6389       isolate->factory()->undefined_value(),
6390       arraysize(argv), argv,
6391       false).is_null();
6392   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
6393   return Just(true);
6394 }
6395
6396
6397 void Promise::Resolver::Resolve(Local<Value> value) {
6398   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
6399   USE(Resolve(context, value));
6400 }
6401
6402
6403 Maybe<bool> Promise::Resolver::Reject(Local<Context> context,
6404                                       Local<Value> value) {
6405   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "Promise::Resolver::Resolve", bool);
6406   auto self = Utils::OpenHandle(this);
6407   i::Handle<i::Object> argv[] = {self, Utils::OpenHandle(*value)};
6408   has_pending_exception = i::Execution::Call(
6409       isolate,
6410       isolate->promise_reject(),
6411       isolate->factory()->undefined_value(),
6412       arraysize(argv), argv,
6413       false).is_null();
6414   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
6415   return Just(true);
6416 }
6417
6418
6419 void Promise::Resolver::Reject(Local<Value> value) {
6420   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
6421   USE(Reject(context, value));
6422 }
6423
6424
6425 MaybeLocal<Promise> Promise::Chain(Local<Context> context,
6426                                    Local<Function> handler) {
6427   PREPARE_FOR_EXECUTION(context, "Promise::Chain", Promise);
6428   auto self = Utils::OpenHandle(this);
6429   i::Handle<i::Object> argv[] = {Utils::OpenHandle(*handler)};
6430   i::Handle<i::Object> result;
6431   has_pending_exception =
6432       !i::Execution::Call(isolate, isolate->promise_chain(), self,
6433                           arraysize(argv), argv, false).ToHandle(&result);
6434   RETURN_ON_FAILED_EXECUTION(Promise);
6435   RETURN_ESCAPED(Local<Promise>::Cast(Utils::ToLocal(result)));
6436 }
6437
6438
6439 Local<Promise> Promise::Chain(Local<Function> handler) {
6440   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
6441   RETURN_TO_LOCAL_UNCHECKED(Chain(context, handler), Promise);
6442 }
6443
6444
6445 MaybeLocal<Promise> Promise::Catch(Local<Context> context,
6446                                    Local<Function> handler) {
6447   PREPARE_FOR_EXECUTION(context, "Promise::Catch", Promise);
6448   auto self = Utils::OpenHandle(this);
6449   i::Handle<i::Object> argv[] = { Utils::OpenHandle(*handler) };
6450   i::Handle<i::Object> result;
6451   has_pending_exception =
6452       !i::Execution::Call(isolate, isolate->promise_catch(), self,
6453                           arraysize(argv), argv, false).ToHandle(&result);
6454   RETURN_ON_FAILED_EXECUTION(Promise);
6455   RETURN_ESCAPED(Local<Promise>::Cast(Utils::ToLocal(result)));
6456 }
6457
6458
6459 Local<Promise> Promise::Catch(Local<Function> handler) {
6460   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
6461   RETURN_TO_LOCAL_UNCHECKED(Catch(context, handler), Promise);
6462 }
6463
6464
6465 MaybeLocal<Promise> Promise::Then(Local<Context> context,
6466                                   Local<Function> handler) {
6467   PREPARE_FOR_EXECUTION(context, "Promise::Then", Promise);
6468   auto self = Utils::OpenHandle(this);
6469   i::Handle<i::Object> argv[] = { Utils::OpenHandle(*handler) };
6470   i::Handle<i::Object> result;
6471   has_pending_exception =
6472       !i::Execution::Call(isolate, isolate->promise_then(), self,
6473                           arraysize(argv), argv, false).ToHandle(&result);
6474   RETURN_ON_FAILED_EXECUTION(Promise);
6475   RETURN_ESCAPED(Local<Promise>::Cast(Utils::ToLocal(result)));
6476 }
6477
6478
6479 Local<Promise> Promise::Then(Local<Function> handler) {
6480   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
6481   RETURN_TO_LOCAL_UNCHECKED(Then(context, handler), Promise);
6482 }
6483
6484
6485 bool Promise::HasHandler() {
6486   i::Handle<i::JSObject> promise = Utils::OpenHandle(this);
6487   i::Isolate* isolate = promise->GetIsolate();
6488   LOG_API(isolate, "Promise::HasRejectHandler");
6489   ENTER_V8(isolate);
6490   i::Handle<i::Symbol> key = isolate->factory()->promise_has_handler_symbol();
6491   return i::JSReceiver::GetDataProperty(promise, key)->IsTrue();
6492 }
6493
6494
6495 bool v8::ArrayBuffer::IsExternal() const {
6496   return Utils::OpenHandle(this)->is_external();
6497 }
6498
6499
6500 bool v8::ArrayBuffer::IsNeuterable() const {
6501   return Utils::OpenHandle(this)->is_neuterable();
6502 }
6503
6504
6505 v8::ArrayBuffer::Contents v8::ArrayBuffer::Externalize() {
6506   i::Handle<i::JSArrayBuffer> self = Utils::OpenHandle(this);
6507   i::Isolate* isolate = self->GetIsolate();
6508   Utils::ApiCheck(!self->is_external(), "v8::ArrayBuffer::Externalize",
6509                   "ArrayBuffer already externalized");
6510   self->set_is_external(true);
6511   isolate->heap()->UnregisterArrayBuffer(isolate->heap()->InNewSpace(*self),
6512                                          self->backing_store());
6513
6514   return GetContents();
6515 }
6516
6517
6518 v8::ArrayBuffer::Contents v8::ArrayBuffer::GetContents() {
6519   i::Handle<i::JSArrayBuffer> self = Utils::OpenHandle(this);
6520   size_t byte_length = static_cast<size_t>(self->byte_length()->Number());
6521   Contents contents;
6522   contents.data_ = self->backing_store();
6523   contents.byte_length_ = byte_length;
6524   return contents;
6525 }
6526
6527
6528 void v8::ArrayBuffer::Neuter() {
6529   i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this);
6530   i::Isolate* isolate = obj->GetIsolate();
6531   Utils::ApiCheck(obj->is_external(),
6532                   "v8::ArrayBuffer::Neuter",
6533                   "Only externalized ArrayBuffers can be neutered");
6534   Utils::ApiCheck(obj->is_neuterable(), "v8::ArrayBuffer::Neuter",
6535                   "Only neuterable ArrayBuffers can be neutered");
6536   LOG_API(obj->GetIsolate(), "v8::ArrayBuffer::Neuter()");
6537   ENTER_V8(isolate);
6538   obj->Neuter();
6539 }
6540
6541
6542 size_t v8::ArrayBuffer::ByteLength() const {
6543   i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this);
6544   return static_cast<size_t>(obj->byte_length()->Number());
6545 }
6546
6547
6548 Local<ArrayBuffer> v8::ArrayBuffer::New(Isolate* isolate, size_t byte_length) {
6549   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6550   LOG_API(i_isolate, "v8::ArrayBuffer::New(size_t)");
6551   ENTER_V8(i_isolate);
6552   i::Handle<i::JSArrayBuffer> obj =
6553       i_isolate->factory()->NewJSArrayBuffer(i::SharedFlag::kNotShared);
6554   i::JSArrayBuffer::SetupAllocatingData(obj, i_isolate, byte_length);
6555   return Utils::ToLocal(obj);
6556 }
6557
6558
6559 Local<ArrayBuffer> v8::ArrayBuffer::New(Isolate* isolate, void* data,
6560                                         size_t byte_length,
6561                                         ArrayBufferCreationMode mode) {
6562   // Embedders must guarantee that the external backing store is valid.
6563   CHECK(byte_length == 0 || data != NULL);
6564   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6565   LOG_API(i_isolate, "v8::ArrayBuffer::New(void*, size_t)");
6566   ENTER_V8(i_isolate);
6567   i::Handle<i::JSArrayBuffer> obj =
6568       i_isolate->factory()->NewJSArrayBuffer(i::SharedFlag::kNotShared);
6569   i::JSArrayBuffer::Setup(obj, i_isolate,
6570                           mode == ArrayBufferCreationMode::kExternalized, data,
6571                           byte_length);
6572   return Utils::ToLocal(obj);
6573 }
6574
6575
6576 Local<ArrayBuffer> v8::ArrayBufferView::Buffer() {
6577   i::Handle<i::JSArrayBufferView> obj = Utils::OpenHandle(this);
6578   i::Handle<i::JSArrayBuffer> buffer;
6579   if (obj->IsJSDataView()) {
6580     i::Handle<i::JSDataView> data_view(i::JSDataView::cast(*obj));
6581     DCHECK(data_view->buffer()->IsJSArrayBuffer());
6582     buffer = i::handle(i::JSArrayBuffer::cast(data_view->buffer()));
6583   } else {
6584     DCHECK(obj->IsJSTypedArray());
6585     buffer = i::JSTypedArray::cast(*obj)->GetBuffer();
6586   }
6587   return Utils::ToLocal(buffer);
6588 }
6589
6590
6591 size_t v8::ArrayBufferView::CopyContents(void* dest, size_t byte_length) {
6592   i::Handle<i::JSArrayBufferView> self = Utils::OpenHandle(this);
6593   i::Isolate* isolate = self->GetIsolate();
6594   size_t byte_offset = i::NumberToSize(isolate, self->byte_offset());
6595   size_t bytes_to_copy =
6596       i::Min(byte_length, i::NumberToSize(isolate, self->byte_length()));
6597   if (bytes_to_copy) {
6598     i::DisallowHeapAllocation no_gc;
6599     i::Handle<i::JSArrayBuffer> buffer(i::JSArrayBuffer::cast(self->buffer()));
6600     const char* source = reinterpret_cast<char*>(buffer->backing_store());
6601     if (source == nullptr) {
6602       DCHECK(self->IsJSTypedArray());
6603       i::Handle<i::JSTypedArray> typed_array(i::JSTypedArray::cast(*self));
6604       i::Handle<i::FixedTypedArrayBase> fixed_array(
6605           i::FixedTypedArrayBase::cast(typed_array->elements()));
6606       source = reinterpret_cast<char*>(fixed_array->DataPtr());
6607     }
6608     memcpy(dest, source + byte_offset, bytes_to_copy);
6609   }
6610   return bytes_to_copy;
6611 }
6612
6613
6614 bool v8::ArrayBufferView::HasBuffer() const {
6615   i::Handle<i::JSArrayBufferView> self = Utils::OpenHandle(this);
6616   i::Handle<i::JSArrayBuffer> buffer(i::JSArrayBuffer::cast(self->buffer()));
6617   return buffer->backing_store() != nullptr;
6618 }
6619
6620
6621 size_t v8::ArrayBufferView::ByteOffset() {
6622   i::Handle<i::JSArrayBufferView> obj = Utils::OpenHandle(this);
6623   return static_cast<size_t>(obj->byte_offset()->Number());
6624 }
6625
6626
6627 size_t v8::ArrayBufferView::ByteLength() {
6628   i::Handle<i::JSArrayBufferView> obj = Utils::OpenHandle(this);
6629   return static_cast<size_t>(obj->byte_length()->Number());
6630 }
6631
6632
6633 size_t v8::TypedArray::Length() {
6634   i::Handle<i::JSTypedArray> obj = Utils::OpenHandle(this);
6635   return static_cast<size_t>(obj->length_value());
6636 }
6637
6638
6639 #define TYPED_ARRAY_NEW(Type, type, TYPE, ctype, size)                        \
6640   Local<Type##Array> Type##Array::New(Local<ArrayBuffer> array_buffer,        \
6641                                       size_t byte_offset, size_t length) {    \
6642     i::Isolate* isolate = Utils::OpenHandle(*array_buffer)->GetIsolate();     \
6643     LOG_API(isolate,                                                          \
6644             "v8::" #Type "Array::New(Local<ArrayBuffer>, size_t, size_t)");   \
6645     ENTER_V8(isolate);                                                        \
6646     if (!Utils::ApiCheck(length <= static_cast<size_t>(i::Smi::kMaxValue),    \
6647                          "v8::" #Type                                         \
6648                          "Array::New(Local<ArrayBuffer>, size_t, size_t)",    \
6649                          "length exceeds max allowed value")) {               \
6650       return Local<Type##Array>();                                            \
6651     }                                                                         \
6652     i::Handle<i::JSArrayBuffer> buffer = Utils::OpenHandle(*array_buffer);    \
6653     i::Handle<i::JSTypedArray> obj = isolate->factory()->NewJSTypedArray(     \
6654         i::kExternal##Type##Array, buffer, byte_offset, length);              \
6655     return Utils::ToLocal##Type##Array(obj);                                  \
6656   }                                                                           \
6657   Local<Type##Array> Type##Array::New(                                        \
6658       Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset,       \
6659       size_t length) {                                                        \
6660     CHECK(i::FLAG_harmony_sharedarraybuffer);                                 \
6661     i::Isolate* isolate =                                                     \
6662         Utils::OpenHandle(*shared_array_buffer)->GetIsolate();                \
6663     LOG_API(isolate, "v8::" #Type                                             \
6664                      "Array::New(Local<SharedArrayBuffer>, size_t, size_t)"); \
6665     ENTER_V8(isolate);                                                        \
6666     if (!Utils::ApiCheck(                                                     \
6667             length <= static_cast<size_t>(i::Smi::kMaxValue),                 \
6668             "v8::" #Type                                                      \
6669             "Array::New(Local<SharedArrayBuffer>, size_t, size_t)",           \
6670             "length exceeds max allowed value")) {                            \
6671       return Local<Type##Array>();                                            \
6672     }                                                                         \
6673     i::Handle<i::JSArrayBuffer> buffer =                                      \
6674         Utils::OpenHandle(*shared_array_buffer);                              \
6675     i::Handle<i::JSTypedArray> obj = isolate->factory()->NewJSTypedArray(     \
6676         i::kExternal##Type##Array, buffer, byte_offset, length);              \
6677     return Utils::ToLocal##Type##Array(obj);                                  \
6678   }
6679
6680
6681 TYPED_ARRAYS(TYPED_ARRAY_NEW)
6682 #undef TYPED_ARRAY_NEW
6683
6684 Local<DataView> DataView::New(Local<ArrayBuffer> array_buffer,
6685                               size_t byte_offset, size_t byte_length) {
6686   i::Handle<i::JSArrayBuffer> buffer = Utils::OpenHandle(*array_buffer);
6687   i::Isolate* isolate = buffer->GetIsolate();
6688   LOG_API(isolate, "v8::DataView::New(Local<ArrayBuffer>, size_t, size_t)");
6689   ENTER_V8(isolate);
6690   i::Handle<i::JSDataView> obj =
6691       isolate->factory()->NewJSDataView(buffer, byte_offset, byte_length);
6692   return Utils::ToLocal(obj);
6693 }
6694
6695
6696 Local<DataView> DataView::New(Local<SharedArrayBuffer> shared_array_buffer,
6697                               size_t byte_offset, size_t byte_length) {
6698   CHECK(i::FLAG_harmony_sharedarraybuffer);
6699   i::Handle<i::JSArrayBuffer> buffer = Utils::OpenHandle(*shared_array_buffer);
6700   i::Isolate* isolate = buffer->GetIsolate();
6701   LOG_API(isolate,
6702           "v8::DataView::New(Local<SharedArrayBuffer>, size_t, size_t)");
6703   ENTER_V8(isolate);
6704   i::Handle<i::JSDataView> obj =
6705       isolate->factory()->NewJSDataView(buffer, byte_offset, byte_length);
6706   return Utils::ToLocal(obj);
6707 }
6708
6709
6710 bool v8::SharedArrayBuffer::IsExternal() const {
6711   return Utils::OpenHandle(this)->is_external();
6712 }
6713
6714
6715 v8::SharedArrayBuffer::Contents v8::SharedArrayBuffer::Externalize() {
6716   i::Handle<i::JSArrayBuffer> self = Utils::OpenHandle(this);
6717   i::Isolate* isolate = self->GetIsolate();
6718   Utils::ApiCheck(!self->is_external(), "v8::SharedArrayBuffer::Externalize",
6719                   "SharedArrayBuffer already externalized");
6720   self->set_is_external(true);
6721   isolate->heap()->UnregisterArrayBuffer(isolate->heap()->InNewSpace(*self),
6722                                          self->backing_store());
6723   return GetContents();
6724 }
6725
6726
6727 v8::SharedArrayBuffer::Contents v8::SharedArrayBuffer::GetContents() {
6728   i::Handle<i::JSArrayBuffer> self = Utils::OpenHandle(this);
6729   size_t byte_length = static_cast<size_t>(self->byte_length()->Number());
6730   Contents contents;
6731   contents.data_ = self->backing_store();
6732   contents.byte_length_ = byte_length;
6733   return contents;
6734 }
6735
6736
6737 size_t v8::SharedArrayBuffer::ByteLength() const {
6738   i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this);
6739   return static_cast<size_t>(obj->byte_length()->Number());
6740 }
6741
6742
6743 Local<SharedArrayBuffer> v8::SharedArrayBuffer::New(Isolate* isolate,
6744                                                     size_t byte_length) {
6745   CHECK(i::FLAG_harmony_sharedarraybuffer);
6746   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6747   LOG_API(i_isolate, "v8::SharedArrayBuffer::New(size_t)");
6748   ENTER_V8(i_isolate);
6749   i::Handle<i::JSArrayBuffer> obj =
6750       i_isolate->factory()->NewJSArrayBuffer(i::SharedFlag::kShared);
6751   i::JSArrayBuffer::SetupAllocatingData(obj, i_isolate, byte_length, true,
6752                                         i::SharedFlag::kShared);
6753   return Utils::ToLocalShared(obj);
6754 }
6755
6756
6757 Local<SharedArrayBuffer> v8::SharedArrayBuffer::New(
6758     Isolate* isolate, void* data, size_t byte_length,
6759     ArrayBufferCreationMode mode) {
6760   CHECK(i::FLAG_harmony_sharedarraybuffer);
6761   // Embedders must guarantee that the external backing store is valid.
6762   CHECK(byte_length == 0 || data != NULL);
6763   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6764   LOG_API(i_isolate, "v8::SharedArrayBuffer::New(void*, size_t)");
6765   ENTER_V8(i_isolate);
6766   i::Handle<i::JSArrayBuffer> obj =
6767       i_isolate->factory()->NewJSArrayBuffer(i::SharedFlag::kShared);
6768   i::JSArrayBuffer::Setup(obj, i_isolate,
6769                           mode == ArrayBufferCreationMode::kExternalized, data,
6770                           byte_length, i::SharedFlag::kShared);
6771   return Utils::ToLocalShared(obj);
6772 }
6773
6774
6775 Local<Symbol> v8::Symbol::New(Isolate* isolate, Local<String> name) {
6776   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6777   LOG_API(i_isolate, "Symbol::New()");
6778   ENTER_V8(i_isolate);
6779   i::Handle<i::Symbol> result = i_isolate->factory()->NewSymbol();
6780   if (!name.IsEmpty()) result->set_name(*Utils::OpenHandle(*name));
6781   return Utils::ToLocal(result);
6782 }
6783
6784
6785 static i::Handle<i::Symbol> SymbolFor(i::Isolate* isolate,
6786                                       i::Handle<i::String> name,
6787                                       i::Handle<i::String> part) {
6788   i::Handle<i::JSObject> registry = isolate->GetSymbolRegistry();
6789   i::Handle<i::JSObject> symbols =
6790       i::Handle<i::JSObject>::cast(
6791           i::Object::GetPropertyOrElement(registry, part).ToHandleChecked());
6792   i::Handle<i::Object> symbol =
6793       i::Object::GetPropertyOrElement(symbols, name).ToHandleChecked();
6794   if (!symbol->IsSymbol()) {
6795     DCHECK(symbol->IsUndefined());
6796     symbol = isolate->factory()->NewSymbol();
6797     i::Handle<i::Symbol>::cast(symbol)->set_name(*name);
6798     i::JSObject::SetProperty(symbols, name, symbol, i::STRICT).Assert();
6799   }
6800   return i::Handle<i::Symbol>::cast(symbol);
6801 }
6802
6803
6804 Local<Symbol> v8::Symbol::For(Isolate* isolate, Local<String> name) {
6805   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6806   i::Handle<i::String> i_name = Utils::OpenHandle(*name);
6807   i::Handle<i::String> part = i_isolate->factory()->for_string();
6808   return Utils::ToLocal(SymbolFor(i_isolate, i_name, part));
6809 }
6810
6811
6812 Local<Symbol> v8::Symbol::ForApi(Isolate* isolate, Local<String> name) {
6813   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6814   i::Handle<i::String> i_name = Utils::OpenHandle(*name);
6815   i::Handle<i::String> part = i_isolate->factory()->for_api_string();
6816   return Utils::ToLocal(SymbolFor(i_isolate, i_name, part));
6817 }
6818
6819
6820 Local<Symbol> v8::Symbol::GetIterator(Isolate* isolate) {
6821   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6822   return Utils::ToLocal(i_isolate->factory()->iterator_symbol());
6823 }
6824
6825
6826 Local<Symbol> v8::Symbol::GetUnscopables(Isolate* isolate) {
6827   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6828   return Utils::ToLocal(i_isolate->factory()->unscopables_symbol());
6829 }
6830
6831
6832 Local<Symbol> v8::Symbol::GetToStringTag(Isolate* isolate) {
6833   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6834   return Utils::ToLocal(i_isolate->factory()->to_string_tag_symbol());
6835 }
6836
6837
6838 Local<Number> v8::Number::New(Isolate* isolate, double value) {
6839   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
6840   if (std::isnan(value)) {
6841     // Introduce only canonical NaN value into the VM, to avoid signaling NaNs.
6842     value = std::numeric_limits<double>::quiet_NaN();
6843   }
6844   ENTER_V8(internal_isolate);
6845   i::Handle<i::Object> result = internal_isolate->factory()->NewNumber(value);
6846   return Utils::NumberToLocal(result);
6847 }
6848
6849
6850 Local<Integer> v8::Integer::New(Isolate* isolate, int32_t value) {
6851   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
6852   if (i::Smi::IsValid(value)) {
6853     return Utils::IntegerToLocal(i::Handle<i::Object>(i::Smi::FromInt(value),
6854                                                       internal_isolate));
6855   }
6856   ENTER_V8(internal_isolate);
6857   i::Handle<i::Object> result = internal_isolate->factory()->NewNumber(value);
6858   return Utils::IntegerToLocal(result);
6859 }
6860
6861
6862 Local<Integer> v8::Integer::NewFromUnsigned(Isolate* isolate, uint32_t value) {
6863   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
6864   bool fits_into_int32_t = (value & (1 << 31)) == 0;
6865   if (fits_into_int32_t) {
6866     return Integer::New(isolate, static_cast<int32_t>(value));
6867   }
6868   ENTER_V8(internal_isolate);
6869   i::Handle<i::Object> result = internal_isolate->factory()->NewNumber(value);
6870   return Utils::IntegerToLocal(result);
6871 }
6872
6873
6874 void Isolate::CollectAllGarbage(const char* gc_reason) {
6875   i::Heap* heap = reinterpret_cast<i::Isolate*>(this)->heap();
6876   if (heap->incremental_marking()->IsStopped()) {
6877     if (heap->incremental_marking()->CanBeActivated()) {
6878       heap->StartIncrementalMarking(
6879           i::Heap::kNoGCFlags,
6880           kGCCallbackFlagSynchronousPhantomCallbackProcessing, gc_reason);
6881     } else {
6882       heap->CollectAllGarbage(
6883           i::Heap::kNoGCFlags, gc_reason,
6884           kGCCallbackFlagSynchronousPhantomCallbackProcessing);
6885     }
6886   } else {
6887     // Incremental marking is turned on an has already been started.
6888
6889     // TODO(mlippautz): Compute the time slice for incremental marking based on
6890     // memory pressure.
6891     double deadline = heap->MonotonicallyIncreasingTimeInMs() +
6892                       i::FLAG_external_allocation_limit_incremental_time;
6893     heap->AdvanceIncrementalMarking(
6894         0, deadline, i::IncrementalMarking::StepActions(
6895                          i::IncrementalMarking::GC_VIA_STACK_GUARD,
6896                          i::IncrementalMarking::FORCE_MARKING,
6897                          i::IncrementalMarking::FORCE_COMPLETION));
6898   }
6899 }
6900
6901
6902 HeapProfiler* Isolate::GetHeapProfiler() {
6903   i::HeapProfiler* heap_profiler =
6904       reinterpret_cast<i::Isolate*>(this)->heap_profiler();
6905   return reinterpret_cast<HeapProfiler*>(heap_profiler);
6906 }
6907
6908
6909 CpuProfiler* Isolate::GetCpuProfiler() {
6910   i::CpuProfiler* cpu_profiler =
6911       reinterpret_cast<i::Isolate*>(this)->cpu_profiler();
6912   return reinterpret_cast<CpuProfiler*>(cpu_profiler);
6913 }
6914
6915
6916 bool Isolate::InContext() {
6917   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
6918   return isolate->context() != NULL;
6919 }
6920
6921
6922 v8::Local<v8::Context> Isolate::GetCurrentContext() {
6923   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
6924   i::Context* context = isolate->context();
6925   if (context == NULL) return Local<Context>();
6926   i::Context* native_context = context->native_context();
6927   if (native_context == NULL) return Local<Context>();
6928   return Utils::ToLocal(i::Handle<i::Context>(native_context));
6929 }
6930
6931
6932 v8::Local<v8::Context> Isolate::GetCallingContext() {
6933   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
6934   i::Handle<i::Object> calling = isolate->GetCallingNativeContext();
6935   if (calling.is_null()) return Local<Context>();
6936   return Utils::ToLocal(i::Handle<i::Context>::cast(calling));
6937 }
6938
6939
6940 v8::Local<v8::Context> Isolate::GetEnteredContext() {
6941   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
6942   i::Handle<i::Object> last =
6943       isolate->handle_scope_implementer()->LastEnteredContext();
6944   if (last.is_null()) return Local<Context>();
6945   return Utils::ToLocal(i::Handle<i::Context>::cast(last));
6946 }
6947
6948
6949 v8::Local<Value> Isolate::ThrowException(v8::Local<v8::Value> value) {
6950   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
6951   ENTER_V8(isolate);
6952   // If we're passed an empty handle, we throw an undefined exception
6953   // to deal more gracefully with out of memory situations.
6954   if (value.IsEmpty()) {
6955     isolate->ScheduleThrow(isolate->heap()->undefined_value());
6956   } else {
6957     isolate->ScheduleThrow(*Utils::OpenHandle(*value));
6958   }
6959   return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
6960 }
6961
6962
6963 void Isolate::SetObjectGroupId(internal::Object** object, UniqueId id) {
6964   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(this);
6965   internal_isolate->global_handles()->SetObjectGroupId(
6966       v8::internal::Handle<v8::internal::Object>(object).location(),
6967       id);
6968 }
6969
6970
6971 void Isolate::SetReferenceFromGroup(UniqueId id, internal::Object** object) {
6972   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(this);
6973   internal_isolate->global_handles()->SetReferenceFromGroup(
6974       id,
6975       v8::internal::Handle<v8::internal::Object>(object).location());
6976 }
6977
6978
6979 void Isolate::SetReference(internal::Object** parent,
6980                            internal::Object** child) {
6981   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(this);
6982   i::Object** parent_location =
6983       v8::internal::Handle<v8::internal::Object>(parent).location();
6984   internal_isolate->global_handles()->SetReference(
6985       reinterpret_cast<i::HeapObject**>(parent_location),
6986       v8::internal::Handle<v8::internal::Object>(child).location());
6987 }
6988
6989
6990 void Isolate::AddGCPrologueCallback(GCCallback callback, GCType gc_type) {
6991   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
6992   isolate->heap()->AddGCPrologueCallback(callback, gc_type);
6993 }
6994
6995
6996 void Isolate::RemoveGCPrologueCallback(GCCallback callback) {
6997   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
6998   isolate->heap()->RemoveGCPrologueCallback(callback);
6999 }
7000
7001
7002 void Isolate::AddGCEpilogueCallback(GCCallback callback, GCType gc_type) {
7003   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7004   isolate->heap()->AddGCEpilogueCallback(callback, gc_type);
7005 }
7006
7007
7008 void Isolate::RemoveGCEpilogueCallback(GCCallback callback) {
7009   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7010   isolate->heap()->RemoveGCEpilogueCallback(callback);
7011 }
7012
7013
7014 void V8::AddGCPrologueCallback(GCCallback callback, GCType gc_type) {
7015   i::Isolate* isolate = i::Isolate::Current();
7016   isolate->heap()->AddGCPrologueCallback(
7017       reinterpret_cast<v8::Isolate::GCCallback>(callback), gc_type, false);
7018 }
7019
7020
7021 void V8::AddGCEpilogueCallback(GCCallback callback, GCType gc_type) {
7022   i::Isolate* isolate = i::Isolate::Current();
7023   isolate->heap()->AddGCEpilogueCallback(
7024       reinterpret_cast<v8::Isolate::GCCallback>(callback), gc_type, false);
7025 }
7026
7027
7028 void Isolate::AddMemoryAllocationCallback(MemoryAllocationCallback callback,
7029                                           ObjectSpace space,
7030                                           AllocationAction action) {
7031   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7032   isolate->memory_allocator()->AddMemoryAllocationCallback(
7033       callback, space, action);
7034 }
7035
7036
7037 void Isolate::RemoveMemoryAllocationCallback(
7038     MemoryAllocationCallback callback) {
7039   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7040   isolate->memory_allocator()->RemoveMemoryAllocationCallback(
7041       callback);
7042 }
7043
7044
7045 void Isolate::TerminateExecution() {
7046   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7047   isolate->stack_guard()->RequestTerminateExecution();
7048 }
7049
7050
7051 bool Isolate::IsExecutionTerminating() {
7052   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7053   return IsExecutionTerminatingCheck(isolate);
7054 }
7055
7056
7057 void Isolate::CancelTerminateExecution() {
7058   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7059   isolate->stack_guard()->ClearTerminateExecution();
7060   isolate->CancelTerminateExecution();
7061 }
7062
7063
7064 void Isolate::RequestInterrupt(InterruptCallback callback, void* data) {
7065   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7066   isolate->RequestInterrupt(callback, data);
7067 }
7068
7069
7070 void Isolate::RequestGarbageCollectionForTesting(GarbageCollectionType type) {
7071   CHECK(i::FLAG_expose_gc);
7072   if (type == kMinorGarbageCollection) {
7073     reinterpret_cast<i::Isolate*>(this)->heap()->CollectGarbage(
7074         i::NEW_SPACE, "Isolate::RequestGarbageCollection",
7075         kGCCallbackFlagForced);
7076   } else {
7077     DCHECK_EQ(kFullGarbageCollection, type);
7078     reinterpret_cast<i::Isolate*>(this)->heap()->CollectAllGarbage(
7079         i::Heap::kAbortIncrementalMarkingMask,
7080         "Isolate::RequestGarbageCollection", kGCCallbackFlagForced);
7081   }
7082 }
7083
7084
7085 Isolate* Isolate::GetCurrent() {
7086   i::Isolate* isolate = i::Isolate::Current();
7087   return reinterpret_cast<Isolate*>(isolate);
7088 }
7089
7090
7091 Isolate* Isolate::New(const Isolate::CreateParams& params) {
7092   i::Isolate* isolate = new i::Isolate(false);
7093   Isolate* v8_isolate = reinterpret_cast<Isolate*>(isolate);
7094   CHECK(params.array_buffer_allocator != NULL);
7095   isolate->set_array_buffer_allocator(params.array_buffer_allocator);
7096   if (params.snapshot_blob != NULL) {
7097     isolate->set_snapshot_blob(params.snapshot_blob);
7098   } else {
7099     isolate->set_snapshot_blob(i::Snapshot::DefaultSnapshotBlob());
7100   }
7101   if (params.entry_hook) {
7102     isolate->set_function_entry_hook(params.entry_hook);
7103   }
7104   if (params.code_event_handler) {
7105     isolate->InitializeLoggingAndCounters();
7106     isolate->logger()->SetCodeEventHandler(kJitCodeEventDefault,
7107                                            params.code_event_handler);
7108   }
7109   if (params.counter_lookup_callback) {
7110     v8_isolate->SetCounterFunction(params.counter_lookup_callback);
7111   }
7112
7113   if (params.create_histogram_callback) {
7114     v8_isolate->SetCreateHistogramFunction(params.create_histogram_callback);
7115   }
7116
7117   if (params.add_histogram_sample_callback) {
7118     v8_isolate->SetAddHistogramSampleFunction(
7119         params.add_histogram_sample_callback);
7120   }
7121   SetResourceConstraints(isolate, params.constraints);
7122   // TODO(jochen): Once we got rid of Isolate::Current(), we can remove this.
7123   Isolate::Scope isolate_scope(v8_isolate);
7124   if (params.entry_hook || !i::Snapshot::Initialize(isolate)) {
7125     // If the isolate has a function entry hook, it needs to re-build all its
7126     // code stubs with entry hooks embedded, so don't deserialize a snapshot.
7127     if (i::Snapshot::EmbedsScript(isolate)) {
7128       // If the snapshot embeds a script, we cannot initialize the isolate
7129       // without the snapshot as a fallback. This is unlikely to happen though.
7130       V8_Fatal(__FILE__, __LINE__,
7131                "Initializing isolate from custom startup snapshot failed");
7132     }
7133     isolate->Init(NULL);
7134   }
7135   return v8_isolate;
7136 }
7137
7138
7139 void Isolate::Dispose() {
7140   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7141   if (!Utils::ApiCheck(!isolate->IsInUse(),
7142                        "v8::Isolate::Dispose()",
7143                        "Disposing the isolate that is entered by a thread.")) {
7144     return;
7145   }
7146   isolate->TearDown();
7147 }
7148
7149
7150 void Isolate::Enter() {
7151   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7152   isolate->Enter();
7153 }
7154
7155
7156 void Isolate::Exit() {
7157   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7158   isolate->Exit();
7159 }
7160
7161
7162 Isolate::DisallowJavascriptExecutionScope::DisallowJavascriptExecutionScope(
7163     Isolate* isolate,
7164     Isolate::DisallowJavascriptExecutionScope::OnFailure on_failure)
7165     : on_failure_(on_failure) {
7166   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7167   if (on_failure_ == CRASH_ON_FAILURE) {
7168     internal_ = reinterpret_cast<void*>(
7169         new i::DisallowJavascriptExecution(i_isolate));
7170   } else {
7171     DCHECK_EQ(THROW_ON_FAILURE, on_failure);
7172     internal_ = reinterpret_cast<void*>(
7173         new i::ThrowOnJavascriptExecution(i_isolate));
7174   }
7175 }
7176
7177
7178 Isolate::DisallowJavascriptExecutionScope::~DisallowJavascriptExecutionScope() {
7179   if (on_failure_ == CRASH_ON_FAILURE) {
7180     delete reinterpret_cast<i::DisallowJavascriptExecution*>(internal_);
7181   } else {
7182     delete reinterpret_cast<i::ThrowOnJavascriptExecution*>(internal_);
7183   }
7184 }
7185
7186
7187 Isolate::AllowJavascriptExecutionScope::AllowJavascriptExecutionScope(
7188     Isolate* isolate) {
7189   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7190   internal_assert_ = reinterpret_cast<void*>(
7191       new i::AllowJavascriptExecution(i_isolate));
7192   internal_throws_ = reinterpret_cast<void*>(
7193       new i::NoThrowOnJavascriptExecution(i_isolate));
7194 }
7195
7196
7197 Isolate::AllowJavascriptExecutionScope::~AllowJavascriptExecutionScope() {
7198   delete reinterpret_cast<i::AllowJavascriptExecution*>(internal_assert_);
7199   delete reinterpret_cast<i::NoThrowOnJavascriptExecution*>(internal_throws_);
7200 }
7201
7202
7203 Isolate::SuppressMicrotaskExecutionScope::SuppressMicrotaskExecutionScope(
7204     Isolate* isolate)
7205     : isolate_(reinterpret_cast<i::Isolate*>(isolate)) {
7206   isolate_->handle_scope_implementer()->IncrementCallDepth();
7207 }
7208
7209
7210 Isolate::SuppressMicrotaskExecutionScope::~SuppressMicrotaskExecutionScope() {
7211   isolate_->handle_scope_implementer()->DecrementCallDepth();
7212 }
7213
7214
7215 void Isolate::GetHeapStatistics(HeapStatistics* heap_statistics) {
7216   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7217   i::Heap* heap = isolate->heap();
7218   heap_statistics->total_heap_size_ = heap->CommittedMemory();
7219   heap_statistics->total_heap_size_executable_ =
7220       heap->CommittedMemoryExecutable();
7221   heap_statistics->total_physical_size_ = heap->CommittedPhysicalMemory();
7222   heap_statistics->total_available_size_ = heap->Available();
7223   heap_statistics->used_heap_size_ = heap->SizeOfObjects();
7224   heap_statistics->heap_size_limit_ = heap->MaxReserved();
7225 }
7226
7227
7228 size_t Isolate::NumberOfHeapSpaces() {
7229   return i::LAST_SPACE - i::FIRST_SPACE + 1;
7230 }
7231
7232
7233 bool Isolate::GetHeapSpaceStatistics(HeapSpaceStatistics* space_statistics,
7234                                      size_t index) {
7235   if (!space_statistics) return false;
7236   if (!i::Heap::IsValidAllocationSpace(static_cast<i::AllocationSpace>(index)))
7237     return false;
7238
7239   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7240   i::Heap* heap = isolate->heap();
7241   i::Space* space = heap->space(static_cast<int>(index));
7242
7243   space_statistics->space_name_ = heap->GetSpaceName(static_cast<int>(index));
7244   space_statistics->space_size_ = space->CommittedMemory();
7245   space_statistics->space_used_size_ = space->SizeOfObjects();
7246   space_statistics->space_available_size_ = space->Available();
7247   space_statistics->physical_space_size_ = space->CommittedPhysicalMemory();
7248   return true;
7249 }
7250
7251
7252 size_t Isolate::NumberOfTrackedHeapObjectTypes() {
7253   return i::Heap::OBJECT_STATS_COUNT;
7254 }
7255
7256
7257 bool Isolate::GetHeapObjectStatisticsAtLastGC(
7258     HeapObjectStatistics* object_statistics, size_t type_index) {
7259   if (!object_statistics) return false;
7260   if (type_index >= i::Heap::OBJECT_STATS_COUNT) return false;
7261   if (!i::FLAG_track_gc_object_stats) return false;
7262
7263   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7264   i::Heap* heap = isolate->heap();
7265   const char* object_type;
7266   const char* object_sub_type;
7267   size_t object_count = heap->object_count_last_gc(type_index);
7268   size_t object_size = heap->object_size_last_gc(type_index);
7269   if (!heap->GetObjectTypeName(type_index, &object_type, &object_sub_type)) {
7270     // There should be no objects counted when the type is unknown.
7271     DCHECK_EQ(object_count, 0U);
7272     DCHECK_EQ(object_size, 0U);
7273     return false;
7274   }
7275
7276   object_statistics->object_type_ = object_type;
7277   object_statistics->object_sub_type_ = object_sub_type;
7278   object_statistics->object_count_ = object_count;
7279   object_statistics->object_size_ = object_size;
7280   return true;
7281 }
7282
7283
7284 void Isolate::GetStackSample(const RegisterState& state, void** frames,
7285                              size_t frames_limit, SampleInfo* sample_info) {
7286   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7287   i::TickSample::GetStackSample(isolate, state, i::TickSample::kSkipCEntryFrame,
7288                                 frames, frames_limit, sample_info);
7289 }
7290
7291
7292 void Isolate::SetEventLogger(LogEventCallback that) {
7293   // Do not overwrite the event logger if we want to log explicitly.
7294   if (i::FLAG_log_internal_timer_events) return;
7295   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7296   isolate->set_event_logger(that);
7297 }
7298
7299
7300 void Isolate::AddCallCompletedCallback(CallCompletedCallback callback) {
7301   if (callback == NULL) return;
7302   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7303   isolate->AddCallCompletedCallback(callback);
7304 }
7305
7306
7307 void Isolate::RemoveCallCompletedCallback(CallCompletedCallback callback) {
7308   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7309   isolate->RemoveCallCompletedCallback(callback);
7310 }
7311
7312
7313 void Isolate::SetPromiseRejectCallback(PromiseRejectCallback callback) {
7314   if (callback == NULL) return;
7315   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7316   isolate->SetPromiseRejectCallback(callback);
7317 }
7318
7319
7320 void Isolate::RunMicrotasks() {
7321   reinterpret_cast<i::Isolate*>(this)->RunMicrotasks();
7322 }
7323
7324
7325 void Isolate::EnqueueMicrotask(Local<Function> microtask) {
7326   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7327   isolate->EnqueueMicrotask(Utils::OpenHandle(*microtask));
7328 }
7329
7330
7331 void Isolate::EnqueueMicrotask(MicrotaskCallback microtask, void* data) {
7332   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7333   i::HandleScope scope(isolate);
7334   i::Handle<i::CallHandlerInfo> callback_info =
7335       i::Handle<i::CallHandlerInfo>::cast(
7336           isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE));
7337   SET_FIELD_WRAPPED(callback_info, set_callback, microtask);
7338   SET_FIELD_WRAPPED(callback_info, set_data, data);
7339   isolate->EnqueueMicrotask(callback_info);
7340 }
7341
7342
7343 void Isolate::SetAutorunMicrotasks(bool autorun) {
7344   reinterpret_cast<i::Isolate*>(this)->set_autorun_microtasks(autorun);
7345 }
7346
7347
7348 bool Isolate::WillAutorunMicrotasks() const {
7349   return reinterpret_cast<const i::Isolate*>(this)->autorun_microtasks();
7350 }
7351
7352
7353 void Isolate::SetUseCounterCallback(UseCounterCallback callback) {
7354   reinterpret_cast<i::Isolate*>(this)->SetUseCounterCallback(callback);
7355 }
7356
7357
7358 void Isolate::SetCounterFunction(CounterLookupCallback callback) {
7359   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7360   isolate->stats_table()->SetCounterFunction(callback);
7361   isolate->InitializeLoggingAndCounters();
7362   isolate->counters()->ResetCounters();
7363 }
7364
7365
7366 void Isolate::SetCreateHistogramFunction(CreateHistogramCallback callback) {
7367   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7368   isolate->stats_table()->SetCreateHistogramFunction(callback);
7369   isolate->InitializeLoggingAndCounters();
7370   isolate->counters()->ResetHistograms();
7371 }
7372
7373
7374 void Isolate::SetAddHistogramSampleFunction(
7375     AddHistogramSampleCallback callback) {
7376   reinterpret_cast<i::Isolate*>(this)
7377       ->stats_table()
7378       ->SetAddHistogramSampleFunction(callback);
7379 }
7380
7381
7382 bool Isolate::IdleNotification(int idle_time_in_ms) {
7383   // Returning true tells the caller that it need not
7384   // continue to call IdleNotification.
7385   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7386   if (!i::FLAG_use_idle_notification) return true;
7387   return isolate->heap()->IdleNotification(idle_time_in_ms);
7388 }
7389
7390
7391 bool Isolate::IdleNotificationDeadline(double deadline_in_seconds) {
7392   // Returning true tells the caller that it need not
7393   // continue to call IdleNotification.
7394   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7395   if (!i::FLAG_use_idle_notification) return true;
7396   return isolate->heap()->IdleNotification(deadline_in_seconds);
7397 }
7398
7399
7400 void Isolate::LowMemoryNotification() {
7401   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7402   {
7403     i::HistogramTimerScope idle_notification_scope(
7404         isolate->counters()->gc_low_memory_notification());
7405     isolate->heap()->CollectAllAvailableGarbage("low memory notification");
7406   }
7407 }
7408
7409
7410 int Isolate::ContextDisposedNotification(bool dependant_context) {
7411   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7412   return isolate->heap()->NotifyContextDisposed(dependant_context);
7413 }
7414
7415
7416 void Isolate::SetJitCodeEventHandler(JitCodeEventOptions options,
7417                                      JitCodeEventHandler event_handler) {
7418   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7419   // Ensure that logging is initialized for our isolate.
7420   isolate->InitializeLoggingAndCounters();
7421   isolate->logger()->SetCodeEventHandler(options, event_handler);
7422 }
7423
7424
7425 void Isolate::SetStackLimit(uintptr_t stack_limit) {
7426   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7427   CHECK(stack_limit);
7428   isolate->stack_guard()->SetStackLimit(stack_limit);
7429 }
7430
7431
7432 void Isolate::GetCodeRange(void** start, size_t* length_in_bytes) {
7433   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7434   if (isolate->code_range()->valid()) {
7435     *start = isolate->code_range()->start();
7436     *length_in_bytes = isolate->code_range()->size();
7437   } else {
7438     *start = NULL;
7439     *length_in_bytes = 0;
7440   }
7441 }
7442
7443
7444 void Isolate::SetFatalErrorHandler(FatalErrorCallback that) {
7445   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7446   isolate->set_exception_behavior(that);
7447 }
7448
7449
7450 void Isolate::SetAllowCodeGenerationFromStringsCallback(
7451     AllowCodeGenerationFromStringsCallback callback) {
7452   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7453   isolate->set_allow_code_gen_callback(callback);
7454 }
7455
7456
7457 bool Isolate::IsDead() {
7458   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7459   return isolate->IsDead();
7460 }
7461
7462
7463 bool Isolate::AddMessageListener(MessageCallback that, Local<Value> data) {
7464   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7465   ENTER_V8(isolate);
7466   i::HandleScope scope(isolate);
7467   NeanderArray listeners(isolate->factory()->message_listeners());
7468   NeanderObject obj(isolate, 2);
7469   obj.set(0, *isolate->factory()->NewForeign(FUNCTION_ADDR(that)));
7470   obj.set(1, data.IsEmpty() ? isolate->heap()->undefined_value()
7471                             : *Utils::OpenHandle(*data));
7472   listeners.add(isolate, obj.value());
7473   return true;
7474 }
7475
7476
7477 void Isolate::RemoveMessageListeners(MessageCallback that) {
7478   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7479   ENTER_V8(isolate);
7480   i::HandleScope scope(isolate);
7481   NeanderArray listeners(isolate->factory()->message_listeners());
7482   for (int i = 0; i < listeners.length(); i++) {
7483     if (listeners.get(i)->IsUndefined()) continue;  // skip deleted ones
7484
7485     NeanderObject listener(i::JSObject::cast(listeners.get(i)));
7486     i::Handle<i::Foreign> callback_obj(i::Foreign::cast(listener.get(0)));
7487     if (callback_obj->foreign_address() == FUNCTION_ADDR(that)) {
7488       listeners.set(i, isolate->heap()->undefined_value());
7489     }
7490   }
7491 }
7492
7493
7494 void Isolate::SetFailedAccessCheckCallbackFunction(
7495     FailedAccessCheckCallback callback) {
7496   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7497   isolate->SetFailedAccessCheckCallback(callback);
7498 }
7499
7500
7501 void Isolate::SetCaptureStackTraceForUncaughtExceptions(
7502     bool capture, int frame_limit, StackTrace::StackTraceOptions options) {
7503   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7504   isolate->SetCaptureStackTraceForUncaughtExceptions(capture, frame_limit,
7505                                                      options);
7506 }
7507
7508
7509 void Isolate::VisitExternalResources(ExternalResourceVisitor* visitor) {
7510   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7511   isolate->heap()->VisitExternalResources(visitor);
7512 }
7513
7514
7515 class VisitorAdapter : public i::ObjectVisitor {
7516  public:
7517   explicit VisitorAdapter(PersistentHandleVisitor* visitor)
7518       : visitor_(visitor) {}
7519   virtual void VisitPointers(i::Object** start, i::Object** end) {
7520     UNREACHABLE();
7521   }
7522   virtual void VisitEmbedderReference(i::Object** p, uint16_t class_id) {
7523     Value* value = ToApi<Value>(i::Handle<i::Object>(p));
7524     visitor_->VisitPersistentHandle(
7525         reinterpret_cast<Persistent<Value>*>(&value), class_id);
7526   }
7527
7528  private:
7529   PersistentHandleVisitor* visitor_;
7530 };
7531
7532
7533 void Isolate::VisitHandlesWithClassIds(PersistentHandleVisitor* visitor) {
7534   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7535   i::DisallowHeapAllocation no_allocation;
7536   VisitorAdapter visitor_adapter(visitor);
7537   isolate->global_handles()->IterateAllRootsWithClassIds(&visitor_adapter);
7538 }
7539
7540
7541 void Isolate::VisitHandlesForPartialDependence(
7542     PersistentHandleVisitor* visitor) {
7543   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
7544   i::DisallowHeapAllocation no_allocation;
7545   VisitorAdapter visitor_adapter(visitor);
7546   isolate->global_handles()->IterateAllRootsInNewSpaceWithClassIds(
7547       &visitor_adapter);
7548 }
7549
7550
7551 String::Utf8Value::Utf8Value(v8::Local<v8::Value> obj)
7552     : str_(NULL), length_(0) {
7553   if (obj.IsEmpty()) return;
7554   i::Isolate* isolate = i::Isolate::Current();
7555   Isolate* v8_isolate = reinterpret_cast<Isolate*>(isolate);
7556   ENTER_V8(isolate);
7557   i::HandleScope scope(isolate);
7558   Local<Context> context = v8_isolate->GetCurrentContext();
7559   TryCatch try_catch(v8_isolate);
7560   Local<String> str;
7561   if (!obj->ToString(context).ToLocal(&str)) return;
7562   i::Handle<i::String> i_str = Utils::OpenHandle(*str);
7563   length_ = v8::Utf8Length(*i_str, isolate);
7564   str_ = i::NewArray<char>(length_ + 1);
7565   str->WriteUtf8(str_);
7566 }
7567
7568
7569 String::Utf8Value::~Utf8Value() {
7570   i::DeleteArray(str_);
7571 }
7572
7573
7574 String::Value::Value(v8::Local<v8::Value> obj) : str_(NULL), length_(0) {
7575   if (obj.IsEmpty()) return;
7576   i::Isolate* isolate = i::Isolate::Current();
7577   Isolate* v8_isolate = reinterpret_cast<Isolate*>(isolate);
7578   ENTER_V8(isolate);
7579   i::HandleScope scope(isolate);
7580   Local<Context> context = v8_isolate->GetCurrentContext();
7581   TryCatch try_catch(v8_isolate);
7582   Local<String> str;
7583   if (!obj->ToString(context).ToLocal(&str)) return;
7584   length_ = str->Length();
7585   str_ = i::NewArray<uint16_t>(length_ + 1);
7586   str->Write(str_);
7587 }
7588
7589
7590 String::Value::~Value() {
7591   i::DeleteArray(str_);
7592 }
7593
7594
7595 #define DEFINE_ERROR(NAME, name)                                         \
7596   Local<Value> Exception::NAME(v8::Local<v8::String> raw_message) {      \
7597     i::Isolate* isolate = i::Isolate::Current();                         \
7598     LOG_API(isolate, #NAME);                                             \
7599     ENTER_V8(isolate);                                                   \
7600     i::Object* error;                                                    \
7601     {                                                                    \
7602       i::HandleScope scope(isolate);                                     \
7603       i::Handle<i::String> message = Utils::OpenHandle(*raw_message);    \
7604       i::Handle<i::JSFunction> constructor = isolate->name##_function(); \
7605       error = *isolate->factory()->NewError(constructor, message);       \
7606     }                                                                    \
7607     i::Handle<i::Object> result(error, isolate);                         \
7608     return Utils::ToLocal(result);                                       \
7609   }
7610
7611 DEFINE_ERROR(RangeError, range_error)
7612 DEFINE_ERROR(ReferenceError, reference_error)
7613 DEFINE_ERROR(SyntaxError, syntax_error)
7614 DEFINE_ERROR(TypeError, type_error)
7615 DEFINE_ERROR(Error, error)
7616
7617 #undef DEFINE_ERROR
7618
7619
7620 Local<Message> Exception::CreateMessage(Local<Value> exception) {
7621   i::Handle<i::Object> obj = Utils::OpenHandle(*exception);
7622   if (!obj->IsHeapObject()) return Local<Message>();
7623   i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
7624   ENTER_V8(isolate);
7625   i::HandleScope scope(isolate);
7626   return Utils::MessageToLocal(
7627       scope.CloseAndEscape(isolate->CreateMessage(obj, NULL)));
7628 }
7629
7630
7631 Local<StackTrace> Exception::GetStackTrace(Local<Value> exception) {
7632   i::Handle<i::Object> obj = Utils::OpenHandle(*exception);
7633   if (!obj->IsJSObject()) return Local<StackTrace>();
7634   i::Handle<i::JSObject> js_obj = i::Handle<i::JSObject>::cast(obj);
7635   i::Isolate* isolate = js_obj->GetIsolate();
7636   ENTER_V8(isolate);
7637   return Utils::StackTraceToLocal(isolate->GetDetailedStackTrace(js_obj));
7638 }
7639
7640
7641 // --- D e b u g   S u p p o r t ---
7642
7643 bool Debug::SetDebugEventListener(EventCallback that, Local<Value> data) {
7644   i::Isolate* isolate = i::Isolate::Current();
7645   ENTER_V8(isolate);
7646   i::HandleScope scope(isolate);
7647   i::Handle<i::Object> foreign = isolate->factory()->undefined_value();
7648   if (that != NULL) {
7649     foreign = isolate->factory()->NewForeign(FUNCTION_ADDR(that));
7650   }
7651   isolate->debug()->SetEventListener(foreign,
7652                                      Utils::OpenHandle(*data, true));
7653   return true;
7654 }
7655
7656
7657 void Debug::DebugBreak(Isolate* isolate) {
7658   reinterpret_cast<i::Isolate*>(isolate)->stack_guard()->RequestDebugBreak();
7659 }
7660
7661
7662 void Debug::CancelDebugBreak(Isolate* isolate) {
7663   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
7664   internal_isolate->stack_guard()->ClearDebugBreak();
7665 }
7666
7667
7668 bool Debug::CheckDebugBreak(Isolate* isolate) {
7669   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
7670   return internal_isolate->stack_guard()->CheckDebugBreak();
7671 }
7672
7673
7674 void Debug::SetMessageHandler(v8::Debug::MessageHandler handler) {
7675   i::Isolate* isolate = i::Isolate::Current();
7676   ENTER_V8(isolate);
7677   isolate->debug()->SetMessageHandler(handler);
7678 }
7679
7680
7681 void Debug::SendCommand(Isolate* isolate,
7682                         const uint16_t* command,
7683                         int length,
7684                         ClientData* client_data) {
7685   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
7686   internal_isolate->debug()->EnqueueCommandMessage(
7687       i::Vector<const uint16_t>(command, length), client_data);
7688 }
7689
7690
7691 MaybeLocal<Value> Debug::Call(Local<Context> context,
7692                               v8::Local<v8::Function> fun,
7693                               v8::Local<v8::Value> data) {
7694   PREPARE_FOR_EXECUTION(context, "v8::Debug::Call()", Value);
7695   i::Handle<i::Object> data_obj;
7696   if (data.IsEmpty()) {
7697     data_obj = isolate->factory()->undefined_value();
7698   } else {
7699     data_obj = Utils::OpenHandle(*data);
7700   }
7701   Local<Value> result;
7702   has_pending_exception =
7703       !ToLocal<Value>(isolate->debug()->Call(Utils::OpenHandle(*fun), data_obj),
7704                       &result);
7705   RETURN_ON_FAILED_EXECUTION(Value);
7706   RETURN_ESCAPED(result);
7707 }
7708
7709
7710 Local<Value> Debug::Call(v8::Local<v8::Function> fun,
7711                          v8::Local<v8::Value> data) {
7712   auto context = ContextFromHeapObject(Utils::OpenHandle(*fun));
7713   RETURN_TO_LOCAL_UNCHECKED(Call(context, fun, data), Value);
7714 }
7715
7716
7717 MaybeLocal<Value> Debug::GetMirror(Local<Context> context,
7718                                    v8::Local<v8::Value> obj) {
7719   PREPARE_FOR_EXECUTION(context, "v8::Debug::GetMirror()", Value);
7720   i::Debug* isolate_debug = isolate->debug();
7721   has_pending_exception = !isolate_debug->Load();
7722   RETURN_ON_FAILED_EXECUTION(Value);
7723   i::Handle<i::JSObject> debug(isolate_debug->debug_context()->global_object());
7724   auto name = isolate->factory()->NewStringFromStaticChars("MakeMirror");
7725   auto fun_obj = i::Object::GetProperty(debug, name).ToHandleChecked();
7726   auto v8_fun = Utils::ToLocal(i::Handle<i::JSFunction>::cast(fun_obj));
7727   const int kArgc = 1;
7728   v8::Local<v8::Value> argv[kArgc] = {obj};
7729   Local<Value> result;
7730   has_pending_exception = !v8_fun->Call(context, Utils::ToLocal(debug), kArgc,
7731                                         argv).ToLocal(&result);
7732   RETURN_ON_FAILED_EXECUTION(Value);
7733   RETURN_ESCAPED(result);
7734 }
7735
7736
7737 Local<Value> Debug::GetMirror(v8::Local<v8::Value> obj) {
7738   RETURN_TO_LOCAL_UNCHECKED(GetMirror(Local<Context>(), obj), Value);
7739 }
7740
7741
7742 void Debug::ProcessDebugMessages() {
7743   i::Isolate::Current()->debug()->ProcessDebugMessages(true);
7744 }
7745
7746
7747 Local<Context> Debug::GetDebugContext() {
7748   i::Isolate* isolate = i::Isolate::Current();
7749   ENTER_V8(isolate);
7750   return Utils::ToLocal(isolate->debug()->GetDebugContext());
7751 }
7752
7753
7754 void Debug::SetLiveEditEnabled(Isolate* isolate, bool enable) {
7755   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
7756   internal_isolate->debug()->set_live_edit_enabled(enable);
7757 }
7758
7759
7760 MaybeLocal<Array> Debug::GetInternalProperties(Isolate* v8_isolate,
7761                                                Local<Value> value) {
7762   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
7763   ENTER_V8(isolate);
7764   i::Handle<i::Object> val = Utils::OpenHandle(*value);
7765   i::Handle<i::JSArray> result;
7766   if (!i::Runtime::GetInternalProperties(isolate, val).ToHandle(&result))
7767     return MaybeLocal<Array>();
7768   return Utils::ToLocal(result);
7769 }
7770
7771
7772 Local<String> CpuProfileNode::GetFunctionName() const {
7773   i::Isolate* isolate = i::Isolate::Current();
7774   const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
7775   const i::CodeEntry* entry = node->entry();
7776   i::Handle<i::String> name =
7777       isolate->factory()->InternalizeUtf8String(entry->name());
7778   if (!entry->has_name_prefix()) {
7779     return ToApiHandle<String>(name);
7780   } else {
7781     // We do not expect this to fail. Change this if it does.
7782     i::Handle<i::String> cons = isolate->factory()->NewConsString(
7783         isolate->factory()->InternalizeUtf8String(entry->name_prefix()),
7784         name).ToHandleChecked();
7785     return ToApiHandle<String>(cons);
7786   }
7787 }
7788
7789
7790 int CpuProfileNode::GetScriptId() const {
7791   const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
7792   const i::CodeEntry* entry = node->entry();
7793   return entry->script_id();
7794 }
7795
7796
7797 Local<String> CpuProfileNode::GetScriptResourceName() const {
7798   i::Isolate* isolate = i::Isolate::Current();
7799   const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
7800   return ToApiHandle<String>(isolate->factory()->InternalizeUtf8String(
7801       node->entry()->resource_name()));
7802 }
7803
7804
7805 int CpuProfileNode::GetLineNumber() const {
7806   return reinterpret_cast<const i::ProfileNode*>(this)->entry()->line_number();
7807 }
7808
7809
7810 int CpuProfileNode::GetColumnNumber() const {
7811   return reinterpret_cast<const i::ProfileNode*>(this)->
7812       entry()->column_number();
7813 }
7814
7815
7816 unsigned int CpuProfileNode::GetHitLineCount() const {
7817   const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
7818   return node->GetHitLineCount();
7819 }
7820
7821
7822 bool CpuProfileNode::GetLineTicks(LineTick* entries,
7823                                   unsigned int length) const {
7824   const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
7825   return node->GetLineTicks(entries, length);
7826 }
7827
7828
7829 const char* CpuProfileNode::GetBailoutReason() const {
7830   const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
7831   return node->entry()->bailout_reason();
7832 }
7833
7834
7835 unsigned CpuProfileNode::GetHitCount() const {
7836   return reinterpret_cast<const i::ProfileNode*>(this)->self_ticks();
7837 }
7838
7839
7840 unsigned CpuProfileNode::GetCallUid() const {
7841   return reinterpret_cast<const i::ProfileNode*>(this)->function_id();
7842 }
7843
7844
7845 unsigned CpuProfileNode::GetNodeId() const {
7846   return reinterpret_cast<const i::ProfileNode*>(this)->id();
7847 }
7848
7849
7850 int CpuProfileNode::GetChildrenCount() const {
7851   return reinterpret_cast<const i::ProfileNode*>(this)->children()->length();
7852 }
7853
7854
7855 const CpuProfileNode* CpuProfileNode::GetChild(int index) const {
7856   const i::ProfileNode* child =
7857       reinterpret_cast<const i::ProfileNode*>(this)->children()->at(index);
7858   return reinterpret_cast<const CpuProfileNode*>(child);
7859 }
7860
7861
7862 const std::vector<CpuProfileDeoptInfo>& CpuProfileNode::GetDeoptInfos() const {
7863   const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
7864   return node->deopt_infos();
7865 }
7866
7867
7868 void CpuProfile::Delete() {
7869   i::Isolate* isolate = i::Isolate::Current();
7870   i::CpuProfiler* profiler = isolate->cpu_profiler();
7871   DCHECK(profiler != NULL);
7872   profiler->DeleteProfile(reinterpret_cast<i::CpuProfile*>(this));
7873 }
7874
7875
7876 Local<String> CpuProfile::GetTitle() const {
7877   i::Isolate* isolate = i::Isolate::Current();
7878   const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this);
7879   return ToApiHandle<String>(isolate->factory()->InternalizeUtf8String(
7880       profile->title()));
7881 }
7882
7883
7884 const CpuProfileNode* CpuProfile::GetTopDownRoot() const {
7885   const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this);
7886   return reinterpret_cast<const CpuProfileNode*>(profile->top_down()->root());
7887 }
7888
7889
7890 const CpuProfileNode* CpuProfile::GetSample(int index) const {
7891   const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this);
7892   return reinterpret_cast<const CpuProfileNode*>(profile->sample(index));
7893 }
7894
7895
7896 int64_t CpuProfile::GetSampleTimestamp(int index) const {
7897   const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this);
7898   return (profile->sample_timestamp(index) - base::TimeTicks())
7899       .InMicroseconds();
7900 }
7901
7902
7903 int64_t CpuProfile::GetStartTime() const {
7904   const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this);
7905   return (profile->start_time() - base::TimeTicks()).InMicroseconds();
7906 }
7907
7908
7909 int64_t CpuProfile::GetEndTime() const {
7910   const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this);
7911   return (profile->end_time() - base::TimeTicks()).InMicroseconds();
7912 }
7913
7914
7915 int CpuProfile::GetSamplesCount() const {
7916   return reinterpret_cast<const i::CpuProfile*>(this)->samples_count();
7917 }
7918
7919
7920 void CpuProfiler::SetSamplingInterval(int us) {
7921   DCHECK(us >= 0);
7922   return reinterpret_cast<i::CpuProfiler*>(this)->set_sampling_interval(
7923       base::TimeDelta::FromMicroseconds(us));
7924 }
7925
7926
7927 void CpuProfiler::StartProfiling(Local<String> title, bool record_samples) {
7928   reinterpret_cast<i::CpuProfiler*>(this)->StartProfiling(
7929       *Utils::OpenHandle(*title), record_samples);
7930 }
7931
7932
7933 CpuProfile* CpuProfiler::StopProfiling(Local<String> title) {
7934   return reinterpret_cast<CpuProfile*>(
7935       reinterpret_cast<i::CpuProfiler*>(this)->StopProfiling(
7936           *Utils::OpenHandle(*title)));
7937 }
7938
7939
7940 void CpuProfiler::SetIdle(bool is_idle) {
7941   i::Isolate* isolate = reinterpret_cast<i::CpuProfiler*>(this)->isolate();
7942   v8::StateTag state = isolate->current_vm_state();
7943   DCHECK(state == v8::EXTERNAL || state == v8::IDLE);
7944   if (isolate->js_entry_sp() != NULL) return;
7945   if (is_idle) {
7946     isolate->set_current_vm_state(v8::IDLE);
7947   } else if (state == v8::IDLE) {
7948     isolate->set_current_vm_state(v8::EXTERNAL);
7949   }
7950 }
7951
7952
7953 static i::HeapGraphEdge* ToInternal(const HeapGraphEdge* edge) {
7954   return const_cast<i::HeapGraphEdge*>(
7955       reinterpret_cast<const i::HeapGraphEdge*>(edge));
7956 }
7957
7958
7959 HeapGraphEdge::Type HeapGraphEdge::GetType() const {
7960   return static_cast<HeapGraphEdge::Type>(ToInternal(this)->type());
7961 }
7962
7963
7964 Local<Value> HeapGraphEdge::GetName() const {
7965   i::Isolate* isolate = i::Isolate::Current();
7966   i::HeapGraphEdge* edge = ToInternal(this);
7967   switch (edge->type()) {
7968     case i::HeapGraphEdge::kContextVariable:
7969     case i::HeapGraphEdge::kInternal:
7970     case i::HeapGraphEdge::kProperty:
7971     case i::HeapGraphEdge::kShortcut:
7972     case i::HeapGraphEdge::kWeak:
7973       return ToApiHandle<String>(
7974           isolate->factory()->InternalizeUtf8String(edge->name()));
7975     case i::HeapGraphEdge::kElement:
7976     case i::HeapGraphEdge::kHidden:
7977       return ToApiHandle<Number>(
7978           isolate->factory()->NewNumberFromInt(edge->index()));
7979     default: UNREACHABLE();
7980   }
7981   return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
7982 }
7983
7984
7985 const HeapGraphNode* HeapGraphEdge::GetFromNode() const {
7986   const i::HeapEntry* from = ToInternal(this)->from();
7987   return reinterpret_cast<const HeapGraphNode*>(from);
7988 }
7989
7990
7991 const HeapGraphNode* HeapGraphEdge::GetToNode() const {
7992   const i::HeapEntry* to = ToInternal(this)->to();
7993   return reinterpret_cast<const HeapGraphNode*>(to);
7994 }
7995
7996
7997 static i::HeapEntry* ToInternal(const HeapGraphNode* entry) {
7998   return const_cast<i::HeapEntry*>(
7999       reinterpret_cast<const i::HeapEntry*>(entry));
8000 }
8001
8002
8003 HeapGraphNode::Type HeapGraphNode::GetType() const {
8004   return static_cast<HeapGraphNode::Type>(ToInternal(this)->type());
8005 }
8006
8007
8008 Local<String> HeapGraphNode::GetName() const {
8009   i::Isolate* isolate = i::Isolate::Current();
8010   return ToApiHandle<String>(
8011       isolate->factory()->InternalizeUtf8String(ToInternal(this)->name()));
8012 }
8013
8014
8015 SnapshotObjectId HeapGraphNode::GetId() const {
8016   return ToInternal(this)->id();
8017 }
8018
8019
8020 size_t HeapGraphNode::GetShallowSize() const {
8021   return ToInternal(this)->self_size();
8022 }
8023
8024
8025 int HeapGraphNode::GetChildrenCount() const {
8026   return ToInternal(this)->children().length();
8027 }
8028
8029
8030 const HeapGraphEdge* HeapGraphNode::GetChild(int index) const {
8031   return reinterpret_cast<const HeapGraphEdge*>(
8032       ToInternal(this)->children()[index]);
8033 }
8034
8035
8036 static i::HeapSnapshot* ToInternal(const HeapSnapshot* snapshot) {
8037   return const_cast<i::HeapSnapshot*>(
8038       reinterpret_cast<const i::HeapSnapshot*>(snapshot));
8039 }
8040
8041
8042 void HeapSnapshot::Delete() {
8043   i::Isolate* isolate = i::Isolate::Current();
8044   if (isolate->heap_profiler()->GetSnapshotsCount() > 1) {
8045     ToInternal(this)->Delete();
8046   } else {
8047     // If this is the last snapshot, clean up all accessory data as well.
8048     isolate->heap_profiler()->DeleteAllSnapshots();
8049   }
8050 }
8051
8052
8053 const HeapGraphNode* HeapSnapshot::GetRoot() const {
8054   return reinterpret_cast<const HeapGraphNode*>(ToInternal(this)->root());
8055 }
8056
8057
8058 const HeapGraphNode* HeapSnapshot::GetNodeById(SnapshotObjectId id) const {
8059   return reinterpret_cast<const HeapGraphNode*>(
8060       ToInternal(this)->GetEntryById(id));
8061 }
8062
8063
8064 int HeapSnapshot::GetNodesCount() const {
8065   return ToInternal(this)->entries().length();
8066 }
8067
8068
8069 const HeapGraphNode* HeapSnapshot::GetNode(int index) const {
8070   return reinterpret_cast<const HeapGraphNode*>(
8071       &ToInternal(this)->entries().at(index));
8072 }
8073
8074
8075 SnapshotObjectId HeapSnapshot::GetMaxSnapshotJSObjectId() const {
8076   return ToInternal(this)->max_snapshot_js_object_id();
8077 }
8078
8079
8080 void HeapSnapshot::Serialize(OutputStream* stream,
8081                              HeapSnapshot::SerializationFormat format) const {
8082   Utils::ApiCheck(format == kJSON,
8083                   "v8::HeapSnapshot::Serialize",
8084                   "Unknown serialization format");
8085   Utils::ApiCheck(stream->GetChunkSize() > 0,
8086                   "v8::HeapSnapshot::Serialize",
8087                   "Invalid stream chunk size");
8088   i::HeapSnapshotJSONSerializer serializer(ToInternal(this));
8089   serializer.Serialize(stream);
8090 }
8091
8092
8093 // static
8094 STATIC_CONST_MEMBER_DEFINITION const SnapshotObjectId
8095     HeapProfiler::kUnknownObjectId;
8096
8097
8098 int HeapProfiler::GetSnapshotCount() {
8099   return reinterpret_cast<i::HeapProfiler*>(this)->GetSnapshotsCount();
8100 }
8101
8102
8103 const HeapSnapshot* HeapProfiler::GetHeapSnapshot(int index) {
8104   return reinterpret_cast<const HeapSnapshot*>(
8105       reinterpret_cast<i::HeapProfiler*>(this)->GetSnapshot(index));
8106 }
8107
8108
8109 SnapshotObjectId HeapProfiler::GetObjectId(Local<Value> value) {
8110   i::Handle<i::Object> obj = Utils::OpenHandle(*value);
8111   return reinterpret_cast<i::HeapProfiler*>(this)->GetSnapshotObjectId(obj);
8112 }
8113
8114
8115 Local<Value> HeapProfiler::FindObjectById(SnapshotObjectId id) {
8116   i::Handle<i::Object> obj =
8117       reinterpret_cast<i::HeapProfiler*>(this)->FindHeapObjectById(id);
8118   if (obj.is_null()) return Local<Value>();
8119   return Utils::ToLocal(obj);
8120 }
8121
8122
8123 void HeapProfiler::ClearObjectIds() {
8124   reinterpret_cast<i::HeapProfiler*>(this)->ClearHeapObjectMap();
8125 }
8126
8127
8128 const HeapSnapshot* HeapProfiler::TakeHeapSnapshot(
8129     ActivityControl* control, ObjectNameResolver* resolver) {
8130   return reinterpret_cast<const HeapSnapshot*>(
8131       reinterpret_cast<i::HeapProfiler*>(this)
8132           ->TakeSnapshot(control, resolver));
8133 }
8134
8135
8136 void HeapProfiler::StartTrackingHeapObjects(bool track_allocations) {
8137   reinterpret_cast<i::HeapProfiler*>(this)->StartHeapObjectsTracking(
8138       track_allocations);
8139 }
8140
8141
8142 void HeapProfiler::StopTrackingHeapObjects() {
8143   reinterpret_cast<i::HeapProfiler*>(this)->StopHeapObjectsTracking();
8144 }
8145
8146
8147 SnapshotObjectId HeapProfiler::GetHeapStats(OutputStream* stream,
8148                                             int64_t* timestamp_us) {
8149   i::HeapProfiler* heap_profiler = reinterpret_cast<i::HeapProfiler*>(this);
8150   return heap_profiler->PushHeapObjectsStats(stream, timestamp_us);
8151 }
8152
8153
8154 void HeapProfiler::DeleteAllHeapSnapshots() {
8155   reinterpret_cast<i::HeapProfiler*>(this)->DeleteAllSnapshots();
8156 }
8157
8158
8159 void HeapProfiler::SetWrapperClassInfoProvider(uint16_t class_id,
8160                                                WrapperInfoCallback callback) {
8161   reinterpret_cast<i::HeapProfiler*>(this)->DefineWrapperClass(class_id,
8162                                                                callback);
8163 }
8164
8165
8166 size_t HeapProfiler::GetProfilerMemorySize() {
8167   return reinterpret_cast<i::HeapProfiler*>(this)->
8168       GetMemorySizeUsedByProfiler();
8169 }
8170
8171
8172 void HeapProfiler::SetRetainedObjectInfo(UniqueId id,
8173                                          RetainedObjectInfo* info) {
8174   reinterpret_cast<i::HeapProfiler*>(this)->SetRetainedObjectInfo(id, info);
8175 }
8176
8177
8178 v8::Testing::StressType internal::Testing::stress_type_ =
8179     v8::Testing::kStressTypeOpt;
8180
8181
8182 void Testing::SetStressRunType(Testing::StressType type) {
8183   internal::Testing::set_stress_type(type);
8184 }
8185
8186
8187 int Testing::GetStressRuns() {
8188   if (internal::FLAG_stress_runs != 0) return internal::FLAG_stress_runs;
8189 #ifdef DEBUG
8190   // In debug mode the code runs much slower so stressing will only make two
8191   // runs.
8192   return 2;
8193 #else
8194   return 5;
8195 #endif
8196 }
8197
8198
8199 static void SetFlagsFromString(const char* flags) {
8200   V8::SetFlagsFromString(flags, i::StrLength(flags));
8201 }
8202
8203
8204 void Testing::PrepareStressRun(int run) {
8205   static const char* kLazyOptimizations =
8206       "--prepare-always-opt "
8207       "--max-inlined-source-size=999999 "
8208       "--max-inlined-nodes=999999 "
8209       "--max-inlined-nodes-cumulative=999999 "
8210       "--noalways-opt";
8211   static const char* kForcedOptimizations = "--always-opt";
8212
8213   // If deoptimization stressed turn on frequent deoptimization. If no value
8214   // is spefified through --deopt-every-n-times use a default default value.
8215   static const char* kDeoptEvery13Times = "--deopt-every-n-times=13";
8216   if (internal::Testing::stress_type() == Testing::kStressTypeDeopt &&
8217       internal::FLAG_deopt_every_n_times == 0) {
8218     SetFlagsFromString(kDeoptEvery13Times);
8219   }
8220
8221 #ifdef DEBUG
8222   // As stressing in debug mode only make two runs skip the deopt stressing
8223   // here.
8224   if (run == GetStressRuns() - 1) {
8225     SetFlagsFromString(kForcedOptimizations);
8226   } else {
8227     SetFlagsFromString(kLazyOptimizations);
8228   }
8229 #else
8230   if (run == GetStressRuns() - 1) {
8231     SetFlagsFromString(kForcedOptimizations);
8232   } else if (run != GetStressRuns() - 2) {
8233     SetFlagsFromString(kLazyOptimizations);
8234   }
8235 #endif
8236 }
8237
8238
8239 // TODO(svenpanne) Deprecate this.
8240 void Testing::DeoptimizeAll() {
8241   i::Isolate* isolate = i::Isolate::Current();
8242   i::HandleScope scope(isolate);
8243   internal::Deoptimizer::DeoptimizeAll(isolate);
8244 }
8245
8246
8247 namespace internal {
8248
8249
8250 void HandleScopeImplementer::FreeThreadResources() {
8251   Free();
8252 }
8253
8254
8255 char* HandleScopeImplementer::ArchiveThread(char* storage) {
8256   HandleScopeData* current = isolate_->handle_scope_data();
8257   handle_scope_data_ = *current;
8258   MemCopy(storage, this, sizeof(*this));
8259
8260   ResetAfterArchive();
8261   current->Initialize();
8262
8263   return storage + ArchiveSpacePerThread();
8264 }
8265
8266
8267 int HandleScopeImplementer::ArchiveSpacePerThread() {
8268   return sizeof(HandleScopeImplementer);
8269 }
8270
8271
8272 char* HandleScopeImplementer::RestoreThread(char* storage) {
8273   MemCopy(this, storage, sizeof(*this));
8274   *isolate_->handle_scope_data() = handle_scope_data_;
8275   return storage + ArchiveSpacePerThread();
8276 }
8277
8278
8279 void HandleScopeImplementer::IterateThis(ObjectVisitor* v) {
8280 #ifdef DEBUG
8281   bool found_block_before_deferred = false;
8282 #endif
8283   // Iterate over all handles in the blocks except for the last.
8284   for (int i = blocks()->length() - 2; i >= 0; --i) {
8285     Object** block = blocks()->at(i);
8286     if (last_handle_before_deferred_block_ != NULL &&
8287         (last_handle_before_deferred_block_ <= &block[kHandleBlockSize]) &&
8288         (last_handle_before_deferred_block_ >= block)) {
8289       v->VisitPointers(block, last_handle_before_deferred_block_);
8290       DCHECK(!found_block_before_deferred);
8291 #ifdef DEBUG
8292       found_block_before_deferred = true;
8293 #endif
8294     } else {
8295       v->VisitPointers(block, &block[kHandleBlockSize]);
8296     }
8297   }
8298
8299   DCHECK(last_handle_before_deferred_block_ == NULL ||
8300          found_block_before_deferred);
8301
8302   // Iterate over live handles in the last block (if any).
8303   if (!blocks()->is_empty()) {
8304     v->VisitPointers(blocks()->last(), handle_scope_data_.next);
8305   }
8306
8307   List<Context*>* context_lists[2] = { &saved_contexts_, &entered_contexts_};
8308   for (unsigned i = 0; i < arraysize(context_lists); i++) {
8309     if (context_lists[i]->is_empty()) continue;
8310     Object** start = reinterpret_cast<Object**>(&context_lists[i]->first());
8311     v->VisitPointers(start, start + context_lists[i]->length());
8312   }
8313 }
8314
8315
8316 void HandleScopeImplementer::Iterate(ObjectVisitor* v) {
8317   HandleScopeData* current = isolate_->handle_scope_data();
8318   handle_scope_data_ = *current;
8319   IterateThis(v);
8320 }
8321
8322
8323 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
8324   HandleScopeImplementer* scope_implementer =
8325       reinterpret_cast<HandleScopeImplementer*>(storage);
8326   scope_implementer->IterateThis(v);
8327   return storage + ArchiveSpacePerThread();
8328 }
8329
8330
8331 DeferredHandles* HandleScopeImplementer::Detach(Object** prev_limit) {
8332   DeferredHandles* deferred =
8333       new DeferredHandles(isolate()->handle_scope_data()->next, isolate());
8334
8335   while (!blocks_.is_empty()) {
8336     Object** block_start = blocks_.last();
8337     Object** block_limit = &block_start[kHandleBlockSize];
8338     // We should not need to check for SealHandleScope here. Assert this.
8339     DCHECK(prev_limit == block_limit ||
8340            !(block_start <= prev_limit && prev_limit <= block_limit));
8341     if (prev_limit == block_limit) break;
8342     deferred->blocks_.Add(blocks_.last());
8343     blocks_.RemoveLast();
8344   }
8345
8346   // deferred->blocks_ now contains the blocks installed on the
8347   // HandleScope stack since BeginDeferredScope was called, but in
8348   // reverse order.
8349
8350   DCHECK(prev_limit == NULL || !blocks_.is_empty());
8351
8352   DCHECK(!blocks_.is_empty() && prev_limit != NULL);
8353   DCHECK(last_handle_before_deferred_block_ != NULL);
8354   last_handle_before_deferred_block_ = NULL;
8355   return deferred;
8356 }
8357
8358
8359 void HandleScopeImplementer::BeginDeferredScope() {
8360   DCHECK(last_handle_before_deferred_block_ == NULL);
8361   last_handle_before_deferred_block_ = isolate()->handle_scope_data()->next;
8362 }
8363
8364
8365 DeferredHandles::~DeferredHandles() {
8366   isolate_->UnlinkDeferredHandles(this);
8367
8368   for (int i = 0; i < blocks_.length(); i++) {
8369 #ifdef ENABLE_HANDLE_ZAPPING
8370     HandleScope::ZapRange(blocks_[i], &blocks_[i][kHandleBlockSize]);
8371 #endif
8372     isolate_->handle_scope_implementer()->ReturnBlock(blocks_[i]);
8373   }
8374 }
8375
8376
8377 void DeferredHandles::Iterate(ObjectVisitor* v) {
8378   DCHECK(!blocks_.is_empty());
8379
8380   DCHECK((first_block_limit_ >= blocks_.first()) &&
8381          (first_block_limit_ <= &(blocks_.first())[kHandleBlockSize]));
8382
8383   v->VisitPointers(blocks_.first(), first_block_limit_);
8384
8385   for (int i = 1; i < blocks_.length(); i++) {
8386     v->VisitPointers(blocks_[i], &blocks_[i][kHandleBlockSize]);
8387   }
8388 }
8389
8390
8391 void InvokeAccessorGetterCallback(
8392     v8::Local<v8::Name> property,
8393     const v8::PropertyCallbackInfo<v8::Value>& info,
8394     v8::AccessorNameGetterCallback getter) {
8395   // Leaving JavaScript.
8396   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
8397   Address getter_address = reinterpret_cast<Address>(reinterpret_cast<intptr_t>(
8398       getter));
8399   VMState<EXTERNAL> state(isolate);
8400   ExternalCallbackScope call_scope(isolate, getter_address);
8401   getter(property, info);
8402 }
8403
8404
8405 void InvokeFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info,
8406                             v8::FunctionCallback callback) {
8407   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
8408   Address callback_address =
8409       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
8410   VMState<EXTERNAL> state(isolate);
8411   ExternalCallbackScope call_scope(isolate, callback_address);
8412   callback(info);
8413 }
8414
8415
8416 }  // namespace internal
8417 }  // namespace v8