Make some crucial Isolate functions inlineable

src/isolate-inl.h

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_ISOLATE_INL_H_
 #define V8_ISOLATE_INL_H_
 
 #include "src/isolate.h"
 #include "src/objects-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 void Isolate::set_context(Context* context) {
   DCHECK(context == NULL || context->IsContext());
   thread_local_top_.context_ = context;
 }
 
+Handle<Context> Isolate::native_context() {
+  return handle(context()->native_context(), this);
+}
+
+Context* Isolate::raw_native_context() { return context()->native_context(); }
 
 Object* Isolate::pending_exception() {
   DCHECK(has_pending_exception());
   DCHECK(!thread_local_top_.pending_exception_->IsException(this));
   return thread_local_top_.pending_exception_;
 }
 
 
 void Isolate::set_pending_exception(Object* exception_obj) {
   DCHECK(!exception_obj->IsException(this));
@@ skipping 34 matching lines @@
 void Isolate::clear_scheduled_exception() {
   DCHECK(!thread_local_top_.scheduled_exception_->IsException(this));
   thread_local_top_.scheduled_exception_ = heap_.the_hole_value();
 }
 
 
 bool Isolate::is_catchable_by_javascript(Object* exception) {
   return exception != heap()->termination_exception();
 }
 
+void Isolate::FireBeforeCallEnteredCallback() {
+  for (int i = 0; i < before_call_entered_callbacks_.length(); i++) {
+    before_call_entered_callbacks_.at(i)(reinterpret_cast<v8::Isolate*>(this));
+  }
+}
 
 Handle<JSGlobalObject> Isolate::global_object() {
   return handle(context()->global_object(), this);
 }
 
 Handle<JSObject> Isolate::global_proxy() {
   return handle(context()->global_proxy(), this);
 }
 
 
 Isolate::ExceptionScope::ExceptionScope(Isolate* isolate)
     : isolate_(isolate),
       pending_exception_(isolate_->pending_exception(), isolate_) {}
 
 
 Isolate::ExceptionScope::~ExceptionScope() {
   isolate_->set_pending_exception(*pending_exception_);
 }
 
-
-#define NATIVE_CONTEXT_FIELD_ACCESSOR(index, type, name) \
-  Handle<type> Isolate::name() {                         \
-    return Handle<type>(native_context()->name(), this); \
-  }                                                      \
-  bool Isolate::is_##name(type* value) {                 \
-    return native_context()->is_##name(value);           \
+#define NATIVE_CONTEXT_FIELD_ACCESSOR(index, type, name)     \
+  Handle<type> Isolate::name() {                             \
+    return Handle<type>(raw_native_context()->name(), this); \
+  }                                                          \
+  bool Isolate::is_##name(type* value) {                     \
+    return raw_native_context()->is_##name(value);           \
   }
 NATIVE_CONTEXT_FIELDS(NATIVE_CONTEXT_FIELD_ACCESSOR)
 #undef NATIVE_CONTEXT_FIELD_ACCESSOR
 
 bool Isolate::IsArraySpeciesLookupChainIntact() {
   // Note: It would be nice to have debug checks to make sure that the
   // species protector is accurate, but this would be hard to do for most of
   // what the protector stands for:
   // - You'd need to traverse the heap to check that no Array instance has
   //   a constructor property
@@ skipping 11 matching lines @@
 
 bool Isolate::IsHasInstanceLookupChainIntact() {
   PropertyCell* has_instance_cell = heap()->has_instance_protector();
   return has_instance_cell->value() == Smi::FromInt(kArrayProtectorValid);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_ISOLATE_INL_H_