Replace v8::Handle<> with v8::Local<> in bindings/core/v8/*

Source/bindings/core/v8/V8Initializer.cpp

 /*
  * Copyright (C) 2009 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 53 matching lines @@
 #include "wtf/text/WTFString.h"
 #include <v8-debug.h>
 
 namespace blink {
 
 static Frame* findFrame(v8::Isolate* isolate, v8::Local<v8::Object> host, v8::Local<v8::Value> data)
 {
     const WrapperTypeInfo* type = WrapperTypeInfo::unwrap(data);
 
     if (V8Window::wrapperTypeInfo.equals(type)) {
-        v8::Handle<v8::Object> windowWrapper = V8Window::findInstanceInPrototypeChain(host, isolate);
+        v8::Local<v8::Object> windowWrapper = V8Window::findInstanceInPrototypeChain(host, isolate);
         if (windowWrapper.IsEmpty())
             return 0;
         return V8Window::toImpl(windowWrapper)->frame();
     }
 
     if (V8History::wrapperTypeInfo.equals(type))
         return V8History::toImpl(host)->frame();
 
     if (V8Location::wrapperTypeInfo.equals(type))
         return V8Location::toImpl(host)->frame();
 
     // This function can handle only those types listed above.
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 static void reportFatalErrorInMainThread(const char* location, const char* message)
 {
     int memoryUsageMB = blink::Platform::current()->actualMemoryUsageMB();
     printf("V8 error: %s (%s).  Current memory usage: %d MB\n", message, location, memoryUsageMB);
     CRASH();
 }
 
-static PassRefPtrWillBeRawPtr<ScriptCallStack> extractCallStack(v8::Isolate* isolate, v8::Handle<v8::Message> message, int* const scriptId)
+static PassRefPtrWillBeRawPtr<ScriptCallStack> extractCallStack(v8::Isolate* isolate, v8::Local<v8::Message> message, int* const scriptId)
 {
-    v8::Handle<v8::StackTrace> stackTrace = message->GetStackTrace();
+    v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();
     RefPtrWillBeRawPtr<ScriptCallStack> callStack = nullptr;
     *scriptId = message->GetScriptOrigin().ScriptID()->Value();
     // Currently stack trace is only collected when inspector is open.
     if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0) {
         callStack = createScriptCallStack(isolate, stackTrace, ScriptCallStack::maxCallStackSizeToCapture);
         bool success = false;
         int topScriptId = callStack->at(0).scriptId().toInt(&success);
         if (success && topScriptId == *scriptId)
             *scriptId = 0;
     } else {
         Vector<ScriptCallFrame> callFrames;
         callStack = ScriptCallStack::create(callFrames);
     }
     return callStack.release();
 }
 
-static String extractResourceName(v8::Handle<v8::Message> message, const Document* document)
+static String extractResourceName(v8::Local<v8::Message> message, const Document* document)
 {
-    v8::Handle<v8::Value> resourceName = message->GetScriptOrigin().ResourceName();
+    v8::Local<v8::Value> resourceName = message->GetScriptOrigin().ResourceName();
     bool shouldUseDocumentURL = document && (resourceName.IsEmpty() || !resourceName->IsString());
     return shouldUseDocumentURL ? document->url() : toCoreString(resourceName.As<v8::String>());
 }
 
-static String extractMessageForConsole(v8::Isolate* isolate, v8::Handle<v8::Value> data)
+static String extractMessageForConsole(v8::Isolate* isolate, v8::Local<v8::Value> data)
 {
     if (V8DOMWrapper::isWrapper(isolate, data)) {
-        v8::Handle<v8::Object> obj = v8::Handle<v8::Object>::Cast(data);
+        v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(data);
         const WrapperTypeInfo* type = toWrapperTypeInfo(obj);
         if (V8DOMException::wrapperTypeInfo.isSubclass(type)) {
             DOMException* exception = V8DOMException::toImpl(obj);
             if (exception && !exception->messageForConsole().isEmpty())
                 return exception->toStringForConsole();
         }
     }
     return emptyString();
 }
 
-static void messageHandlerInMainThread(v8::Handle<v8::Message> message, v8::Handle<v8::Value> data)
+static void messageHandlerInMainThread(v8::Local<v8::Message> message, v8::Local<v8::Value> data)
 {
     ASSERT(isMainThread());
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     // If called during context initialization, there will be no entered window.
     LocalDOMWindow* enteredWindow = enteredDOMWindow(isolate);
     if (!enteredWindow || !enteredWindow->isCurrentlyDisplayedInFrame())
         return;
 
     int scriptId = 0;
     RefPtrWillBeRawPtr<ScriptCallStack> callStack = extractCallStack(isolate, message, &scriptId);
@@ skipping 54 matching lines @@
 static void promiseRejectHandlerInMainThread(v8::PromiseRejectMessage data)
 {
     ASSERT(isMainThread());
     if (data.GetEvent() == v8::kPromiseHandlerAddedAfterReject) {
         rejectedPromisesOnMainThread().handlerAdded(data);
         return;
     }
 
     ASSERT(data.GetEvent() == v8::kPromiseRejectWithNoHandler);
 
-    v8::Handle<v8::Promise> promise = data.GetPromise();
+    v8::Local<v8::Promise> promise = data.GetPromise();
 
     v8::Isolate* isolate = promise->GetIsolate();
     // There is no entered window during microtask callbacks from V8,
     // thus we call toDOMWindow() instead of enteredDOMWindow().
     LocalDOMWindow* window = currentDOMWindow(isolate);
     if (!window || !window->isCurrentlyDisplayedInFrame())
         return;
 
-    v8::Handle<v8::Value> exception = data.GetValue();
+    v8::Local<v8::Value> exception = data.GetValue();
     if (V8DOMWrapper::isWrapper(isolate, exception)) {
         // Try to get the stack & location from a wrapped exception object (e.g. DOMException).
         ASSERT(exception->IsObject());
-        v8::Handle<v8::Object> obj = v8::Handle<v8::Object>::Cast(exception);
-        v8::Handle<v8::Value> error = V8HiddenValue::getHiddenValue(isolate, obj, V8HiddenValue::error(isolate));
+        v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(exception);
+        v8::Local<v8::Value> error = V8HiddenValue::getHiddenValue(isolate, obj, V8HiddenValue::error(isolate));
         if (!error.IsEmpty())
             exception = error;
     }
 
     int scriptId = 0;
     int lineNumber = 0;
     int columnNumber = 0;
     String resourceName;
     String errorMessage;
     RefPtrWillBeRawPtr<ScriptCallStack> callStack = nullptr;
 
-    v8::Handle<v8::Message> message = v8::Exception::CreateMessage(exception);
+    v8::Local<v8::Message> message = v8::Exception::CreateMessage(exception);
     if (!message.IsEmpty()) {
         if (v8Call(message->GetLineNumber(isolate->GetCurrentContext()), lineNumber)
             && v8Call(message->GetStartColumn(isolate->GetCurrentContext()), columnNumber))
             ++columnNumber;
         resourceName = extractResourceName(message, window->document());
         errorMessage = toCoreStringWithNullCheck(message->Get());
         callStack = extractCallStack(isolate, message, &scriptId);
     } else if (!exception.IsEmpty() && exception->IsInt32()) {
         // For Smi's the message would be empty.
         errorMessage = "Uncaught " + String::number(exception.As<v8::Integer>()->Value());
     }
 
     String messageForConsole = extractMessageForConsole(isolate, data.GetValue());
     if (!messageForConsole.isEmpty())
         errorMessage = "Uncaught " + messageForConsole;
 
     ScriptState* scriptState = ScriptState::current(isolate);
     rejectedPromisesOnMainThread().rejectedWithNoHandler(scriptState, data, errorMessage, resourceName, scriptId, lineNumber, columnNumber, callStack);
 }
 
 static void promiseRejectHandlerInWorker(v8::PromiseRejectMessage data)
 {
-    v8::Handle<v8::Promise> promise = data.GetPromise();
+    v8::Local<v8::Promise> promise = data.GetPromise();
 
     // Bail out if called during context initialization.
     v8::Isolate* isolate = promise->GetIsolate();
     ScriptState* scriptState = ScriptState::current(isolate);
     if (!scriptState->contextIsValid())
         return;
 
     ExecutionContext* executionContext = scriptState->executionContext();
     if (!executionContext)
         return;
 
     ASSERT(executionContext->isWorkerGlobalScope());
     WorkerScriptController* scriptController = toWorkerGlobalScope(executionContext)->script();
     ASSERT(scriptController);
 
     if (data.GetEvent() == v8::kPromiseHandlerAddedAfterReject) {
         scriptController->rejectedPromises()->handlerAdded(data);
         return;
     }
 
     ASSERT(data.GetEvent() == v8::kPromiseRejectWithNoHandler);
 
     int scriptId = 0;
     int lineNumber = 0;
     int columnNumber = 0;
     String resourceName;
     String errorMessage;
 
-    v8::Handle<v8::Message> message = v8::Exception::CreateMessage(data.GetValue());
+    v8::Local<v8::Message> message = v8::Exception::CreateMessage(data.GetValue());
     if (!message.IsEmpty()) {
         TOSTRING_VOID(V8StringResource<>, resourceName, message->GetScriptOrigin().ResourceName());
         scriptId = message->GetScriptOrigin().ScriptID()->Value();
         if (v8Call(message->GetLineNumber(scriptState->context()), lineNumber)
             && v8Call(message->GetStartColumn(scriptState->context()), columnNumber))
             ++columnNumber;
         // message->Get() can be empty here. https://crbug.com/450330
         errorMessage = toCoreStringWithNullCheck(message->Get());
     }
     scriptController->rejectedPromises()->rejectedWithNoHandler(scriptState, data, errorMessage, resourceName, scriptId, lineNumber, columnNumber, nullptr);
@@ skipping 112 matching lines @@
 
     ScriptProfiler::initialize();
 }
 
 static void reportFatalErrorInWorker(const char* location, const char* message)
 {
     // FIXME: We temporarily deal with V8 internal error situations such as out-of-memory by crashing the worker.
     CRASH();
 }
 
-static void messageHandlerInWorker(v8::Handle<v8::Message> message, v8::Handle<v8::Value> data)
+static void messageHandlerInWorker(v8::Local<v8::Message> message, v8::Local<v8::Value> data)
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     V8PerIsolateData* perIsolateData = V8PerIsolateData::from(isolate);
     // Exceptions that occur in error handler should be ignored since in that case
     // WorkerGlobalScope::reportException will send the exception to the worker object.
     if (perIsolateData->isReportingException())
         return;
     perIsolateData->setReportingException(true);
 
     ScriptState* scriptState = ScriptState::current(isolate);
@@ skipping 35 matching lines @@
 
     v8::V8::AddMessageListener(messageHandlerInWorker);
     v8::V8::SetFatalErrorHandler(reportFatalErrorInWorker);
 
     uint32_t here;
     isolate->SetStackLimit(reinterpret_cast<uintptr_t>(&here - kWorkerMaxStackSize / sizeof(uint32_t*)));
     isolate->SetPromiseRejectCallback(promiseRejectHandlerInWorker);
 }
 
 } // namespace blink