Merge GlobalObject with JSGlobalObject.

src/execution.cc

 // Copyright 2014 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.
 
 #include "src/execution.h"
 
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
 #include "src/deoptimizer.h"
 #include "src/isolate-inl.h"
@@ skipping 40 matching lines @@
 }
 
 
 namespace {
 
 MUST_USE_RESULT MaybeHandle<Object> Invoke(Isolate* isolate, bool is_construct,
                                            Handle<Object> target,
                                            Handle<Object> receiver, int argc,
                                            Handle<Object> args[],
                                            Handle<Object> new_target) {
-  DCHECK(!receiver->IsGlobalObject());
+  DCHECK(!receiver->IsJSGlobalObject());
 
   // Entering JavaScript.
   VMState<JS> state(isolate);
   CHECK(AllowJavascriptExecution::IsAllowed(isolate));
   if (!ThrowOnJavascriptExecution::IsAllowed(isolate)) {
     isolate->ThrowIllegalOperation();
     isolate->ReportPendingMessages();
     return MaybeHandle<Object>();
   }
 
@@ skipping 52 matching lines @@
 }  // namespace
 
 
 // static
 MaybeHandle<Object> Execution::Call(Isolate* isolate, Handle<Object> callable,
                                     Handle<Object> receiver, int argc,
                                     Handle<Object> argv[]) {
   // Convert calls on global objects to be calls on the global
   // receiver instead to avoid having a 'this' pointer which refers
   // directly to a global object.
-  if (receiver->IsGlobalObject()) {
+  if (receiver->IsJSGlobalObject()) {
     receiver =
-        handle(Handle<GlobalObject>::cast(receiver)->global_proxy(), isolate);
+        handle(Handle<JSGlobalObject>::cast(receiver)->global_proxy(), isolate);
   }
 
   // api callbacks can be called directly.
   if (callable->IsJSFunction() &&
       Handle<JSFunction>::cast(callable)->shared()->IsApiFunction()) {
     Handle<JSFunction> function = Handle<JSFunction>::cast(callable);
     SaveContext save(isolate);
     isolate->set_context(function->context());
     // Do proper receiver conversion for non-strict mode api functions.
     if (!receiver->IsJSReceiver() &&
         is_sloppy(function->shared()->language_mode())) {
       if (receiver->IsUndefined() || receiver->IsNull()) {
         receiver = handle(function->global_proxy(), isolate);
       } else {
         ASSIGN_RETURN_ON_EXCEPTION(
             isolate, receiver, Execution::ToObject(isolate, receiver), Object);
       }
     }
-    DCHECK(function->context()->global_object()->IsGlobalObject());
+    DCHECK(function->context()->global_object()->IsJSGlobalObject());
     auto value = Builtins::InvokeApiFunction(function, receiver, argc, argv);
     bool has_exception = value.is_null();
     DCHECK(has_exception == isolate->has_pending_exception());
     if (has_exception) {
       isolate->ReportPendingMessages();
       return MaybeHandle<Object>();
     } else {
       isolate->clear_pending_message();
     }
     return value;
@@ skipping 359 matching lines @@
 
   isolate_->counters()->stack_interrupts()->Increment();
   isolate_->counters()->runtime_profiler_ticks()->Increment();
   isolate_->runtime_profiler()->OptimizeNow();
 
   return isolate_->heap()->undefined_value();
 }
 
 }  // namespace internal
 }  // namespace v8