Count Promise constructor callings.

Source/bindings/v8/custom/V8PromiseCustom.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 26 matching lines @@
 #include "bindings/v8/ScopedPersistent.h"
 #include "bindings/v8/ScriptFunctionCall.h"
 #include "bindings/v8/ScriptState.h"
 #include "bindings/v8/V8Binding.h"
 #include "bindings/v8/V8PerIsolateData.h"
 #include "bindings/v8/V8ScriptRunner.h"
 #include "bindings/v8/WrapperTypeInfo.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/frame/DOMWindow.h"
+#include "core/frame/UseCounter.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "platform/Task.h"
 #include "wtf/Deque.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/PassOwnPtr.h"
 
 namespace WebCore {
 
@@ skipping 422 matching lines @@
         addToDerived(internal, derivedPromise, onFulfilled, onRejected, isolate);
     }
 }
 
 } // namespace
 
 void V8Promise::constructorCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8SetReturnValue(info, v8::Local<v8::Value>());
     v8::Isolate* isolate = info.GetIsolate();
+    ExecutionContext* executionContext = activeExecutionContext(isolate);
+    UseCounter::count(executionContext, UseCounter::PromiseConstructor);
     if (!info.Length() || !info[0]->IsFunction()) {
         throwTypeError("Promise constructor takes a function argument", isolate);
         return;
     }
     v8::Local<v8::Function> init = info[0].As<v8::Function>();
     v8::Local<v8::Object> promise = V8PromiseCustom::createPromise(info.Holder(), isolate);
     v8::Handle<v8::Value> argv[] = {
         createClosure(promiseResolveCallback, promise, isolate),
         createClosure(promiseRejectCallback, promise, isolate)
     };
@@ skipping 13 matching lines @@
     if (info.Length() > 0 && info[0]->IsFunction())
         onFulfilled = info[0].As<v8::Function>();
     if (info.Length() > 1 && info[1]->IsFunction())
         onRejected = info[1].As<v8::Function>();
     v8SetReturnValue(info, V8PromiseCustom::then(info.Holder(), onFulfilled, onRejected, isolate));
 }
 
 void V8Promise::castMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8::Isolate* isolate = info.GetIsolate();
+    ExecutionContext* executionContext = activeExecutionContext(isolate);
+    UseCounter::count(executionContext, UseCounter::PromiseCast);
     v8::Local<v8::Value> result = v8::Undefined(isolate);
     if (info.Length() > 0)
         result = info[0];
 
     v8SetReturnValue(info, V8PromiseCustom::toPromise(result, isolate));
 }
 
 void V8Promise::catchMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8::Isolate* isolate = info.GetIsolate();
     v8::Local<v8::Function> onFulfilled, onRejected;
 
     if (info.Length() > 0 && !info[0]->IsUndefined()) {
         if (!info[0]->IsFunction()) {
             v8SetReturnValue(info, throwTypeError("onRejected must be a function or undefined", isolate));
             return;
         }
         onRejected = info[0].As<v8::Function>();
     }
     v8SetReturnValue(info, V8PromiseCustom::then(info.Holder(), onFulfilled, onRejected, isolate));
 }
 
 void V8Promise::resolveMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8::Isolate* isolate = info.GetIsolate();
+    ExecutionContext* executionContext = activeExecutionContext(isolate);
+    UseCounter::count(executionContext, UseCounter::PromiseResolve);
     v8::Local<v8::Value> result = v8::Undefined(isolate);
     if (info.Length() > 0)
         result = info[0];
 
     v8::Local<v8::Object> promise = V8PromiseCustom::createPromise(info.Holder(), isolate);
     V8PromiseCustom::resolve(promise, result, isolate);
     v8SetReturnValue(info, promise);
 }
 
 void V8Promise::rejectMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8::Isolate* isolate = info.GetIsolate();
+    ExecutionContext* executionContext = activeExecutionContext(isolate);
+    UseCounter::count(executionContext, UseCounter::PromiseReject);
     v8::Local<v8::Value> result = v8::Undefined(isolate);
     if (info.Length() > 0)
         result = info[0];
 
     v8::Local<v8::Object> promise = V8PromiseCustom::createPromise(info.Holder(), isolate);
     V8PromiseCustom::reject(promise, result, isolate);
     v8SetReturnValue(info, promise);
 }
 
 void V8Promise::raceMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
@@ skipping 238 matching lines @@
 
 void V8PromiseCustom::callHandler(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> handler, v8::Handle<v8::Value> argument, PromiseState originatorState, v8::Isolate* isolate)
 {
     ASSERT(originatorState == Fulfilled || originatorState == Rejected);
     ExecutionContext* executionContext = currentExecutionContext(isolate);
     ASSERT(executionContext && executionContext->isContextThread());
     executionContext->postTask(adoptPtr(new CallHandlerTask(promise, handler, argument, originatorState, isolate, executionContext)));
 }
 
 } // namespace WebCore