Revert of Create JSPromise

src/runtime/runtime-debug.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/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/debug/debug-evaluate.h"
 #include "src/debug/debug-frames.h"
 #include "src/debug/debug-scopes.h"
@@ skipping 118 matching lines @@
       }
 
       case LookupIterator::DATA:
         return it->GetDataValue();
     }
   }
 
   return it->isolate()->factory()->undefined_value();
 }
 
+
+static Handle<Object> DebugGetProperty(Handle<Object> object,
+                                       Handle<Name> name) {
+  LookupIterator it(object, name);
+  return DebugGetProperty(&it);
+}
+
+
 template <class IteratorType>
 static MaybeHandle<JSArray> GetIteratorInternalProperties(
     Isolate* isolate, Handle<IteratorType> object) {
   Factory* factory = isolate->factory();
   Handle<IteratorType> iterator = Handle<IteratorType>::cast(object);
   CHECK(iterator->kind()->IsSmi());
   const char* kind = NULL;
   switch (Smi::cast(iterator->kind())->value()) {
     case IteratorType::kKindKeys:
       kind = "keys";
@@ skipping 84 matching lines @@
         factory->NewStringFromAsciiChecked("[[GeneratorFunction]]");
     result->set(2, *function);
     result->set(3, generator->function());
 
     Handle<String> receiver =
         factory->NewStringFromAsciiChecked("[[GeneratorReceiver]]");
     result->set(4, *receiver);
     result->set(5, generator->receiver());
     return factory->NewJSArrayWithElements(result);
   } else if (object->IsJSPromise()) {
-    Handle<JSPromise> promise = Handle<JSPromise>::cast(object);
-    const char* status = JSPromise::Status(promise->status());
+    Handle<JSObject> promise = Handle<JSObject>::cast(object);
+
+    Handle<Object> status_obj =
+        DebugGetProperty(promise, isolate->factory()->promise_state_symbol());
+    CHECK(status_obj->IsSmi());
+    const char* status = "rejected";
+    int status_val = Handle<Smi>::cast(status_obj)->value();
+    switch (status_val) {
+      case kPromiseFulfilled:
+        status = "resolved";
+        break;
+      case kPromisePending:
+        status = "pending";
+        break;
+      default:
+        DCHECK_EQ(kPromiseRejected, status_val);
+    }
+
     Handle<FixedArray> result = factory->NewFixedArray(2 * 2);
     Handle<String> promise_status =
         factory->NewStringFromAsciiChecked("[[PromiseStatus]]");
     result->set(0, *promise_status);
     Handle<String> status_str = factory->NewStringFromAsciiChecked(status);
     result->set(1, *status_str);
 
-    Handle<Object> value_obj(promise->result(), isolate);
+    Handle<Object> value_obj =
+        DebugGetProperty(promise, isolate->factory()->promise_result_symbol());
     Handle<String> promise_value =
         factory->NewStringFromAsciiChecked("[[PromiseValue]]");
     result->set(2, *promise_value);
     result->set(3, *value_obj);
     return factory->NewJSArrayWithElements(result);
   } else if (object->IsJSProxy()) {
     Handle<JSProxy> js_proxy = Handle<JSProxy>::cast(object);
     Handle<FixedArray> result = factory->NewFixedArray(3 * 2);
 
     Handle<String> handler_str =
@@ skipping 1660 matching lines @@
 }
 
 
 RUNTIME_FUNCTION(Runtime_DebugBreakInOptimizedCode) {
   UNIMPLEMENTED();
   return NULL;
 }
 
 }  // namespace internal
 }  // namespace v8