bindings: Use Maybe APIs in V8ScriptRunner (part 1)

Source/bindings/core/v8/PrivateScriptRunner.cpp

 // Copyright 2014 The Chromium 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 "config.h"
 #include "bindings/core/v8/PrivateScriptRunner.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/V8Binding.h"
@@ skipping 41 matching lines @@
     v8::Handle<v8::Object> global = isolate->GetCurrentContext()->Global();
     v8::Handle<v8::Value> privateScriptController = global->Get(v8String(isolate, "privateScriptController"));
     RELEASE_ASSERT(privateScriptController->IsUndefined() || privateScriptController->IsObject());
     if (privateScriptController->IsObject()) {
         v8::Handle<v8::Object> privateScriptControllerObject = privateScriptController->ToObject(isolate);
         v8::Handle<v8::Value> importFunctionValue = privateScriptControllerObject->Get(v8String(isolate, "import"));
         if (importFunctionValue->IsUndefined())
             privateScriptControllerObject->Set(v8String(isolate, "import"), v8::FunctionTemplate::New(isolate, importFunction)->GetFunction());
     }
 
-    v8::Handle<v8::Script> script = V8ScriptRunner::compileScript(v8String(isolate, sourceString), fileName, String(), TextPosition::minimumPosition(), isolate, nullptr, nullptr, nullptr, NotSharableCrossOrigin);
-    if (block.HasCaught()) {
+    v8::Local<v8::Script> script;
+    if (!V8ScriptRunner::compileScript(v8String(isolate, sourceString), fileName, String(), TextPosition::minimumPosition(), isolate, nullptr, nullptr, nullptr, NotSharableCrossOrigin).ToLocal(&script)) {
         fprintf(stderr, "Private script error: Compile failed. (Class name = %s)\n", scriptClassName.utf8().data());
-        dumpV8Message(block.Message());
+        if (block.HasCaught())

[haraken, 2015/03/13 04:31:16]

Just to confirm: When a worker termination is signaled and the compileScript
returns false, V8 does not throw any exception, right? Is it an expected
behavior?

I'm asking this because except for the worker termination, it is guaranteed that
the compileScript returns false if and only if V8 throws an exception. In other
words, except for the worker termination, block.HasCaught() is guaranteed to be
true here.

[bashi, 2015/03/13 05:15:20]

I'm not fully confident, but I think you are right. Changed to use ASSERT().

+            dumpV8Message(block.Message());
         RELEASE_ASSERT_NOT_REACHED();
     }
 
-    v8::Handle<v8::Value> result = V8ScriptRunner::runCompiledInternalScript(isolate, script);
-    if (block.HasCaught()) {
-        fprintf(stderr, "Private script error: installClass() failed. (Class name = %s)\n", scriptClassName.utf8().data());
-        dumpV8Message(block.Message());
+    v8::Local<v8::Value> result;
+    if (!V8ScriptRunner::runCompiledInternalScript(isolate, script).ToLocal(&result)) {
+        if (block.HasCaught()) {
+            fprintf(stderr, "Private script error: installClass() failed. (Class name = %s)\n", scriptClassName.utf8().data());
+            dumpV8Message(block.Message());
+        }
         RELEASE_ASSERT_NOT_REACHED();
     }
     return result;
 }
 
 // Private scripts can use privateScriptController.import(bundledResource, compileAndRunScript) to import dependent resources.
 // |bundledResource| is a string resource name.
 // |compileAndRunScript| optional boolean representing if the javascript should be executed. Default: true.
 void importFunction(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
@@ skipping 245 matching lines @@
     v8::Handle<v8::Value> result = V8ScriptRunner::callFunction(v8::Handle<v8::Function>::Cast(method), scriptState->executionContext(), holder, argc, argv, scriptState->isolate());
     if (block.HasCaught()) {
         rethrowExceptionInPrivateScript(scriptState->isolate(), block, scriptStateInUserScript, ExceptionState::ExecutionContext, methodName, className);
         block.ReThrow();
         return v8::Handle<v8::Value>();
     }
     return result;
 }
 
 } // namespace blink