[api] add API for Promise status and result.

src/builtins/builtins-promise.cc

 // Copyright 2016 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/builtins/builtins-promise.h"
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/promise-utils.h"
@@ skipping 212 matching lines @@
       var_on_reject.Bind(LoadContextElement(
           native_context, Context::PROMISE_ID_REJECT_HANDLER_INDEX));
       Goto(&append_callbacks);
     }
   }
 
   Bind(&append_callbacks);
   {
     Label fulfilled_check(this);
     Node* const status = LoadObjectField(promise, JSPromise::kStatusOffset);
-    GotoUnless(SmiEqual(status, SmiConstant(kPromisePending)),
+    GotoUnless(SmiEqual(status, SmiConstant(v8::Promise::kPending)),
                &fulfilled_check);
 
     Node* const existing_deferred =
         LoadObjectField(promise, JSPromise::kDeferredOffset);
 
     Label if_noexistingcallbacks(this), if_existingcallbacks(this);
     Branch(IsUndefined(existing_deferred), &if_noexistingcallbacks,
            &if_existingcallbacks);
 
     Bind(&if_noexistingcallbacks);
@@ skipping 53 matching lines @@
         AppendPromiseCallback(JSPromise::kRejectReactionsOffset, promise,
                               var_on_reject.value());
         Goto(&out);
       }
     }
 
     Bind(&fulfilled_check);
     {
       Label reject(this);
       Node* const result = LoadObjectField(promise, JSPromise::kResultOffset);
-      GotoUnless(WordEqual(status, SmiConstant(kPromiseFulfilled)), &reject);
+      GotoUnless(WordEqual(status, SmiConstant(v8::Promise::kFulfilled)),
+                 &reject);
 
       // TODO(gsathya): Move this to TF.
       CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, promise, result,
                   var_on_resolve.value(), deferred,
-                  SmiConstant(kPromiseFulfilled));
+                  SmiConstant(v8::Promise::kFulfilled));
       Goto(&out);
 
       Bind(&reject);
       {
         Node* const has_handler = PromiseHasHandler(promise);
         Label enqueue(this);
 
         // TODO(gsathya): Fold these runtime calls and move to TF.
         GotoIf(has_handler, &enqueue);
         CallRuntime(Runtime::kPromiseRevokeReject, context, promise);
         Goto(&enqueue);
 
         Bind(&enqueue);
         {
           CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, promise,
                       result, var_on_reject.value(), deferred,
-                      SmiConstant(kPromiseRejected));
+                      SmiConstant(v8::Promise::kRejected));
 
           Goto(&out);
         }
       }
     }
   }
 
   Bind(&out);
   PromiseSetHasHandler(promise);
 
@@ skipping 68 matching lines @@
   // rejected, shortcircuit the resolution procedure by directly
   // reusing the value from the promise.
   Bind(&if_nativepromise);
   {
     Node* const thenable_status =
         LoadObjectField(result, JSPromise::kStatusOffset);
     Node* const thenable_value =
         LoadObjectField(result, JSPromise::kResultOffset);
 
     Label if_isnotpending(this);
-    GotoUnless(SmiEqual(SmiConstant(kPromisePending), thenable_status),
+    GotoUnless(SmiEqual(SmiConstant(v8::Promise::kPending), thenable_status),
                &if_isnotpending);
 
     // TODO(gsathya): Use a marker here instead of the actual then
     // callback, and check for the marker in PromiseResolveThenableJob
     // and perform PromiseThen.
     Node* const native_context = LoadNativeContext(context);
     Node* const then =
         LoadContextElement(native_context, Context::PROMISE_THEN_INDEX);
     var_then.Bind(then);
     Goto(&do_enqueue);
 
     Bind(&if_isnotpending);
     {
       Label if_fulfilled(this), if_rejected(this);
-      Branch(SmiEqual(SmiConstant(kPromiseFulfilled), thenable_status),
+      Branch(SmiEqual(SmiConstant(v8::Promise::kFulfilled), thenable_status),
              &if_fulfilled, &if_rejected);
 
       Bind(&if_fulfilled);
       {
         CallRuntime(Runtime::kPromiseFulfill, context, promise,
-                    SmiConstant(kPromiseFulfilled), thenable_value);
+                    SmiConstant(v8::Promise::kFulfilled), thenable_value);
         PromiseSetHasHandler(promise);
         Goto(out);
       }
 
       Bind(&if_rejected);
       {
         Label reject(this);
         Node* const has_handler = PromiseHasHandler(result);
 
         // Promise has already been rejected, but had no handler.
@@ skipping 50 matching lines @@
     Bind(&enqueue);
     CallRuntime(Runtime::kEnqueuePromiseResolveThenableJob, context, promise,
                 result, var_then.value());
     Goto(out);
   }
 
   // 7.b Return FulfillPromise(promise, resolution).
   Bind(&fulfill);
   {
     CallRuntime(Runtime::kPromiseFulfill, context, promise,
-                SmiConstant(kPromiseFulfilled), result);
+                SmiConstant(v8::Promise::kFulfilled), result);
     Goto(out);
   }
 
   Bind(&if_cycle);
   {
     // 6.a Let selfResolutionError be a newly created TypeError object.
     Node* const message_id = SmiConstant(MessageTemplate::kPromiseCyclic);
     Node* const error =
         CallRuntime(Runtime::kNewTypeError, context, message_id, result);
     var_reason.Bind(error);
@@ skipping 464 matching lines @@
     CallRuntime(Runtime::kDebugPopPromise, context);
     Goto(&out);
 
     Bind(&out);
     Return(UndefinedConstant());
   }
 }
 
 }  // namespace internal
 }  // namespace v8