bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-06-05 21:39:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove the old network implementation (see issue #2622)

Browse Source 
The `--disable-features=NetworkService` flag is no longer supported.
This commit is contained in:
Marshall Greenblatt
2019-07-29 17:27:12 -04:00
parent ccb06ce3cb
commit 67b61c4af9
76 changed files with 296 additions and 6113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
tests/ceftests/cookie_unittest.cc
View File

@@ -921,10 +921,7 @@ class CookieTestSchemeHandler : public TestHandler {
EXPECT_FALSE(got_cookie2_);
EXPECT_FALSE(got_cookie3_);
} else {
if (IsNetworkServiceEnabled())
EXPECT_TRUE(got_create_cookie_);
else
EXPECT_FALSE(got_create_cookie_);
EXPECT_TRUE(got_create_cookie_);
EXPECT_TRUE(got_process_request_cookie_);
EXPECT_TRUE(got_cookie1_);
EXPECT_TRUE(got_cookie2_);
@@ -1946,34 +1943,15 @@ class CookieAccessTestHandler : public RoutingTestHandler,
IMPLEMENT_REFCOUNTING(CookieAccessTestHandler);
};
bool IsTestSupported(CookieAccessTestHandler::TestMode test_mode,
CookieAccessTestHandler::TestBackend backend_mode,
bool custom_scheme,
bool use_global) {
if (!IsNetworkServiceEnabled() &&
backend_mode == CookieAccessTestHandler::RESOURCE_HANDLER &&
custom_scheme) {
// The old network implementation does not support the same functionality
// for intercepting custom scheme requests via GetResourceHandler().
return false;
}
return true;
}
} // namespace
#define ACCESS_TEST(name, test_mode, backend_mode, custom_scheme, use_global) \
TEST(CookieTest, Access##name) { \
if (!IsTestSupported(CookieAccessTestHandler::test_mode, \
CookieAccessTestHandler::backend_mode, custom_scheme, \
use_global)) { \
return; \
} \
CefRefPtr<CookieAccessTestHandler> handler = new CookieAccessTestHandler( \
CookieAccessTestHandler::test_mode, \
CookieAccessTestHandler::backend_mode, custom_scheme, use_global); \
handler->ExecuteTest(); \
ReleaseAndWaitForDestructor(handler); \
#define ACCESS_TEST(name, test_mode, backend_mode, custom_scheme, use_global) \
TEST(CookieTest, Access##name) { \
CefRefPtr<CookieAccessTestHandler> handler = new CookieAccessTestHandler( \
CookieAccessTestHandler::test_mode, \
CookieAccessTestHandler::backend_mode, custom_scheme, use_global); \
handler->ExecuteTest(); \
ReleaseAndWaitForDestructor(handler); \
}
#define ACCESS_TEST_ALL_MODES(name, backend_mode, custom_scheme, use_global) \
@@ -2396,8 +2374,6 @@ class CookieRestartTestHandler : public RoutingTestHandler,
} // namespace
TEST(CookieTest, RestartGlobal) {
if (!IsNetworkServiceEnabled())
return;
CefRefPtr<CookieRestartTestHandler> handler =
new CookieRestartTestHandler(true);
handler->ExecuteTest();
@@ -2405,8 +2381,6 @@ TEST(CookieTest, RestartGlobal) {
}
TEST(CookieTest, RestartInMemory) {
if (!IsNetworkServiceEnabled())
return;
CefRefPtr<CookieRestartTestHandler> handler =
new CookieRestartTestHandler(false);
handler->ExecuteTest();

21
tests/ceftests/navigation_unittest.cc
View File

@@ -896,16 +896,10 @@ class RedirectTestHandler : public TestHandler {
// Called due to the nav3 redirect response.
got_nav3_redirect_.yes();
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(307, response->GetStatus());
EXPECT_STREQ("Temporary Redirect",
response->GetStatusText().ToString().c_str());
EXPECT_STREQ("", response->GetMimeType().ToString().c_str());
} else {
EXPECT_EQ(303, response->GetStatus());
EXPECT_STREQ("See Other", response->GetStatusText().ToString().c_str());
EXPECT_STREQ("text/html", response->GetMimeType().ToString().c_str());
}
EXPECT_EQ(307, response->GetStatus());
EXPECT_STREQ("Temporary Redirect",
response->GetStatusText().ToString().c_str());
EXPECT_STREQ("", response->GetMimeType().ToString().c_str());
} else {
got_invalid_redirect_.yes();
}
@@ -1015,12 +1009,7 @@ TEST(NavigationTest, Redirect) {
ASSERT_TRUE(handler->got_nav4_load_end_);
ASSERT_FALSE(handler->got_invalid_load_end_);
ASSERT_TRUE(handler->got_nav1_redirect_);
if (IsNetworkServiceEnabled()) {
ASSERT_FALSE(handler->got_nav2_redirect_);
} else {
// This seems like a bug in the old network implementation.
ASSERT_TRUE(handler->got_nav2_redirect_);
}
ASSERT_FALSE(handler->got_nav2_redirect_);
ASSERT_TRUE(handler->got_nav3_redirect_);
ASSERT_FALSE(handler->got_invalid_redirect_);
ASSERT_TRUE(g_got_nav1_request);

462
tests/ceftests/resource_request_handler_unittest.cc
View File

@@ -38,10 +38,7 @@ class NormalResourceHandler : public CefStreamResourceHandler {
destroy_callback_(destroy_callback) {}
~NormalResourceHandler() override {
if (IsNetworkServiceEnabled())
EXPECT_EQ(1, cancel_ct_);
else
EXPECT_EQ(0, cancel_ct_);
EXPECT_EQ(1, cancel_ct_);
destroy_callback_.Run();
}
@@ -76,10 +73,7 @@ class IncompleteResourceHandler : public CefResourceHandler {
~IncompleteResourceHandler() override {
EXPECT_EQ(1, process_request_ct_);
if (IsNetworkServiceEnabled())
EXPECT_EQ(1, cancel_ct_);
else
EXPECT_EQ(0, cancel_ct_);
EXPECT_EQ(1, cancel_ct_);
if (test_mode_ == BLOCK_READ_RESPONSE) {
EXPECT_EQ(1, get_response_headers_ct_);
@@ -280,7 +274,7 @@ class BasicResponseTest : public TestHandler {
EXPECT_EQ(browser_id_, browser->GetIdentifier());
EXPECT_TRUE(frame->IsMain());
if (IsNetworkServiceEnabled() && request_id_ == 0U) {
if (request_id_ == 0U) {
// This is the first callback that provides a request ID.
request_id_ = request->GetIdentifier();
EXPECT_GT(request_id_, 0U);
@@ -443,9 +437,7 @@ class BasicResponseTest : public TestHandler {
// Redirect again.
new_url = GetURL(RESULT_HTML);
} else {
DCHECK(!IsNetworkServiceEnabled());
// The URL redirected to above.
EXPECT_STREQ(GetURL(RESULT_HTML), new_url.ToString().c_str());
NOTREACHED();
}
}
@@ -560,129 +552,85 @@ class BasicResponseTest : public TestHandler {
}
void DestroyTest() override {
if (!IsNetworkServiceEnabled()) {
// Called once for each other callback.
EXPECT_EQ(on_before_resource_load_ct_ + get_resource_handler_ct_ +
on_resource_redirect_ct_ + on_resource_response_ct_ +
get_resource_response_filter_ct_ +
on_resource_load_complete_ct_,
get_resource_request_handler_ct_);
// Only called at the time we handle cookies.
EXPECT_EQ(0, get_cookie_access_filter_ct_);
}
if (mode_ == LOAD || mode_ == MODIFY_BEFORE_RESOURCE_LOAD) {
EXPECT_EQ(1, on_before_browse_ct_);
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(1, get_resource_request_handler_ct_);
EXPECT_EQ(1, get_cookie_access_filter_ct_);
}
EXPECT_EQ(1, get_resource_request_handler_ct_);
EXPECT_EQ(1, get_cookie_access_filter_ct_);
EXPECT_EQ(1, on_before_resource_load_ct_);
EXPECT_EQ(1, get_resource_handler_ct_);
EXPECT_EQ(0, on_resource_redirect_ct_);
if (IsNetworkServiceEnabled()) {
// Unhandled requests won't see a call to GetResourceResponseFilter.
if (unhandled_)
EXPECT_EQ(0, get_resource_response_filter_ct_);
else
EXPECT_EQ(1, get_resource_response_filter_ct_);
// Unhandled requests won't see a call to GetResourceResponseFilter
// or OnResourceResponse.
if (unhandled_) {
EXPECT_EQ(0, get_resource_response_filter_ct_);
EXPECT_EQ(0, on_resource_response_ct_);
} else {
EXPECT_EQ(1, get_resource_response_filter_ct_);
EXPECT_EQ(1, on_resource_response_ct_);
}
} else if (mode_ == RESTART_RESOURCE_RESPONSE) {
EXPECT_EQ(1, on_before_browse_ct_);
EXPECT_EQ(2, get_resource_request_handler_ct_);
EXPECT_EQ(2, get_cookie_access_filter_ct_);
EXPECT_EQ(2, on_before_resource_load_ct_);
EXPECT_EQ(2, get_resource_handler_ct_);
EXPECT_EQ(0, on_resource_redirect_ct_);
// Unhandled requests won't see a call to GetResourceResponseFilter or
// OnResourceResponse. In this case we're restarting from inside
// OnResourceResponse.
if (unhandled_) {
EXPECT_EQ(0, get_resource_response_filter_ct_);
EXPECT_EQ(1, on_resource_response_ct_);
} else {
EXPECT_EQ(1, get_resource_response_filter_ct_);
EXPECT_EQ(2, on_resource_response_ct_);
}
} else if (IsRedirect()) {
EXPECT_EQ(2, on_before_browse_ct_);
EXPECT_EQ(2, get_resource_request_handler_ct_);
EXPECT_EQ(2, get_cookie_access_filter_ct_);
EXPECT_EQ(2, on_before_resource_load_ct_);
if (mode_ == REDIRECT_BEFORE_RESOURCE_LOAD) {
EXPECT_EQ(1, get_resource_handler_ct_);
} else {
EXPECT_EQ(2, get_resource_handler_ct_);
}
EXPECT_EQ(1, on_resource_redirect_ct_);
// Unhandled requests won't see a call to GetResourceResponseFilter.
if (unhandled_) {
EXPECT_EQ(0, get_resource_response_filter_ct_);
} else {
EXPECT_EQ(1, get_resource_response_filter_ct_);
}
// Unhandled requests won't see a call to OnResourceResponse.
if (unhandled_)
EXPECT_EQ(0, on_resource_response_ct_);
else
EXPECT_EQ(1, on_resource_response_ct_);
} else if (mode_ == RESTART_RESOURCE_RESPONSE) {
EXPECT_EQ(1, on_before_browse_ct_);
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(2, get_resource_request_handler_ct_);
EXPECT_EQ(2, get_cookie_access_filter_ct_);
EXPECT_EQ(2, on_before_resource_load_ct_);
} else {
// This seems like a bug in the old network implementation.
EXPECT_EQ(1, on_before_resource_load_ct_);
}
EXPECT_EQ(2, get_resource_handler_ct_);
EXPECT_EQ(0, on_resource_redirect_ct_);
if (IsNetworkServiceEnabled()) {
// Unhandled requests won't see a call to GetResourceResponseFilter.
if (unhandled_)
EXPECT_EQ(0, get_resource_response_filter_ct_);
else
EXPECT_EQ(1, get_resource_response_filter_ct_);
} else {
EXPECT_EQ(2, get_resource_response_filter_ct_);
}
// Unhandled requests won't see a call to OnResourceResponse.
// In this case we're restarting from inside OnResourceResponse.
if (unhandled_)
EXPECT_EQ(1, on_resource_response_ct_);
else
EXPECT_EQ(2, on_resource_response_ct_);
} else if (IsRedirect()) {
EXPECT_EQ(2, on_before_browse_ct_);
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(2, get_resource_request_handler_ct_);
EXPECT_EQ(2, get_cookie_access_filter_ct_);
} else {
// Called at the time that we handle cookies.
EXPECT_EQ(0, get_cookie_access_filter_ct_);
}
EXPECT_EQ(2, on_before_resource_load_ct_);
if (mode_ == REDIRECT_BEFORE_RESOURCE_LOAD)
EXPECT_EQ(1, get_resource_handler_ct_);
else
EXPECT_EQ(2, get_resource_handler_ct_);
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(1, on_resource_redirect_ct_);
} else {
if (mode_ == REDIRECT_RESOURCE_REDIRECT) {
// This seems like a bug in the old network implementation.
EXPECT_EQ(2, on_resource_redirect_ct_);
} else {
EXPECT_EQ(1, on_resource_redirect_ct_);
}
}
if (IsNetworkServiceEnabled()) {
// Unhandled requests won't see a call to GetResourceResponseFilter.
if (unhandled_)
EXPECT_EQ(0, get_resource_response_filter_ct_);
else
EXPECT_EQ(1, get_resource_response_filter_ct_);
} else {
if (mode_ == REDIRECT_RESOURCE_RESPONSE)
EXPECT_EQ(2, get_resource_response_filter_ct_);
else
EXPECT_EQ(1, get_resource_response_filter_ct_);
}
// Unhandled requests won't see a call to OnResourceResponse.
if (mode_ == REDIRECT_RESOURCE_RESPONSE) {
// In this case we're redirecting from inside OnResourceResponse.
if (unhandled_)
if (unhandled_) {
EXPECT_EQ(1, on_resource_response_ct_);
else
} else {
EXPECT_EQ(2, on_resource_response_ct_);
}
} else {
if (unhandled_)
if (unhandled_) {
EXPECT_EQ(0, on_resource_response_ct_);
else
} else {
EXPECT_EQ(1, on_resource_response_ct_);
}
}
} else if (IsIncomplete()) {
EXPECT_EQ(1, on_before_browse_ct_);
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(1, get_resource_request_handler_ct_);
EXPECT_EQ(1, get_cookie_access_filter_ct_);
}
EXPECT_EQ(1, get_resource_request_handler_ct_);
EXPECT_EQ(1, get_cookie_access_filter_ct_);
EXPECT_EQ(1, on_before_resource_load_ct_);
if (IsIncompleteRequestHandler())
if (IsIncompleteRequestHandler()) {
EXPECT_EQ(1, get_resource_handler_ct_);
else
} else {
EXPECT_EQ(0, get_resource_handler_ct_);
}
EXPECT_EQ(0, on_resource_redirect_ct_);
@@ -712,20 +660,23 @@ class BasicResponseTest : public TestHandler {
EXPECT_EQ(resource_handler_created_ct_, resource_handler_destroyed_ct_);
if (IsAborted())
if (IsAborted()) {
EXPECT_EQ(0, on_resource_load_complete_ct_);
else
} else {
EXPECT_EQ(1, on_resource_load_complete_ct_);
}
if (IsIncomplete() || IsAborted())
if (IsIncomplete() || IsAborted()) {
EXPECT_EQ(0, on_load_end_ct_);
else
} else {
EXPECT_EQ(1, on_load_end_ct_);
}
if (custom_scheme_ && unhandled_ && !(IsIncomplete() || IsAborted()))
if (custom_scheme_ && unhandled_ && !(IsIncomplete() || IsAborted())) {
EXPECT_EQ(1, on_protocol_execution_ct_);
else
} else {
EXPECT_EQ(0, on_protocol_execution_ct_);
}
TestHandler::DestroyTest();
@@ -900,7 +851,7 @@ class BasicResponseTest : public TestHandler {
// Browser-side navigation no longer exposes the actual request
// information.
EXPECT_EQ(0U, request->GetIdentifier()) << callback;
} else if (IsNetworkServiceEnabled()) {
} else {
// All resource-related callbacks share the same request ID.
EXPECT_EQ(request_id_, request->GetIdentifier()) << callback;
}
@@ -1080,41 +1031,14 @@ class BasicResponseTest : public TestHandler {
IMPLEMENT_REFCOUNTING(BasicResponseTest);
};
bool IsTestSupported(BasicResponseTest::TestMode test_mode,
bool custom_scheme,
bool unhandled) {
if (!IsNetworkServiceEnabled()) {
if (custom_scheme || unhandled) {
// The old network implementation does not support the same functionality
// for custom schemes and unhandled requests.
return false;
}
if (test_mode == BasicResponseTest::ABORT_AFTER_CREATED ||
test_mode == BasicResponseTest::ABORT_BEFORE_BROWSE ||
test_mode == BasicResponseTest::INCOMPLETE_BEFORE_RESOURCE_LOAD ||
test_mode ==
BasicResponseTest::INCOMPLETE_REQUEST_HANDLER_PROCESS_REQUEST ||
test_mode ==
BasicResponseTest::INCOMPLETE_REQUEST_HANDLER_READ_RESPONSE) {
// The old network implementation does not support the same behavior
// for canceling incomplete requests.
return false;
}
}
return true;
}
} // namespace
#define BASIC_TEST(name, test_mode, custom, unhandled) \
TEST(ResourceRequestHandlerTest, Basic##name) { \
if (!IsTestSupported(BasicResponseTest::test_mode, custom, unhandled)) { \
return; \
} \
CefRefPtr<BasicResponseTest> handler = new BasicResponseTest( \
BasicResponseTest::test_mode, custom, unhandled); \
handler->ExecuteTest(); \
ReleaseAndWaitForDestructor(handler); \
#define BASIC_TEST(name, test_mode, custom, unhandled) \
TEST(ResourceRequestHandlerTest, Basic##name) { \
CefRefPtr<BasicResponseTest> handler = new BasicResponseTest( \
BasicResponseTest::test_mode, custom, unhandled); \
handler->ExecuteTest(); \
ReleaseAndWaitForDestructor(handler); \
}
#define BASIC_TEST_ALL_MODES(name, custom, unhandled) \
@@ -1277,7 +1201,7 @@ class SubresourceResponseTest : public RoutingTestHandler {
VerifyFrame(kGetResourceRequestHandler, frame);
if (IsNetworkServiceEnabled() && request_id_ == 0U) {
if (request_id_ == 0U) {
// This is the first callback that provides a request ID.
request_id_ = request->GetIdentifier();
EXPECT_GT(request_id_, 0U);
@@ -1476,9 +1400,7 @@ class SubresourceResponseTest : public RoutingTestHandler {
// Redirect again.
new_url = GetURL(RESULT_JS);
} else {
DCHECK(!IsNetworkServiceEnabled());
// The URL redirected to above.
EXPECT_STREQ(GetURL(RESULT_JS), new_url.ToString().c_str());
NOTREACHED();
}
}
@@ -1652,106 +1574,61 @@ class SubresourceResponseTest : public RoutingTestHandler {
}
void DestroyTest() override {
if (!IsNetworkServiceEnabled()) {
// Called once for each other callback.
EXPECT_EQ(on_before_resource_load_ct_ + get_resource_handler_ct_ +
on_resource_redirect_ct_ + on_resource_response_ct_ +
get_resource_response_filter_ct_ +
on_resource_load_complete_ct_,
get_resource_request_handler_ct_);
// Only called at the time we handle cookies.
EXPECT_EQ(0, get_cookie_access_filter_ct_);
// Only called for the main and/or sub frame load.
if (subframe_) {
EXPECT_EQ(2, on_before_browse_ct_);
} else {
EXPECT_EQ(1, on_before_browse_ct_);
}
// Only called for the main and/or sub frame load.
if (subframe_)
EXPECT_EQ(2, on_before_browse_ct_);
else
EXPECT_EQ(1, on_before_browse_ct_);
if (mode_ == LOAD || mode_ == MODIFY_BEFORE_RESOURCE_LOAD) {
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(1, get_resource_request_handler_ct_);
EXPECT_EQ(1, get_cookie_access_filter_ct_);
}
EXPECT_EQ(1, get_resource_request_handler_ct_);
EXPECT_EQ(1, get_cookie_access_filter_ct_);
EXPECT_EQ(1, on_before_resource_load_ct_);
EXPECT_EQ(1, get_resource_handler_ct_);
EXPECT_EQ(0, on_resource_redirect_ct_);
if (IsNetworkServiceEnabled()) {
// Unhandled requests won't see a call to GetResourceResponseFilter.
if (unhandled_)
EXPECT_EQ(0, get_resource_response_filter_ct_);
else
EXPECT_EQ(1, get_resource_response_filter_ct_);
// Unhandled requests won't see a call to GetResourceResponseFilter or
// OnResourceResponse.
if (unhandled_) {
EXPECT_EQ(0, get_resource_response_filter_ct_);
EXPECT_EQ(0, on_resource_response_ct_);
} else {
EXPECT_EQ(1, get_resource_response_filter_ct_);
}
// Unhandled requests won't see a call to OnResourceResponse.
if (unhandled_)
EXPECT_EQ(0, on_resource_response_ct_);
else
EXPECT_EQ(1, on_resource_response_ct_);
}
} else if (mode_ == RESTART_RESOURCE_RESPONSE) {
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(2, get_resource_request_handler_ct_);
}
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(2, get_cookie_access_filter_ct_);
EXPECT_EQ(2, on_before_resource_load_ct_);
} else {
// This seems like a bug in the old network implementation.
EXPECT_EQ(1, on_before_resource_load_ct_);
}
EXPECT_EQ(2, get_resource_request_handler_ct_);
EXPECT_EQ(2, get_cookie_access_filter_ct_);
EXPECT_EQ(2, on_before_resource_load_ct_);
EXPECT_EQ(2, get_resource_handler_ct_);
EXPECT_EQ(0, on_resource_redirect_ct_);
if (IsNetworkServiceEnabled()) {
// Unhandled requests won't see a call to GetResourceResponseFilter.
if (unhandled_)
EXPECT_EQ(0, get_resource_response_filter_ct_);
else
EXPECT_EQ(1, get_resource_response_filter_ct_);
} else {
EXPECT_EQ(2, get_resource_response_filter_ct_);
}
// Unhandled requests won't see a call to OnResourceResponse.
// In this case we're restarting from inside OnResourceResponse.
if (unhandled_)
// Unhandled requests won't see a call to GetResourceResponseFilter or
// OnResourceResponse. In this case we're restarting from inside
// OnResourceResponse.
if (unhandled_) {
EXPECT_EQ(0, get_resource_response_filter_ct_);
EXPECT_EQ(1, on_resource_response_ct_);
else
} else {
EXPECT_EQ(1, get_resource_response_filter_ct_);
EXPECT_EQ(2, on_resource_response_ct_);
}
} else if (IsRedirect()) {
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(2, get_resource_request_handler_ct_);
EXPECT_EQ(2, get_cookie_access_filter_ct_);
}
EXPECT_EQ(2, get_resource_request_handler_ct_);
EXPECT_EQ(2, get_cookie_access_filter_ct_);
EXPECT_EQ(2, on_before_resource_load_ct_);
if (mode_ == REDIRECT_BEFORE_RESOURCE_LOAD)
if (mode_ == REDIRECT_BEFORE_RESOURCE_LOAD) {
EXPECT_EQ(1, get_resource_handler_ct_);
else
} else {
EXPECT_EQ(2, get_resource_handler_ct_);
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(1, on_resource_redirect_ct_);
} else {
if (mode_ == REDIRECT_RESOURCE_REDIRECT) {
// This seems like a bug in the old network implementation.
EXPECT_EQ(2, on_resource_redirect_ct_);
} else {
EXPECT_EQ(1, on_resource_redirect_ct_);
}
}
if (IsNetworkServiceEnabled()) {
// Unhandled requests won't see a call to GetResourceResponseFilter.
if (unhandled_)
EXPECT_EQ(0, get_resource_response_filter_ct_);
else
EXPECT_EQ(1, get_resource_response_filter_ct_);
} else {
if (mode_ == REDIRECT_RESOURCE_RESPONSE)
EXPECT_EQ(2, get_resource_response_filter_ct_);
else
EXPECT_EQ(1, get_resource_response_filter_ct_);
}
EXPECT_EQ(1, on_resource_redirect_ct_);
// Unhandled requests won't see a call to GetResourceResponseFilter.
if (unhandled_)
EXPECT_EQ(0, get_resource_response_filter_ct_);
else
EXPECT_EQ(1, get_resource_response_filter_ct_);
// Unhandled requests won't see a call to OnResourceResponse.
if (mode_ == REDIRECT_RESOURCE_RESPONSE) {
// In this case we're redirecting from inside OnResourceResponse.
@@ -1766,16 +1643,15 @@ class SubresourceResponseTest : public RoutingTestHandler {
EXPECT_EQ(1, on_resource_response_ct_);
}
} else if (IsIncomplete()) {
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(1, get_resource_request_handler_ct_);
EXPECT_EQ(1, get_cookie_access_filter_ct_);
}
EXPECT_EQ(1, get_resource_request_handler_ct_);
EXPECT_EQ(1, get_cookie_access_filter_ct_);
EXPECT_EQ(1, on_before_resource_load_ct_);
if (IsIncompleteRequestHandler())
if (IsIncompleteRequestHandler()) {
EXPECT_EQ(1, get_resource_handler_ct_);
else
} else {
EXPECT_EQ(0, get_resource_handler_ct_);
}
EXPECT_EQ(0, on_resource_redirect_ct_);
@@ -1797,21 +1673,24 @@ class SubresourceResponseTest : public RoutingTestHandler {
if (IsIncomplete()) {
EXPECT_EQ(0, on_load_end_ct_);
} else {
if (subframe_)
if (subframe_) {
EXPECT_EQ(2, on_load_end_ct_);
else
} else {
EXPECT_EQ(1, on_load_end_ct_);
}
}
if (unhandled_ || IsIncomplete())
if (unhandled_ || IsIncomplete()) {
EXPECT_EQ(0, on_query_ct_);
else
} else {
EXPECT_EQ(1, on_query_ct_);
}
if (custom_scheme_ && unhandled_ && !IsIncomplete())
if (custom_scheme_ && unhandled_ && !IsIncomplete()) {
EXPECT_EQ(1, on_protocol_execution_ct_);
else
} else {
EXPECT_EQ(0, on_protocol_execution_ct_);
}
TestHandler::DestroyTest();
@@ -2047,11 +1926,7 @@ class SubresourceResponseTest : public RoutingTestHandler {
else
EXPECT_TRUE(frame->IsMain()) << callback;
// This is sometimes -4 (kInvalidFrameId) with the old network
// implementation.
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(frame_id_, frame->GetIdentifier()) << callback;
}
EXPECT_EQ(frame_id_, frame->GetIdentifier()) << callback;
}
void VerifyState(Callback callback,
@@ -2072,10 +1947,8 @@ class SubresourceResponseTest : public RoutingTestHandler {
EXPECT_TRUE(request->IsReadOnly()) << callback;
}
if (IsNetworkServiceEnabled()) {
// All resource-related callbacks share the same request ID.
EXPECT_EQ(request_id_, request->GetIdentifier()) << callback;
}
// All resource-related callbacks share the same request ID.
EXPECT_EQ(request_id_, request->GetIdentifier()) << callback;
if (IsLoad() || IsIncomplete()) {
EXPECT_STREQ("GET", request->GetMethod().ToString().c_str()) << callback;
@@ -2106,16 +1979,8 @@ class SubresourceResponseTest : public RoutingTestHandler {
<< callback;
} else {
// After the redirect.
if (!IsNetworkServiceEnabled() && mode_ == REDIRECT_RESOURCE_REDIRECT) {
// With the old network stack we don't have a good signal to know when
// the final redirect has occurred.
const std::string& url = request->GetURL().ToString();
EXPECT_TRUE(url == GetURL(REDIRECT2_JS) || url == GetURL(RESULT_JS))
<< callback;
} else {
EXPECT_STREQ(GetURL(RESULT_JS), request->GetURL().ToString().c_str())
<< callback;
}
EXPECT_STREQ(GetURL(RESULT_JS), request->GetURL().ToString().c_str())
<< callback;
}
if (response) {
@@ -2265,37 +2130,10 @@ class SubresourceResponseTest : public RoutingTestHandler {
IMPLEMENT_REFCOUNTING(SubresourceResponseTest);
};
bool IsTestSupported(SubresourceResponseTest::TestMode test_mode,
bool custom_scheme,
bool unhandled,
bool subframe) {
if (!IsNetworkServiceEnabled()) {
if (custom_scheme || unhandled) {
// The old network implementation does not support the same functionality
// for custom schemes and unhandled requests.
return false;
}
if (test_mode == SubresourceResponseTest::INCOMPLETE_BEFORE_RESOURCE_LOAD ||
test_mode == SubresourceResponseTest::
INCOMPLETE_REQUEST_HANDLER_PROCESS_REQUEST ||
test_mode ==
SubresourceResponseTest::INCOMPLETE_REQUEST_HANDLER_READ_RESPONSE) {
// The old network implementation does not support the same behavior
// for canceling incomplete requests.
return false;
}
}
return true;
}
} // namespace
#define SUBRESOURCE_TEST(name, test_mode, custom, unhandled, subframe) \
TEST(ResourceRequestHandlerTest, Subresource##name) { \
if (!IsTestSupported(SubresourceResponseTest::test_mode, custom, \
unhandled, subframe)) { \
return; \
} \
CefRefPtr<SubresourceResponseTest> handler = new SubresourceResponseTest( \
SubresourceResponseTest::test_mode, custom, unhandled, subframe); \
handler->ExecuteTest(); \
@@ -2552,13 +2390,8 @@ class RedirectResponseTest : public TestHandler {
EXPECT_EQ(expected_resource_response_ct_, resource_response_ct_);
EXPECT_EQ(expected_resource_response_ct_, get_resource_handler_ct_);
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(expected_resource_load_complete_ct_,
get_resource_response_filter_ct_);
} else {
EXPECT_EQ(expected_resource_response_ct_,
get_resource_response_filter_ct_);
}
EXPECT_EQ(expected_resource_load_complete_ct_,
get_resource_response_filter_ct_);
EXPECT_EQ(expected_before_resource_load_ct_, before_resource_load_ct_);
EXPECT_EQ(expected_resource_redirect_ct_, resource_redirect_ct_);
EXPECT_EQ(expected_resource_load_complete_ct_,
@@ -2603,10 +2436,7 @@ class RedirectResponseTest : public TestHandler {
// With NetworkService we don't get an additional (unnecessary) redirect
// callback.
UrlResourceTest()
: ResourceTest("http://test.com/start_url.js",
IsNetworkServiceEnabled() ? 2U : 3U,
2U,
1U) {
: ResourceTest("http://test.com/start_url.js", 2U, 2U, 1U) {
redirect_url_ = "http://test.com/redirect_url.js";
}
@@ -2653,9 +2483,7 @@ class RedirectResponseTest : public TestHandler {
// With NetworkService we restart the request, so we get another call to
// OnBeforeResourceLoad.
HeaderResourceTest()
: ResourceTest("http://test.com/start_header.js",
2U,
IsNetworkServiceEnabled() ? 2U : 1U) {
: ResourceTest("http://test.com/start_header.js", 2U, 2U) {
expected_headers_.insert(std::make_pair("Test-Key1", "Value1"));
expected_headers_.insert(std::make_pair("Test-Key2", "Value2"));
}
@@ -2686,10 +2514,7 @@ class RedirectResponseTest : public TestHandler {
public:
// With NetworkService we restart the request, so we get another call to
// OnBeforeResourceLoad.
PostResourceTest()
: ResourceTest("http://test.com/start_post.js",
2U,
IsNetworkServiceEnabled() ? 2U : 1U) {
PostResourceTest() : ResourceTest("http://test.com/start_post.js", 2U, 2U) {
CefRefPtr<CefPostDataElement> elem = CefPostDataElement::Create();
const std::string data("Test Post Data");
elem->SetToBytes(data.size(), data.c_str());
@@ -3118,14 +2943,9 @@ namespace {
const char kResponseFilterTestUrl[] = "http://tests.com/response_filter.html";
size_t GetResponseBufferSize() {
if (IsNetworkServiceEnabled()) {
// Match the default |capacity_num_bytes| value from
// mojo::Core::CreateDataPipe.
return 64 * 1024; // 64kb
} else {
// Match |kBufferSize| from net/filter/filter_source_stream.cc.
return 32 * 1024; // 32kb
}
// Match the default |capacity_num_bytes| value from
// mojo::Core::CreateDataPipe.
return 64 * 1024; // 64kb
}
const char kInputHeader[] = "<html><head></head><body>";

16
tests/ceftests/scheme_handler_unittest.cc
View File

@@ -259,8 +259,7 @@ class ClientSchemeHandler : public CefResourceHandler {
// CEF_SETTINGS_ACCEPT_LANGUAGE value from
// CefSettings.accept_language_list set in CefTestSuite::GetSettings()
// and expanded internally by ComputeAcceptLanguageFromPref.
EXPECT_STREQ(IsNetworkServiceEnabled() ? "en-GB,en;q=0.9" : "en-GB",
accept_language.data());
EXPECT_STREQ("en-GB,en;q=0.9", accept_language.data());
}
if (handled) {
@@ -808,8 +807,7 @@ TEST(SchemeHandlerTest, CustomNonStandardNameNotHandled) {
TEST(SchemeHandlerTest, CustomStandardDomainNotHandled) {
RegisterTestScheme("customstd", "test");
g_TestResults.url = "customstd://noexist/run.html";
g_TestResults.expected_error_code =
IsNetworkServiceEnabled() ? ERR_UNKNOWN_URL_SCHEME : ERR_FAILED;
g_TestResults.expected_error_code = ERR_UNKNOWN_URL_SCHEME;
CefRefPtr<TestSchemeHandler> handler = new TestSchemeHandler(&g_TestResults);
handler->ExecuteTest();
@@ -1904,10 +1902,7 @@ TEST(SchemeHandlerTest,
}
// Test that a custom standard scheme can generate cross-domain XHR requests
// that perform redirects when using the cross-origin whitelist. This is
// because we add an "Access-Control-Allow-Origin" header internally in
// CefResourceDispatcherHostDelegate::OnRequestRedirected() for the redirect
// request.
// that perform redirects when using the cross-origin whitelist.
TEST(SchemeHandlerTest,
CustomStandardXHRDifferentOriginRedirectWithWhitelistAsync1) {
RegisterTestScheme("customstd", "test1");
@@ -2013,10 +2008,7 @@ TEST(SchemeHandlerTest,
}
// Test that a custom standard scheme can generate cross-domain Fetch requests
// that perform redirects when using the cross-origin whitelist. This is
// because we add an "Access-Control-Allow-Origin" header internally in
// CefResourceDispatcherHostDelegate::OnRequestRedirected() for the redirect
// request.
// that perform redirects when using the cross-origin whitelist.
TEST(SchemeHandlerTest,
CustomStandardFetchDifferentOriginRedirectWithWhitelist1) {
RegisterTestScheme("customstdfetch", "test1");

12
tests/ceftests/test_util.cc
View File

@@ -3,7 +3,6 @@
// can be found in the LICENSE file.
#include "tests/ceftests/test_util.h"
#include "include/cef_command_line.h"
#include "include/cef_request_context_handler.h"
#include "tests/gtest/include/gtest/gtest.h"
@@ -267,17 +266,6 @@ void TestStringVectorEqual(const std::vector<CefString>& val1,
EXPECT_STREQ(val1[i].ToString().c_str(), val2[i].ToString().c_str());
}
bool IsNetworkServiceEnabled() {
static int state = -1;
if (state == -1) {
CefRefPtr<CefCommandLine> command_line =
CefCommandLine::GetGlobalCommandLine();
const std::string& value = command_line->GetSwitchValue("disable-features");
state = value.find("NetworkService") == std::string::npos ? 1 : 0;
}
return state ? true : false;
}
CefRefPtr<CefRequestContext> CreateTestRequestContext(
TestRequestContextMode mode,
const std::string& cache_path) {

3
tests/ceftests/test_util.h
View File

@@ -65,9 +65,6 @@ void TestProcessMessageEqual(CefRefPtr<CefProcessMessage> val1,
void TestStringVectorEqual(const std::vector<CefString>& val1,
const std::vector<CefString>& val2);
// Returns true if the NetworkService is enabled.
bool IsNetworkServiceEnabled();
enum TestRequestContextMode {
TEST_RC_MODE_NONE,
TEST_RC_MODE_GLOBAL,

60
tests/ceftests/urlrequest_unittest.cc
View File

@@ -455,7 +455,7 @@ void VerifyNormalRequest(const RequestRunSettings* settings,
// CEF_SETTINGS_ACCEPT_LANGUAGE value from CefSettings.accept_language_list
// set in CefTestSuite::GetSettings() and expanded internally by
// ComputeAcceptLanguageFromPref.
EXPECT_STREQ(IsNetworkServiceEnabled() ? "en-GB,en;q=0.9" : "en-GB",
EXPECT_STREQ("en-GB,en;q=0.9",
GetHeaderValue(headerMap, "accept-language").c_str());
if (server_backend) {
@@ -553,10 +553,7 @@ class RequestSchemeHandler : public CefResourceHandler {
: settings_(settings), destroy_callback_(destroy_callback) {}
~RequestSchemeHandler() override {
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(1, cancel_ct_);
}
EXPECT_EQ(1, cancel_ct_);
destroy_callback_.Run();
}
@@ -636,10 +633,7 @@ class RequestRedirectSchemeHandler : public CefResourceHandler {
destroy_callback_(destroy_callback) {}
~RequestRedirectSchemeHandler() override {
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(1, cancel_ct_);
}
EXPECT_EQ(1, cancel_ct_);
destroy_callback_.Run();
}
@@ -707,11 +701,7 @@ class IncompleteSchemeHandler : public CefResourceHandler {
~IncompleteSchemeHandler() override {
EXPECT_EQ(1, process_request_ct_);
if (IsNetworkServiceEnabled())
EXPECT_EQ(1, cancel_ct_);
else
EXPECT_EQ(0, cancel_ct_);
EXPECT_EQ(1, cancel_ct_);
if (settings_->incomplete_type ==
RequestRunSettings::INCOMPLETE_READ_RESPONSE) {
@@ -1558,7 +1548,7 @@ class RequestTestRunner : public base::RefCountedThreadSafe<RequestTestRunner> {
// on stop redirects.
settings_.response = CefResponse::Create();
settings_.response->SetStatus(302);
if (IsNetworkServiceEnabled() && is_browser_process_) {
if (is_browser_process_) {
settings_.response->SetStatusText("Found");
}
@@ -2174,10 +2164,8 @@ class RequestTestRunner : public base::RefCountedThreadSafe<RequestTestRunner> {
CefRefPtr<RequestClient> client = new RequestClient(complete_callback);
// Delegation to CefRequestHandler::GetAuthCredentials is only supported
// with NetworkService.
if ((!IsNetworkServiceEnabled() || !use_frame_method_) &&
settings_.expect_authentication) {
// Not delegating to CefRequestHandler::GetAuthCredentials.
if (!use_frame_method_ && settings_.expect_authentication) {
client->has_authentication_ = true;
client->username_ = settings_.username;
client->password_ = settings_.password;
@@ -2891,18 +2879,16 @@ class RequestTestHandler : public TestHandler {
EXPECT_TRUE(got_success_);
}
if (IsNetworkServiceEnabled()) {
if (test_frame_method_) {
// Expect at least 1 call to OnBeforeResourceLoad for every test.
// Redirect tests may get multiple calls.
EXPECT_LE(1, test_frame_resource_load_ct_);
}
if (test_frame_method_) {
// Expect at least 1 call to OnBeforeResourceLoad for every test.
// Redirect tests may get multiple calls.
EXPECT_LE(1, test_frame_resource_load_ct_);
}
// CefRequestHandler::GetAuthCredentials should be called after
// CefURLRequestClient::GetAuthCredentials when the request has an
// associated frame.
if (IsNetworkServiceEnabled() && test_in_browser_ && test_frame_method_ &&
if (test_in_browser_ && test_frame_method_ &&
test_runner_->settings_.expect_authentication) {
EXPECT_EQ(1, auth_credentials_ct_);
} else {
@@ -3011,20 +2997,10 @@ bool IsTestSupported(RequestTestMode test_mode,
bool test_in_browser,
bool test_server_backend,
bool test_frame_method) {
if (IsNetworkServiceEnabled()) {
if (!test_in_browser && !test_server_backend && !test_frame_method) {
// When NetworkService is enabled requests from the render process can
// only reach non-server backends when using the
// CefFrame::CreateURLRequest method.
return false;
}
} else {
if (test_mode == REQTEST_INCOMPLETE_PROCESS_REQUEST ||
test_mode == REQTEST_INCOMPLETE_READ_RESPONSE) {
// The old network implementation does not support the same behavior
// for canceling incomplete requests.
return false;
}
if (!test_in_browser && !test_server_backend && !test_frame_method) {
// Requests from the render process can only reach non-server backends when
// using the CefFrame::CreateURLRequest method.
return false;
}
return true;
@@ -3251,9 +3227,7 @@ class InvalidURLTestClient : public CefURLRequestClient {
void OnRequestComplete(CefRefPtr<CefURLRequest> client) override {
EXPECT_EQ(UR_FAILED, client->GetRequestStatus());
if (IsNetworkServiceEnabled()) {
EXPECT_EQ(ERR_UNKNOWN_URL_SCHEME, client->GetRequestError());
}
EXPECT_EQ(ERR_UNKNOWN_URL_SCHEME, client->GetRequestError());
// Let the call stack unwind before signaling completion.
CefPostTask(TID_UI,