714 lines
24 KiB
C++
714 lines
24 KiB
C++
// Copyright (c) 2009 The Chromium Embedded Framework 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 "include/cef.h"
|
|
#include "include/cef_runnable.h"
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
#include "test_handler.h"
|
|
|
|
namespace {
|
|
|
|
bool g_V8TestV8HandlerExecuteCalled;
|
|
bool g_V8TestV8HandlerExecute2Called;
|
|
|
|
class V8TestV8Handler : public CefThreadSafeBase<CefV8Handler>
|
|
{
|
|
public:
|
|
V8TestV8Handler(bool bindingTest) { binding_test_ = bindingTest; }
|
|
|
|
virtual bool Execute(const CefString& name,
|
|
CefRefPtr<CefV8Value> object,
|
|
const CefV8ValueList& arguments,
|
|
CefRefPtr<CefV8Value>& retval,
|
|
CefString& exception)
|
|
{
|
|
TestExecute(name, object, arguments, retval, exception);
|
|
return true;
|
|
}
|
|
|
|
void TestExecute(const CefString& name,
|
|
CefRefPtr<CefV8Value> object,
|
|
const CefV8ValueList& arguments,
|
|
CefRefPtr<CefV8Value>& retval,
|
|
CefString& exception)
|
|
{
|
|
if(name == "execute") {
|
|
g_V8TestV8HandlerExecuteCalled = true;
|
|
|
|
ASSERT_EQ((size_t)8, arguments.size());
|
|
int argct = 0;
|
|
|
|
// basic types
|
|
ASSERT_TRUE(arguments[argct]->IsInt());
|
|
ASSERT_EQ(5, arguments[argct]->GetIntValue());
|
|
argct++;
|
|
|
|
ASSERT_TRUE(arguments[argct]->IsDouble());
|
|
ASSERT_EQ(6.543, arguments[argct]->GetDoubleValue());
|
|
argct++;
|
|
|
|
ASSERT_TRUE(arguments[argct]->IsBool());
|
|
ASSERT_EQ(true, arguments[argct]->GetBoolValue());
|
|
argct++;
|
|
|
|
ASSERT_TRUE(arguments[argct]->IsString());
|
|
ASSERT_EQ(arguments[argct]->GetStringValue(), "test string");
|
|
argct++;
|
|
|
|
CefRefPtr<CefV8Value> value;
|
|
|
|
// array
|
|
ASSERT_TRUE(arguments[argct]->IsArray());
|
|
ASSERT_EQ(4, arguments[argct]->GetArrayLength());
|
|
{
|
|
int subargct = 0;
|
|
value = arguments[argct]->GetValue(subargct);
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsInt());
|
|
ASSERT_EQ(7, value->GetIntValue());
|
|
subargct++;
|
|
|
|
value = arguments[argct]->GetValue(subargct);
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsDouble());
|
|
ASSERT_EQ(5.432, value->GetDoubleValue());
|
|
subargct++;
|
|
|
|
value = arguments[argct]->GetValue(subargct);
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsBool());
|
|
ASSERT_EQ(false, value->GetBoolValue());
|
|
subargct++;
|
|
|
|
value = arguments[argct]->GetValue(subargct);
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsString());
|
|
ASSERT_EQ(value->GetStringValue(), "another string");
|
|
subargct++;
|
|
}
|
|
argct++;
|
|
|
|
// object
|
|
ASSERT_TRUE(arguments[argct]->IsObject());
|
|
{
|
|
value = arguments[argct]->GetValue("arg0");
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsInt());
|
|
ASSERT_EQ(2, value->GetIntValue());
|
|
|
|
value = arguments[argct]->GetValue("arg1");
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsDouble());
|
|
ASSERT_EQ(3.433, value->GetDoubleValue());
|
|
|
|
value = arguments[argct]->GetValue("arg2");
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsBool());
|
|
ASSERT_EQ(true, value->GetBoolValue());
|
|
|
|
value = arguments[argct]->GetValue("arg3");
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsString());
|
|
ASSERT_EQ(value->GetStringValue(), "some string");
|
|
}
|
|
argct++;
|
|
|
|
// function that returns a value
|
|
ASSERT_TRUE(arguments[argct]->IsFunction());
|
|
{
|
|
CefV8ValueList args;
|
|
args.push_back(CefV8Value::CreateInt(5));
|
|
args.push_back(CefV8Value::CreateDouble(3.5));
|
|
args.push_back(CefV8Value::CreateBool(true));
|
|
args.push_back(CefV8Value::CreateString("10"));
|
|
CefRefPtr<CefV8Value> rv;
|
|
CefString exception;
|
|
ASSERT_TRUE(arguments[argct]->ExecuteFunction(
|
|
arguments[argct], args, rv, exception));
|
|
ASSERT_TRUE(rv.get() != NULL);
|
|
ASSERT_TRUE(rv->IsDouble());
|
|
ASSERT_EQ(19.5, rv->GetDoubleValue());
|
|
}
|
|
argct++;
|
|
|
|
// function that throws an exception
|
|
ASSERT_TRUE(arguments[argct]->IsFunction());
|
|
{
|
|
CefV8ValueList args;
|
|
args.push_back(CefV8Value::CreateDouble(5));
|
|
args.push_back(CefV8Value::CreateDouble(0));
|
|
CefRefPtr<CefV8Value> rv;
|
|
CefString exception;
|
|
ASSERT_TRUE(arguments[argct]->ExecuteFunction(
|
|
arguments[argct], args, rv, exception));
|
|
ASSERT_EQ(exception, "Uncaught My Exception");
|
|
}
|
|
argct++;
|
|
|
|
if(binding_test_)
|
|
{
|
|
// values
|
|
value = object->GetValue("intVal");
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsInt());
|
|
ASSERT_EQ(12, value->GetIntValue());
|
|
|
|
value = object->GetValue("doubleVal");
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsDouble());
|
|
ASSERT_EQ(5.432, value->GetDoubleValue());
|
|
|
|
value = object->GetValue("boolVal");
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsBool());
|
|
ASSERT_EQ(true, value->GetBoolValue());
|
|
|
|
value = object->GetValue("stringVal");
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsString());
|
|
ASSERT_EQ(value->GetStringValue(), "the string");
|
|
|
|
value = object->GetValue("arrayVal");
|
|
ASSERT_TRUE(value.get() != NULL);
|
|
ASSERT_TRUE(value->IsArray());
|
|
{
|
|
CefRefPtr<CefV8Value> value2;
|
|
int subargct = 0;
|
|
value2 = value->GetValue(subargct);
|
|
ASSERT_TRUE(value2.get() != NULL);
|
|
ASSERT_TRUE(value2->IsInt());
|
|
ASSERT_EQ(4, value2->GetIntValue());
|
|
subargct++;
|
|
|
|
value2 = value->GetValue(subargct);
|
|
ASSERT_TRUE(value2.get() != NULL);
|
|
ASSERT_TRUE(value2->IsDouble());
|
|
ASSERT_EQ(120.43, value2->GetDoubleValue());
|
|
subargct++;
|
|
|
|
value2 = value->GetValue(subargct);
|
|
ASSERT_TRUE(value2.get() != NULL);
|
|
ASSERT_TRUE(value2->IsBool());
|
|
ASSERT_EQ(true, value2->GetBoolValue());
|
|
subargct++;
|
|
|
|
value2 = value->GetValue(subargct);
|
|
ASSERT_TRUE(value2.get() != NULL);
|
|
ASSERT_TRUE(value2->IsString());
|
|
ASSERT_EQ(value2->GetStringValue(), "a string");
|
|
subargct++;
|
|
}
|
|
}
|
|
|
|
retval = CefV8Value::CreateInt(5);
|
|
} else if(name == "execute2") {
|
|
g_V8TestV8HandlerExecute2Called = true;
|
|
|
|
// check the result of calling the "execute" function
|
|
ASSERT_EQ((size_t)1, arguments.size());
|
|
ASSERT_TRUE(arguments[0]->IsInt());
|
|
ASSERT_EQ(5, arguments[0]->GetIntValue());
|
|
}
|
|
}
|
|
|
|
bool binding_test_;
|
|
};
|
|
|
|
class V8TestHandler : public TestHandler
|
|
{
|
|
public:
|
|
V8TestHandler(bool bindingTest) { binding_test_ = bindingTest; }
|
|
|
|
virtual void RunTest()
|
|
{
|
|
std::string object;
|
|
if(binding_test_) {
|
|
// binding uses the window object
|
|
object = "window.test";
|
|
} else {
|
|
// extension uses a global object
|
|
object = "test";
|
|
}
|
|
|
|
std::stringstream testHtml;
|
|
testHtml <<
|
|
"<html><body>"
|
|
"<script language=\"JavaScript\">"
|
|
"function func(a,b,c,d) { return a+b+(c?1:0)+parseFloat(d); }"
|
|
"function func2(a,b) { throw('My Exception'); }"
|
|
<< object << ".execute2("
|
|
" " << object << ".execute(5, 6.543, true, \"test string\","
|
|
" [7, 5.432, false, \"another string\"],"
|
|
" {arg0:2, arg1:3.433, arg2:true, arg3:\"some string\"}, func, func2)"
|
|
");"
|
|
"</script>"
|
|
"</body></html>";
|
|
|
|
AddResource("http://tests/run.html", testHtml.str(), "text/html");
|
|
CreateBrowser("http://tests/run.html");
|
|
}
|
|
|
|
virtual RetVal HandleLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
bool isMainContent,
|
|
int httpStatusCode)
|
|
{
|
|
if(!browser->IsPopup() && !frame.get())
|
|
DestroyTest();
|
|
return RV_CONTINUE;
|
|
}
|
|
|
|
virtual RetVal HandleJSBinding(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefV8Value> object)
|
|
{
|
|
if(binding_test_) {
|
|
TestHandleJSBinding(browser, frame, object);
|
|
return RV_HANDLED;
|
|
}
|
|
return RV_CONTINUE;
|
|
}
|
|
|
|
void TestHandleJSBinding(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefV8Value> object)
|
|
{
|
|
// Create the new V8 object
|
|
CefRefPtr<CefV8Value> testObj = CefV8Value::CreateObject(NULL);
|
|
ASSERT_TRUE(testObj.get() != NULL);
|
|
ASSERT_TRUE(object->SetValue("test", testObj));
|
|
|
|
// Create an instance of V8ExecuteV8Handler
|
|
CefRefPtr<CefV8Handler> testHandler(new V8TestV8Handler(true));
|
|
ASSERT_TRUE(testHandler.get() != NULL);
|
|
|
|
// Add the functions
|
|
CefRefPtr<CefV8Value> testFunc;
|
|
testFunc = CefV8Value::CreateFunction("execute", testHandler);
|
|
ASSERT_TRUE(testFunc.get() != NULL);
|
|
ASSERT_TRUE(testObj->SetValue("execute", testFunc));
|
|
testFunc = CefV8Value::CreateFunction("execute2", testHandler);
|
|
ASSERT_TRUE(testFunc.get() != NULL);
|
|
ASSERT_TRUE(testObj->SetValue("execute2", testFunc));
|
|
|
|
// Add the values
|
|
ASSERT_TRUE(testObj->SetValue("intVal",
|
|
CefV8Value::CreateInt(12)));
|
|
ASSERT_TRUE(testObj->SetValue("doubleVal",
|
|
CefV8Value::CreateDouble(5.432)));
|
|
ASSERT_TRUE(testObj->SetValue("boolVal",
|
|
CefV8Value::CreateBool(true)));
|
|
ASSERT_TRUE(testObj->SetValue("stringVal",
|
|
CefV8Value::CreateString("the string")));
|
|
|
|
CefRefPtr<CefV8Value> testArray(CefV8Value::CreateArray());
|
|
ASSERT_TRUE(testArray.get() != NULL);
|
|
ASSERT_TRUE(testObj->SetValue("arrayVal", testArray));
|
|
ASSERT_TRUE(testArray->SetValue(0, CefV8Value::CreateInt(4)));
|
|
ASSERT_TRUE(testArray->SetValue(1, CefV8Value::CreateDouble(120.43)));
|
|
ASSERT_TRUE(testArray->SetValue(2, CefV8Value::CreateBool(true)));
|
|
ASSERT_TRUE(testArray->SetValue(3, CefV8Value::CreateString("a string")));
|
|
}
|
|
|
|
bool binding_test_;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Verify window binding
|
|
TEST(V8Test, Binding)
|
|
{
|
|
g_V8TestV8HandlerExecuteCalled = false;
|
|
g_V8TestV8HandlerExecute2Called = false;
|
|
|
|
CefRefPtr<V8TestHandler> handler = new V8TestHandler(true);
|
|
handler->ExecuteTest();
|
|
|
|
ASSERT_TRUE(g_V8TestV8HandlerExecuteCalled);
|
|
ASSERT_TRUE(g_V8TestV8HandlerExecute2Called);
|
|
}
|
|
|
|
// Verify extensions
|
|
TEST(V8Test, Extension)
|
|
{
|
|
g_V8TestV8HandlerExecuteCalled = false;
|
|
g_V8TestV8HandlerExecute2Called = false;
|
|
|
|
std::string extensionCode =
|
|
"var test;"
|
|
"if (!test)"
|
|
" test = {};"
|
|
"(function() {"
|
|
" test.execute = function(a,b,c,d,e,f,g,h) {"
|
|
" native function execute();"
|
|
" return execute(a,b,c,d,e,f,g,h);"
|
|
" };"
|
|
" test.execute2 = function(a) {"
|
|
" native function execute2();"
|
|
" return execute2(a);"
|
|
" };"
|
|
"})();";
|
|
CefRegisterExtension("v8/test", extensionCode, new V8TestV8Handler(false));
|
|
|
|
CefRefPtr<V8TestHandler> handler = new V8TestHandler(false);
|
|
handler->ExecuteTest();
|
|
|
|
ASSERT_TRUE(g_V8TestV8HandlerExecuteCalled);
|
|
ASSERT_TRUE(g_V8TestV8HandlerExecute2Called);
|
|
}
|
|
|
|
namespace {
|
|
|
|
// Using a delegate so that the code below can remain inline.
|
|
class CefV8HandlerDelegate
|
|
{
|
|
public:
|
|
virtual bool Execute(const CefString& name,
|
|
CefRefPtr<CefV8Value> object,
|
|
const CefV8ValueList& arguments,
|
|
CefRefPtr<CefV8Value>& retval,
|
|
CefString& exception) = 0;
|
|
};
|
|
|
|
class DelegatingV8Handler : public CefThreadSafeBase<CefV8Handler>
|
|
{
|
|
public:
|
|
DelegatingV8Handler(CefV8HandlerDelegate *delegate):
|
|
delegate_(delegate) { }
|
|
|
|
~DelegatingV8Handler()
|
|
{
|
|
}
|
|
|
|
bool Execute(const CefString& name,
|
|
CefRefPtr<CefV8Value> object,
|
|
const CefV8ValueList& arguments,
|
|
CefRefPtr<CefV8Value>& retval,
|
|
CefString& exception)
|
|
{
|
|
return delegate_->Execute(name, object, arguments, retval, exception);
|
|
}
|
|
|
|
private:
|
|
CefV8HandlerDelegate *delegate_;
|
|
};
|
|
|
|
class TestContextHandler: public TestHandler, public CefV8HandlerDelegate
|
|
{
|
|
public:
|
|
TestContextHandler() {}
|
|
|
|
virtual void RunTest()
|
|
{
|
|
// Test Flow:
|
|
// load main.html.
|
|
// 1. main.html calls hello("main", callIFrame) in the execute handler.
|
|
// The excute handler checks that "main" was called and saves
|
|
// the callIFrame function, context, and receiver object.
|
|
// 2. iframe.html calls hello("iframe") in the execute handler.
|
|
// The execute handler checks that "iframe" was called. if both main
|
|
// and iframe were called, it calls CallIFrame()
|
|
// 3. CallIFrame calls "callIFrame" in main.html
|
|
// 4. which calls iframe.html "calledFromMain()".
|
|
// 5. which calls "fromIFrame()" in execute handler.
|
|
// The execute handler checks that the entered and current urls are
|
|
// what we expect: "main.html" and "iframe.html", respectively
|
|
// 6. It then posts a task to call AsyncTestContext
|
|
// you can validate the entered and current context are still the
|
|
// same here, but it is not checked by this test case.
|
|
// 7. AsyncTestContext tests to make sure that no context is set at
|
|
// this point and loads "begin.html"
|
|
// 8. begin.html calls "begin(func1, func2)" in the execute handler
|
|
// The execute handler posts a tasks to call both of those functions
|
|
// when no context is defined. Both should work with the specified
|
|
// context. AsyncTestException should run first, followed by
|
|
// AsyncTestNavigate() which calls the func2 to do a document.location
|
|
// based loading of "end.html".
|
|
// 9. end.html calls "end()" in the execute handler.
|
|
// which concludes the test.
|
|
|
|
std::stringstream mainHtml;
|
|
mainHtml <<
|
|
"<html><body>"
|
|
"<h1>Hello From Main Frame</h1>"
|
|
"<script language=\"JavaScript\">"
|
|
"hello(\"main\", callIFrame);"
|
|
"function callIFrame() {"
|
|
" var iframe = document.getElementById('iframe');"
|
|
" iframe.contentWindow.calledFromMain();"
|
|
"}"
|
|
"</script>"
|
|
"<iframe id=\"iframe\" src=\"http://tests/iframe.html\""
|
|
" width=\"300\" height=\"300\">"
|
|
"</iframe>"
|
|
"</body></html>";
|
|
|
|
AddResource("http://tests/main.html", mainHtml.str(), "text/html");
|
|
|
|
std::stringstream iframeHtml;
|
|
iframeHtml <<
|
|
"<html><body>"
|
|
"<h1>Hello From IFRAME</h1>"
|
|
"<script language=\"JavaScript\">"
|
|
"hello(\"iframe\");"
|
|
"function calledFromMain() { fromIFrame(); }"
|
|
"</script>"
|
|
"</body></html>";
|
|
|
|
AddResource("http://tests/iframe.html", iframeHtml.str(), "text/html");
|
|
|
|
std::stringstream beginHtml;
|
|
beginHtml <<
|
|
"<html><body>"
|
|
"<h1>V8 Context Test</h1>"
|
|
"<script language=\"JavaScript\">"
|
|
"function TestException() { throw('My Exception'); }"
|
|
"function TestNavigate(a) { document.location = a; }"
|
|
"begin(TestException, TestNavigate);"
|
|
"</script>"
|
|
"</body></html>";
|
|
|
|
AddResource("http://tests/begin.html", beginHtml.str(), "text/html");
|
|
|
|
std::stringstream endHtml;
|
|
endHtml <<
|
|
"<html><body>"
|
|
"<h1>Navigation Succeeded!</h1>"
|
|
"<script language=\"JavaScript\">"
|
|
"end();"
|
|
"</script>"
|
|
"</body></html>";
|
|
|
|
AddResource("http://tests/end.html", endHtml.str(), "text/html");
|
|
|
|
CreateBrowser("http://tests/main.html");
|
|
}
|
|
|
|
virtual RetVal HandleLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
bool isMainContent,
|
|
int httpStatusCode)
|
|
{
|
|
return RV_CONTINUE;
|
|
}
|
|
|
|
virtual RetVal HandleJSBinding(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefV8Value> object)
|
|
{
|
|
CefRefPtr<CefV8Context> cc = CefV8Context::GetCurrentContext();
|
|
CefRefPtr<CefBrowser> currentBrowser = cc->GetBrowser();
|
|
CefRefPtr<CefFrame> currentFrame = cc->GetFrame();
|
|
CefString currentURL = currentFrame->GetURL();
|
|
|
|
CefRefPtr<CefV8Context> ec = CefV8Context::GetEnteredContext();
|
|
CefRefPtr<CefBrowser> enteredBrowser = ec->GetBrowser();
|
|
CefRefPtr<CefFrame> enteredFrame = ec->GetFrame();
|
|
CefString enteredURL = enteredFrame->GetURL();
|
|
|
|
CefRefPtr<CefV8Handler> funcHandler(new DelegatingV8Handler(this));
|
|
CefRefPtr<CefV8Value> helloFunc =
|
|
CefV8Value::CreateFunction("hello", funcHandler);
|
|
object->SetValue("hello", helloFunc);
|
|
|
|
CefRefPtr<CefV8Value> fromIFrameFunc =
|
|
CefV8Value::CreateFunction("fromIFrame", funcHandler);
|
|
object->SetValue("fromIFrame", fromIFrameFunc);
|
|
|
|
CefRefPtr<CefV8Value> goFunc =
|
|
CefV8Value::CreateFunction("begin", funcHandler);
|
|
object->SetValue("begin", goFunc);
|
|
|
|
CefRefPtr<CefV8Value> doneFunc =
|
|
CefV8Value::CreateFunction("end", funcHandler);
|
|
object->SetValue("end", doneFunc);
|
|
|
|
return RV_HANDLED;
|
|
}
|
|
|
|
void CallIFrame()
|
|
{
|
|
CefV8ValueList args;
|
|
CefRefPtr<CefV8Value> rv;
|
|
CefString exception;
|
|
CefRefPtr<CefV8Value> empty;
|
|
ASSERT_TRUE(funcIFrame_->ExecuteFunctionWithContext(contextIFrame_, empty,
|
|
args, rv, exception));
|
|
}
|
|
|
|
void AsyncTestContext(CefRefPtr<CefV8Context> ec,
|
|
CefRefPtr<CefV8Context> cc)
|
|
{
|
|
// we should not be in a context in this call.
|
|
CefRefPtr<CefV8Context> noContext = CefV8Context::GetCurrentContext();
|
|
if (!noContext.get())
|
|
got_no_context_.yes();
|
|
|
|
CefRefPtr<CefBrowser> enteredBrowser = ec->GetBrowser();
|
|
CefRefPtr<CefFrame> enteredFrame = ec->GetFrame();
|
|
CefString enteredURL = enteredFrame->GetURL();
|
|
CefString enteredName = enteredFrame->GetName();
|
|
CefRefPtr<CefFrame> enteredMainFrame = enteredBrowser->GetMainFrame();
|
|
CefString enteredMainURL = enteredMainFrame->GetURL();
|
|
CefString enteredMainName = enteredMainFrame->GetName();
|
|
|
|
CefRefPtr<CefBrowser> currentBrowser = cc->GetBrowser();
|
|
CefRefPtr<CefFrame> currentFrame = cc->GetFrame();
|
|
CefString currentURL = currentFrame->GetURL();
|
|
CefString currentName = currentFrame->GetName();
|
|
CefRefPtr<CefFrame> currentMainFrame = currentBrowser->GetMainFrame();
|
|
CefString currentMainURL = currentMainFrame->GetURL();
|
|
CefString currentMainName = currentMainFrame->GetName();
|
|
|
|
CefRefPtr<CefBrowser> copyFromMainFrame =
|
|
currentMainFrame->GetBrowser();
|
|
|
|
currentMainFrame->LoadURL("http://tests/begin.html");
|
|
}
|
|
|
|
void AsyncTestException(CefRefPtr<CefV8Context> context,
|
|
CefRefPtr<CefV8Value> func)
|
|
{
|
|
CefV8ValueList args;
|
|
CefRefPtr<CefV8Value> rv;
|
|
CefString exception;
|
|
CefRefPtr<CefV8Value> empty;
|
|
ASSERT_TRUE(func->ExecuteFunctionWithContext(context, empty, args, rv,
|
|
exception));
|
|
if(exception == "Uncaught My Exception")
|
|
got_exception_.yes();
|
|
}
|
|
|
|
void AsyncTestNavigation(CefRefPtr<CefV8Context> context,
|
|
CefRefPtr<CefV8Value> func)
|
|
{
|
|
CefV8ValueList args;
|
|
args.push_back(CefV8Value::CreateString("http://tests/end.html"));
|
|
CefRefPtr<CefV8Value> rv;
|
|
CefString exception;
|
|
CefRefPtr<CefV8Value> global = context->GetGlobal();
|
|
ASSERT_TRUE(func->ExecuteFunctionWithContext(context, global, args, rv,
|
|
exception));
|
|
if(exception.empty())
|
|
got_navigation_.yes();
|
|
}
|
|
|
|
bool Execute(const CefString& name,
|
|
CefRefPtr<CefV8Value> object,
|
|
const CefV8ValueList& arguments,
|
|
CefRefPtr<CefV8Value>& retval,
|
|
CefString& exception)
|
|
{
|
|
CefRefPtr<CefV8Context> cc = CefV8Context::GetCurrentContext();
|
|
CefRefPtr<CefV8Context> ec = CefV8Context::GetEnteredContext();
|
|
|
|
CefRefPtr<CefBrowser> enteredBrowser = ec->GetBrowser();
|
|
CefRefPtr<CefFrame> enteredFrame = ec->GetFrame();
|
|
CefString enteredURL = enteredFrame->GetURL();
|
|
CefString enteredName = enteredFrame->GetName();
|
|
CefRefPtr<CefFrame> enteredMainFrame = enteredBrowser->GetMainFrame();
|
|
CefString enteredMainURL = enteredMainFrame->GetURL();
|
|
CefString enteredMainName = enteredMainFrame->GetName();
|
|
|
|
CefRefPtr<CefBrowser> currentBrowser = cc->GetBrowser();
|
|
CefRefPtr<CefFrame> currentFrame = cc->GetFrame();
|
|
CefString currentURL = currentFrame->GetURL();
|
|
CefString currentName = currentFrame->GetName();
|
|
CefRefPtr<CefFrame> currentMainFrame = currentBrowser->GetMainFrame();
|
|
CefString currentMainURL = currentMainFrame->GetURL();
|
|
CefString currentMainName = currentMainFrame->GetName();
|
|
|
|
if (name == "hello") {
|
|
if(arguments.size() == 2 && arguments[0]->IsString() &&
|
|
arguments[1]->IsFunction()) {
|
|
CefString msg = arguments[0]->GetStringValue();
|
|
if(msg == "main") {
|
|
got_hello_main_.yes();
|
|
contextIFrame_ = cc;
|
|
funcIFrame_ = arguments[1];
|
|
}
|
|
} else if(arguments.size() == 1 && arguments[0]->IsString()) {
|
|
CefString msg = arguments[0]->GetStringValue();
|
|
if(msg == "iframe")
|
|
got_hello_iframe_.yes();
|
|
}
|
|
else
|
|
return false;
|
|
|
|
if(got_hello_main_ && got_hello_iframe_ && funcIFrame_->IsFunction()) {
|
|
// NB: At this point, enteredURL == http://tests/iframe.html which is
|
|
// expected since the iframe made the call on its own. The unexpected
|
|
// behavior is that in the call to fromIFrame (below) the enteredURL
|
|
// == http://tests/main.html even though the iframe.html context was
|
|
// entered first.
|
|
// -- Perhaps WebKit does something other than look at the bottom
|
|
// of stack for the entered context.
|
|
if(enteredURL == "http://tests/iframe.html")
|
|
got_iframe_as_entered_url_.yes();
|
|
CallIFrame();
|
|
}
|
|
return true;
|
|
} else if(name == "fromIFrame") {
|
|
if(enteredURL == "http://tests/main.html")
|
|
got_correct_entered_url_.yes();
|
|
if(currentURL == "http://tests/iframe.html")
|
|
got_correct_current_url_.yes();
|
|
CefPostTask(TID_UI, NewCefRunnableMethod(this,
|
|
&TestContextHandler::AsyncTestContext, ec, cc));
|
|
return true;
|
|
} else if(name == "begin") {
|
|
if(arguments.size() == 2 && arguments[0]->IsFunction() &&
|
|
arguments[1]->IsFunction()) {
|
|
CefRefPtr<CefV8Value> funcException = arguments[0];
|
|
CefRefPtr<CefV8Value> funcNavigate = arguments[1];
|
|
CefPostTask(TID_UI, NewCefRunnableMethod(this,
|
|
&TestContextHandler::AsyncTestException, cc, funcException));
|
|
CefPostTask(TID_UI, NewCefRunnableMethod(this,
|
|
&TestContextHandler::AsyncTestNavigation, cc, funcNavigate));
|
|
return true;
|
|
}
|
|
} else if (name == "end") {
|
|
got_testcomplete_.yes();
|
|
DestroyTest();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// This function we will be called later to make it call into the
|
|
// IFRAME, which then calls "fromIFrame" so that we can check the
|
|
// entered vs current contexts are working as expected.
|
|
CefRefPtr<CefV8Context> contextIFrame_;
|
|
CefRefPtr<CefV8Value> funcIFrame_;
|
|
|
|
TrackCallback got_hello_main_;
|
|
TrackCallback got_hello_iframe_;
|
|
TrackCallback got_correct_entered_url_;
|
|
TrackCallback got_correct_current_url_;
|
|
TrackCallback got_iframe_as_entered_url_;
|
|
TrackCallback got_no_context_;
|
|
TrackCallback got_exception_;
|
|
TrackCallback got_navigation_;
|
|
TrackCallback got_testcomplete_;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Verify context works to allow async v8 callbacks
|
|
TEST(V8Test, Context)
|
|
{
|
|
CefRefPtr<TestContextHandler> handler = new TestContextHandler();
|
|
handler->ExecuteTest();
|
|
|
|
EXPECT_TRUE(handler->got_hello_main_);
|
|
EXPECT_TRUE(handler->got_hello_iframe_);
|
|
EXPECT_TRUE(handler->got_no_context_);
|
|
EXPECT_TRUE(handler->got_iframe_as_entered_url_);
|
|
EXPECT_TRUE(handler->got_correct_entered_url_);
|
|
EXPECT_TRUE(handler->got_correct_current_url_);
|
|
EXPECT_TRUE(handler->got_exception_);
|
|
EXPECT_TRUE(handler->got_navigation_);
|
|
EXPECT_TRUE(handler->got_testcomplete_);
|
|
}
|