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 methods that modify cookie storage at runtime (see issue #2622).

Browse Source 
This change removes cookie and request handler functionality that will not
supported by the NetworkService. Specifically, it is no longer possible to
change cookie storage locations at runime by returning a different
CefCookieManager for an already initialized CefRequestContext. After this change
you will need to use a separate CefRequestContext when creating a CefBrowser if
you require separate cookie storage.

The following methods have been removed:
- CefCookieManager::CreateManager
- CefCookieManager::GetBlockingManager
- CefCookieManager::SetStoragePath
- CefRequestContextHandler::GetCookieManager

The following methods have been renamed:
- CefRequestContext::GetDefaultCookieManager to GetCookieManager.

This change substantially simplifies the network implementation in CEF because
it is no longer necessary to proxy objects that are normally owned by Chromium.
Chromium patches that are no longer necessary will be removed as a follow-up
commit.

To test: Verify that `ceftests --gtest_filter=-PluginTest.*` pass with
NetworkService disabled. Plugin tests will be fixed in a follow-up commit.
This commit is contained in:
Marshall Greenblatt
2019-03-22 18:11:51 -04:00
parent 6b2c1fe969
commit a23e845244
66 changed files with 1175 additions and 3939 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
tests/cefclient/browser/root_window_manager.cc
View File

@ -22,14 +22,7 @@ namespace {
class ClientRequestContextHandler : public CefRequestContextHandler,
public CefExtensionHandler {
public:
ClientRequestContextHandler() {
CefRefPtr<CefCommandLine> command_line =
CefCommandLine::GetGlobalCommandLine();
if (command_line->HasSwitch(switches::kRequestContextBlockCookies)) {
// Use a cookie manager that neither stores nor retrieves cookies.
cookie_manager_ = CefCookieManager::GetBlockingManager();
}
}
ClientRequestContextHandler() {}
// CefRequestContextHandler methods:
bool OnBeforePluginLoad(const CefString& mime_type,
@ -80,10 +73,6 @@ class ClientRequestContextHandler : public CefRequestContextHandler,
}
}
CefRefPtr<CefCookieManager> GetCookieManager() OVERRIDE {
return cookie_manager_;
}
// CefExtensionHandler methods:
void OnExtensionLoaded(CefRefPtr<CefExtension> extension) OVERRIDE {
CEF_REQUIRE_UI_THREAD();
@ -110,8 +99,6 @@ class ClientRequestContextHandler : public CefRequestContextHandler,
}
private:
CefRefPtr<CefCookieManager> cookie_manager_;
IMPLEMENT_REFCOUNTING(ClientRequestContextHandler);
DISALLOW_COPY_AND_ASSIGN(ClientRequestContextHandler);
};

546
tests/ceftests/cookie_unittest.cc
View File

@ -11,15 +11,12 @@
#include "include/cef_scheme.h"
#include "include/cef_waitable_event.h"
#include "include/wrapper/cef_closure_task.h"
#include "include/wrapper/cef_scoped_temp_dir.h"
#include "tests/ceftests/test_handler.h"
#include "tests/ceftests/test_suite.h"
#include "tests/gtest/include/gtest/gtest.h"
namespace {
const int kCacheDeleteDelay = 50;
const char* kTestUrl = "http://www.test.com/path/to/cookietest/foo.html";
const char* kTestDomain = "www.test.com";
const char* kTestPath = "/path/to/cookietest";
@ -465,63 +462,10 @@ void TestAllCookies(CefRefPtr<CefCookieManager> manager,
VerifyNoCookies(manager, event, false);
}
void TestChangeDirectory(CefRefPtr<CefCookieManager> manager,
CefRefPtr<CefWaitableEvent> event,
const CefString& original_dir) {
CefCookie cookie;
CefScopedTempDir temp_dir;
// Create a new temporary directory.
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
// Delete all of the system cookies.
DeleteAllCookies(manager, event);
// Set the new temporary directory as the storage location.
EXPECT_TRUE(manager->SetStoragePath(temp_dir.GetPath(), false, NULL));
// Wait for the storage location change to complete on the IO thread.
WaitForIOThread();
// Verify that no cookies exist.
VerifyNoCookies(manager, event, true);
// Create a domain cookie.
CreateCookie(manager, cookie, true, false, event);
// Retrieve and verify the domain cookie.
GetCookie(manager, cookie, true, event, false);
// Restore the original storage location.
EXPECT_TRUE(manager->SetStoragePath(original_dir, false, NULL));
// Wait for the storage location change to complete on the IO thread.
WaitForIOThread();
// Verify that no cookies exist.
VerifyNoCookies(manager, event, true);
// Set the new temporary directory as the storage location.
EXPECT_TRUE(manager->SetStoragePath(temp_dir.GetPath(), false, NULL));
// Wait for the storage location change to complete on the IO thread.
WaitForIOThread();
// Retrieve and verify the domain cookie that was set previously.
GetCookie(manager, cookie, true, event, false);
// Restore the original storage location.
EXPECT_TRUE(manager->SetStoragePath(original_dir, false, NULL));
// Wait for the storage location change to complete on the IO thread.
WaitForIOThread();
}
} // namespace
// Test creation of a domain cookie.
TEST(CookieTest, DomainCookieGlobal) {
TEST(CookieTest, DomainCookie) {
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
@ -533,44 +477,8 @@ TEST(CookieTest, DomainCookieGlobal) {
TestDomainCookie(manager, event);
}
// Test creation of a domain cookie.
TEST(CookieTest, DomainCookieInMemory) {
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> manager = CefCookieManager::CreateManager(
CefString(), false, new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
TestDomainCookie(manager, event);
}
// Test creation of a domain cookie.
TEST(CookieTest, DomainCookieOnDisk) {
CefScopedTempDir temp_dir;
// Create a new temporary directory.
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> manager = CefCookieManager::CreateManager(
temp_dir.GetPath(), false, new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
TestDomainCookie(manager, event);
// The backing store will be closed on the FILE thread after the CookieManager
// is destroyed.
manager = NULL;
WaitForFILEThreadWithDelay(kCacheDeleteDelay);
}
// Test creation of a host cookie.
TEST(CookieTest, HostCookieGlobal) {
TEST(CookieTest, HostCookie) {
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
@ -582,44 +490,8 @@ TEST(CookieTest, HostCookieGlobal) {
TestHostCookie(manager, event);
}
// Test creation of a host cookie.
TEST(CookieTest, HostCookieInMemory) {
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> manager = CefCookieManager::CreateManager(
CefString(), false, new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
TestHostCookie(manager, event);
}
// Test creation of a host cookie.
TEST(CookieTest, HostCookieOnDisk) {
CefScopedTempDir temp_dir;
// Create a new temporary directory.
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> manager = CefCookieManager::CreateManager(
temp_dir.GetPath(), false, new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
TestHostCookie(manager, event);
// The backing store will be closed on the FILE thread after the CookieManager
// is destroyed.
manager = NULL;
WaitForFILEThreadWithDelay(kCacheDeleteDelay);
}
// Test creation of multiple cookies.
TEST(CookieTest, MultipleCookiesGlobal) {
TEST(CookieTest, MultipleCookies) {
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
@ -631,43 +503,7 @@ TEST(CookieTest, MultipleCookiesGlobal) {
TestMultipleCookies(manager, event);
}
// Test creation of multiple cookies.
TEST(CookieTest, MultipleCookiesInMemory) {
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> manager = CefCookieManager::CreateManager(
CefString(), false, new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
TestMultipleCookies(manager, event);
}
// Test creation of multiple cookies.
TEST(CookieTest, MultipleCookiesOnDisk) {
CefScopedTempDir temp_dir;
// Create a new temporary directory.
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> manager = CefCookieManager::CreateManager(
temp_dir.GetPath(), false, new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
TestMultipleCookies(manager, event);
// The backing store will be closed on the FILE thread after the CookieManager
// is destroyed.
manager = NULL;
WaitForFILEThreadWithDelay(kCacheDeleteDelay);
}
TEST(CookieTest, AllCookiesGlobal) {
TEST(CookieTest, AllCookies) {
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
@ -679,135 +515,6 @@ TEST(CookieTest, AllCookiesGlobal) {
TestAllCookies(manager, event);
}
TEST(CookieTest, AllCookiesInMemory) {
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> manager = CefCookieManager::CreateManager(
CefString(), false, new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
TestAllCookies(manager, event);
}
TEST(CookieTest, AllCookiesOnDisk) {
CefScopedTempDir temp_dir;
// Create a new temporary directory.
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> manager = CefCookieManager::CreateManager(
temp_dir.GetPath(), false, new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
TestAllCookies(manager, event);
// The backing store will be closed on the FILE thread after the CookieManager
// is destroyed.
manager = NULL;
WaitForFILEThreadWithDelay(kCacheDeleteDelay);
}
TEST(CookieTest, ChangeDirectoryGlobal) {
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> manager =
CefCookieManager::GetGlobalManager(new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
std::string cache_path;
CefTestSuite::GetInstance()->GetCachePath(cache_path);
TestChangeDirectory(manager, event, cache_path);
}
TEST(CookieTest, ChangeDirectoryCreated) {
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> manager = CefCookieManager::CreateManager(
CefString(), false, new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
TestChangeDirectory(manager, event, CefString());
}
TEST(CookieTest, SessionCookieNoPersist) {
CefScopedTempDir temp_dir;
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefCookie cookie;
// Create a new temporary directory.
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
CefRefPtr<CefCookieManager> manager = CefCookieManager::CreateManager(
temp_dir.GetPath(), false, new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
// Create a session cookie.
CreateCookie(manager, cookie, true, true, event);
// Retrieve and verify the cookie.
GetCookie(manager, cookie, true, event, false);
// Flush the cookie store to disk.
manager->FlushStore(new TestCompletionCallback(event));
event->Wait();
// Create a new manager to read the same cookie store.
manager = CefCookieManager::CreateManager(temp_dir.GetPath(), false,
new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
// Verify that the cookie doesn't exist.
VerifyNoCookies(manager, event, true);
}
TEST(CookieTest, SessionCookieWillPersist) {
CefScopedTempDir temp_dir;
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefCookie cookie;
// Create a new temporary directory.
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
CefRefPtr<CefCookieManager> manager = CefCookieManager::CreateManager(
temp_dir.GetPath(), true, new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
// Create a session cookie.
CreateCookie(manager, cookie, true, true, event);
// Retrieve and verify the cookie.
GetCookie(manager, cookie, true, event, false);
// Flush the cookie store to disk.
manager->FlushStore(new TestCompletionCallback(event));
event->Wait();
// Create a new manager to read the same cookie store.
manager = CefCookieManager::CreateManager(temp_dir.GetPath(), true,
new TestCompletionCallback(event));
event->Wait();
EXPECT_TRUE(manager.get());
// Verify that the cookie exists.
GetCookie(manager, cookie, true, event, false);
}
namespace {
const char* kCookieJSUrl1 = "http://tests/cookie1.html";
@ -815,44 +522,9 @@ const char* kCookieJSUrl2 = "http://tests/cookie2.html";
class CookieTestJSHandler : public TestHandler {
public:
class RequestContextHandler : public CefRequestContextHandler {
public:
explicit RequestContextHandler(CookieTestJSHandler* handler)
: handler_(handler) {}
CefRefPtr<CefCookieManager> GetCookieManager() override {
EXPECT_TRUE(handler_);
EXPECT_TRUE(CefCurrentlyOn(TID_IO));
if (url_ == kCookieJSUrl1) {
// Return the first cookie manager.
handler_->got_cookie_manager1_.yes();
return handler_->manager1_;
} else {
// Return the second cookie manager.
handler_->got_cookie_manager2_.yes();
return handler_->manager2_;
}
}
void SetURL(const std::string& url) { url_ = url; }
void Detach() { handler_ = NULL; }
private:
std::string url_;
CookieTestJSHandler* handler_;
IMPLEMENT_REFCOUNTING(RequestContextHandler);
};
CookieTestJSHandler() {}
void RunTest() override {
// Create new in-memory managers.
manager1_ = CefCookieManager::CreateManager(CefString(), false, NULL);
manager2_ = CefCookieManager::CreateManager(CefString(), false, NULL);
std::string page =
"<html><head>"
"<script>"
@ -869,13 +541,11 @@ class CookieTestJSHandler : public TestHandler {
"</head><body>COOKIE TEST2</body></html>";
AddResource(kCookieJSUrl2, page, "text/html");
context_handler_ = new RequestContextHandler(this);
context_handler_->SetURL(kCookieJSUrl1);
// Create the request context that will use an in-memory cache.
CefRequestContextSettings settings;
CefRefPtr<CefRequestContext> request_context =
CefRequestContext::CreateContext(settings, context_handler_.get());
CefRequestContext::CreateContext(settings, NULL);
manager_ = request_context->GetCookieManager(NULL);
// Create the browser.
CreateBrowser(kCookieJSUrl1, request_context);
@ -892,7 +562,6 @@ class CookieTestJSHandler : public TestHandler {
return;
}
context_handler_->SetURL(kCookieJSUrl2);
frame->LoadURL(kCookieJSUrl2);
}
@ -911,32 +580,26 @@ class CookieTestJSHandler : public TestHandler {
std::string url = frame->GetURL();
if (url == kCookieJSUrl1) {
got_load_end1_.yes();
VerifyCookie(manager1_, url, "name1", "value1", &got_cookie1_,
VerifyCookie(manager_, url, "name1", "value1", true, &got_cookie1_,
base::Bind(&CookieTestJSHandler::LoadNextURL, this, frame));
} else {
got_load_end2_.yes();
VerifyCookie(manager2_, url, "name2", "value2", &got_cookie2_,
VerifyCookie(manager_, url, "name2", "value2", true, &got_cookie2_,
base::Bind(&CookieTestJSHandler::CompleteTest, this));
}
}
void DestroyTest() override {
context_handler_->Detach();
context_handler_ = NULL;
TestHandler::DestroyTest();
}
// Verify that the cookie was set successfully.
void VerifyCookie(CefRefPtr<CefCookieManager> manager,
const std::string& url,
const std::string& name,
const std::string& value,
bool deleteCookie,
TrackCallback* callback,
const base::Closure& continue_callback) {
// Get the cookie.
EXPECT_TRUE(cookies_.empty());
VisitUrlCookies(manager, url, false, cookies_, false,
VisitUrlCookies(manager, url, false, cookies_, deleteCookie,
base::Bind(&CookieTestJSHandler::VerifyCookieComplete, this,
name, value, callback, continue_callback));
}
@ -954,15 +617,10 @@ class CookieTestJSHandler : public TestHandler {
continue_callback.Run();
}
CefRefPtr<RequestContextHandler> context_handler_;
CefRefPtr<CefCookieManager> manager1_;
CefRefPtr<CefCookieManager> manager2_;
CefRefPtr<CefCookieManager> manager_;
CookieVector cookies_;
TrackCallback got_cookie_manager1_;
TrackCallback got_cookie_manager2_;
TrackCallback got_load_end1_;
TrackCallback got_load_end2_;
TrackCallback got_cookie1_;
@ -978,8 +636,6 @@ TEST(CookieTest, GetCookieManagerJS) {
CefRefPtr<CookieTestJSHandler> handler = new CookieTestJSHandler();
handler->ExecuteTest();
EXPECT_TRUE(handler->got_cookie_manager1_);
EXPECT_TRUE(handler->got_cookie_manager2_);
EXPECT_TRUE(handler->got_load_end1_);
EXPECT_TRUE(handler->got_load_end2_);
EXPECT_TRUE(handler->got_cookie1_);
@ -990,6 +646,8 @@ TEST(CookieTest, GetCookieManagerJS) {
namespace {
const char kCustomCookieScheme[] = "ccustom";
class CookieTestSchemeHandler : public TestHandler {
public:
class SchemeHandler : public CefResourceHandler {
@ -1100,75 +758,62 @@ class CookieTestSchemeHandler : public TestHandler {
IMPLEMENT_REFCOUNTING(SchemeHandlerFactory);
};
class RequestContextHandler : public CefRequestContextHandler {
class CompletionCallback : public CefCompletionCallback {
public:
explicit RequestContextHandler(CookieTestSchemeHandler* handler)
: handler_(handler) {}
explicit CompletionCallback(const base::Closure& callback)
: callback_(callback) {}
CefRefPtr<CefCookieManager> GetCookieManager() override {
EXPECT_TRUE(handler_);
EXPECT_TRUE(CefCurrentlyOn(TID_IO));
if (url_ == handler_->url1_) {
// Return the first cookie manager.
handler_->got_cookie_manager1_.yes();
return handler_->manager1_;
} else {
// Return the second cookie manager.
handler_->got_cookie_manager2_.yes();
return handler_->manager2_;
}
void OnComplete() override {
callback_.Run();
callback_.Reset();
}
void SetURL(const std::string& url) { url_ = url; }
void Detach() { handler_ = NULL; }
private:
std::string url_;
CookieTestSchemeHandler* handler_;
IMPLEMENT_REFCOUNTING(RequestContextHandler);
base::Closure callback_;
IMPLEMENT_REFCOUNTING(CompletionCallback);
};
CookieTestSchemeHandler(const std::string& scheme) : scheme_(scheme) {
CookieTestSchemeHandler(const std::string& scheme, bool use_global)
: scheme_(scheme), use_global_(use_global) {
url1_ = scheme + "://cookie-tests/cookie1.html";
url2_ = scheme + "://cookie-tests/cookie2.html";
url3_ = scheme + "://cookie-tests/cookie3.html";
}
void RunTest() override {
// Create new in-memory managers.
manager1_ = CefCookieManager::CreateManager(CefString(), false, NULL);
manager2_ = CefCookieManager::CreateManager(CefString(), false, NULL);
if (scheme_ != "http") {
std::vector<CefString> schemes;
schemes.push_back(scheme_);
manager1_->SetSupportedSchemes(schemes, NULL);
manager2_->SetSupportedSchemes(schemes, NULL);
if (use_global_) {
request_context_ = CefRequestContext::GetGlobalContext();
} else {
// Create the request context that will use an in-memory cache.
CefRequestContextSettings settings;
request_context_ = CefRequestContext::CreateContext(settings, NULL);
}
context_handler_ = new RequestContextHandler(this);
context_handler_->SetURL(url1_);
// Create the request context that will use an in-memory cache.
CefRequestContextSettings settings;
CefRefPtr<CefRequestContext> request_context =
CefRequestContext::CreateContext(settings, context_handler_.get());
// Register the scheme handler.
request_context->RegisterSchemeHandlerFactory(
request_context_->RegisterSchemeHandlerFactory(
scheme_, "cookie-tests", new SchemeHandlerFactory(this));
manager_ = request_context_->GetCookieManager(NULL);
if (!use_global_) {
std::vector<CefString> schemes;
schemes.push_back(kCustomCookieScheme);
// Create the browser.
CreateBrowser(url1_, request_context);
// Need to wait for completion before creating the browser.
manager_->SetSupportedSchemes(
schemes, new CompletionCallback(base::Bind(
&CookieTestSchemeHandler::CreateBrowserContinue, this)));
} else {
CreateBrowserContinue();
}
// Time out the test after a reasonable period of time.
SetTestTimeout();
}
void CreateBrowserContinue() {
// Create the browser.
CreateBrowser(url1_, request_context_);
}
// Go to the next URL.
void LoadNextURL(CefRefPtr<CefFrame> frame, const std::string& url) {
if (!CefCurrentlyOn(TID_UI)) {
@ -1177,7 +822,6 @@ class CookieTestSchemeHandler : public TestHandler {
return;
}
context_handler_->SetURL(url);
frame->LoadURL(url);
}
@ -1201,25 +845,39 @@ class CookieTestSchemeHandler : public TestHandler {
std::string url = frame->GetURL();
if (url == url1_) {
got_load_end1_.yes();
VerifyCookie(manager1_, url, "name1", "value1", &got_cookie1_,
VerifyCookie(manager_, url, "name1", "value1", true, &got_cookie1_,
base::Bind(&CookieTestSchemeHandler::LoadNextURL, this,
frame, url2_));
} else if (url == url2_) {
got_load_end2_.yes();
VerifyCookie(manager2_, url, "name2", "value2", &got_cookie2_,
VerifyCookie(manager_, url, "name2", "value2", false, &got_cookie2_,
base::Bind(&CookieTestSchemeHandler::LoadNextURL, this,
frame, url3_));
} else {
got_load_end3_.yes();
VerifyCookie(
manager2_, url, "name2", "value2", &got_cookie3_,
manager_, url, "name2", "value2", true, &got_cookie3_,
base::Bind(&CookieTestSchemeHandler::CompleteTest, this, browser));
}
}
void DestroyTest() override {
context_handler_->Detach();
context_handler_ = NULL;
EXPECT_TRUE(got_process_request1_);
EXPECT_TRUE(got_process_request2_);
EXPECT_TRUE(got_process_request3_);
EXPECT_FALSE(got_create_cookie_);
EXPECT_TRUE(got_process_request_cookie_);
EXPECT_TRUE(got_load_end1_);
EXPECT_TRUE(got_load_end2_);
EXPECT_TRUE(got_load_end3_);
EXPECT_TRUE(got_cookie1_);
EXPECT_TRUE(got_cookie2_);
EXPECT_TRUE(got_cookie3_);
// Unregister the scheme handler.
request_context_->RegisterSchemeHandlerFactory(scheme_, "cookie-tests",
NULL);
request_context_ = NULL;
TestHandler::DestroyTest();
}
@ -1229,11 +887,12 @@ class CookieTestSchemeHandler : public TestHandler {
const std::string& url,
const std::string& name,
const std::string& value,
bool deleteCookie,
TrackCallback* callback,
const base::Closure& continue_callback) {
// Get the cookie.
EXPECT_TRUE(cookies_.empty());
VisitUrlCookies(manager, url, false, cookies_, false,
VisitUrlCookies(manager, url, false, cookies_, deleteCookie,
base::Bind(&CookieTestSchemeHandler::VerifyCookieComplete,
this, name, value, callback, continue_callback));
}
@ -1251,15 +910,14 @@ class CookieTestSchemeHandler : public TestHandler {
continue_callback.Run();
}
std::string scheme_;
const std::string scheme_;
const bool use_global_;
std::string url1_;
std::string url2_;
std::string url3_;
CefRefPtr<RequestContextHandler> context_handler_;
CefRefPtr<CefCookieManager> manager1_;
CefRefPtr<CefCookieManager> manager2_;
CefRefPtr<CefRequestContext> request_context_;
CefRefPtr<CefCookieManager> manager_;
CookieVector cookies_;
@ -1268,8 +926,6 @@ class CookieTestSchemeHandler : public TestHandler {
TrackCallback got_process_request3_;
TrackCallback got_create_cookie_;
TrackCallback got_process_request_cookie_;
TrackCallback got_cookie_manager1_;
TrackCallback got_cookie_manager2_;
TrackCallback got_load_end1_;
TrackCallback got_load_end2_;
TrackCallback got_load_end3_;
@ -1282,49 +938,35 @@ class CookieTestSchemeHandler : public TestHandler {
} // namespace
// Verify use of multiple cookie managers via HTTP.
TEST(CookieTest, GetCookieManagerHttp) {
// Verify use of the global cookie manager with HTTP.
TEST(CookieTest, GetCookieManagerHttpGlobal) {
CefRefPtr<CookieTestSchemeHandler> handler =
new CookieTestSchemeHandler("http");
new CookieTestSchemeHandler("http", true);
handler->ExecuteTest();
EXPECT_TRUE(handler->got_process_request1_);
EXPECT_TRUE(handler->got_process_request2_);
EXPECT_TRUE(handler->got_process_request3_);
EXPECT_FALSE(handler->got_create_cookie_);
EXPECT_TRUE(handler->got_process_request_cookie_);
EXPECT_TRUE(handler->got_cookie_manager1_);
EXPECT_TRUE(handler->got_cookie_manager2_);
EXPECT_TRUE(handler->got_load_end1_);
EXPECT_TRUE(handler->got_load_end2_);
EXPECT_TRUE(handler->got_load_end3_);
EXPECT_TRUE(handler->got_cookie1_);
EXPECT_TRUE(handler->got_cookie2_);
EXPECT_TRUE(handler->got_cookie3_);
ReleaseAndWaitForDestructor(handler);
}
// Verify use of multiple cookie managers via a custom scheme.
TEST(CookieTest, GetCookieManagerCustom) {
// Verify use of an in-memory cookie manager with HTTP.
TEST(CookieTest, GetCookieManagerHttpInMemory) {
CefRefPtr<CookieTestSchemeHandler> handler =
new CookieTestSchemeHandler("ccustom");
new CookieTestSchemeHandler("http", false);
handler->ExecuteTest();
ReleaseAndWaitForDestructor(handler);
}
EXPECT_TRUE(handler->got_process_request1_);
EXPECT_TRUE(handler->got_process_request2_);
EXPECT_TRUE(handler->got_process_request3_);
EXPECT_FALSE(handler->got_create_cookie_);
EXPECT_TRUE(handler->got_process_request_cookie_);
EXPECT_TRUE(handler->got_cookie_manager1_);
EXPECT_TRUE(handler->got_cookie_manager2_);
EXPECT_TRUE(handler->got_load_end1_);
EXPECT_TRUE(handler->got_load_end2_);
EXPECT_TRUE(handler->got_load_end3_);
EXPECT_TRUE(handler->got_cookie1_);
EXPECT_TRUE(handler->got_cookie2_);
EXPECT_TRUE(handler->got_cookie3_);
// Verify use of the global cookie manager with a custom scheme.
TEST(CookieTest, GetCookieManagerCustomGlobal) {
CefRefPtr<CookieTestSchemeHandler> handler =
new CookieTestSchemeHandler(kCustomCookieScheme, true);
handler->ExecuteTest();
ReleaseAndWaitForDestructor(handler);
}
// Verify use of an in-memory cookie manager with a custom scheme.
TEST(CookieTest, GetCookieManagerCustomInMemory) {
CefRefPtr<CookieTestSchemeHandler> handler =
new CookieTestSchemeHandler(kCustomCookieScheme, false);
handler->ExecuteTest();
ReleaseAndWaitForDestructor(handler);
}
@ -1332,7 +974,9 @@ TEST(CookieTest, GetCookieManagerCustom) {
// Called from client_app_delegates.cc.
void RegisterCookieCustomSchemes(CefRawPtr<CefSchemeRegistrar> registrar,
std::vector<CefString>& cookiable_schemes) {
// Used by GetCookieManagerCustom test.
// Used by GetCookieManagerCustom* tests.
registrar->AddCustomScheme(
"ccustom", CEF_SCHEME_OPTION_STANDARD | CEF_SCHEME_OPTION_CORS_ENABLED);
kCustomCookieScheme,
CEF_SCHEME_OPTION_STANDARD | CEF_SCHEME_OPTION_CORS_ENABLED);
cookiable_schemes.push_back(kCustomCookieScheme);
}

6
tests/ceftests/extensions/extension_test_handler.cc
View File

@ -180,11 +180,7 @@ void ExtensionTestHandler::VerifyExtensionInContext(
EXPECT_FALSE(extension_id.empty());
if (has_access) {
if (is_loader) {
EXPECT_TRUE(context->DidLoadExtension(extension_id));
} else {
EXPECT_FALSE(context->DidLoadExtension(extension_id));
}
EXPECT_TRUE(context->DidLoadExtension(extension_id));
EXPECT_TRUE(context->HasExtension(extension_id));
} else {
EXPECT_FALSE(context->DidLoadExtension(extension_id));

173
tests/ceftests/request_context_unittest.cc
View File

@ -34,7 +34,6 @@ TEST(RequestContextTest, CreateContext) {
class Handler : public CefRequestContextHandler {
public:
Handler() {}
CefRefPtr<CefCookieManager> GetCookieManager() override { return NULL; }
private:
IMPLEMENT_REFCOUNTING(Handler);
@ -197,157 +196,8 @@ TEST(RequestContextTest, CreateContextSharedOnDisk) {
namespace {
class CookieTestHandler : public TestHandler {
public:
class RequestContextHandler : public CefRequestContextHandler {
public:
explicit RequestContextHandler(CookieTestHandler* handler)
: handler_(handler) {}
CefRefPtr<CefCookieManager> GetCookieManager() override {
EXPECT_TRUE(handler_);
handler_->got_get_cookie_manager_.yes();
return handler_->cookie_manager_;
}
void Detach() { handler_ = NULL; }
private:
CookieTestHandler* handler_;
IMPLEMENT_REFCOUNTING(RequestContextHandler);
};
CookieTestHandler(const std::string& url) : url_(url) {}
void RunTest() override {
AddResource(url_,
"<html>"
"<head><script>document.cookie='name1=value1';</script></head>"
"<body>Nav1</body>"
"</html>",
"text/html");
CefRequestContextSettings settings;
context_handler_ = new RequestContextHandler(this);
context_ =
CefRequestContext::CreateContext(settings, context_handler_.get());
cookie_manager_ = CefCookieManager::CreateManager(CefString(), true, NULL);
// Create browser that loads the 1st URL.
CreateBrowser(url_, context_);
// Time out the test after a reasonable period of time.
SetTestTimeout();
}
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
int httpStatusCode) override {
CefRefPtr<CefRequestContext> context =
browser->GetHost()->GetRequestContext();
EXPECT_TRUE(context.get());
EXPECT_TRUE(context->IsSame(context_));
EXPECT_FALSE(context->IsGlobal());
EXPECT_EQ(context->GetHandler().get(), context_handler_.get());
FinishTest();
}
protected:
void FinishTest() {
// Verify that the cookie was set correctly.
class TestVisitor : public CefCookieVisitor {
public:
explicit TestVisitor(CookieTestHandler* handler) : handler_(handler) {}
~TestVisitor() override {
// Destroy the test.
CefPostTask(TID_UI,
base::Bind(&CookieTestHandler::DestroyTest, handler_));
}
bool Visit(const CefCookie& cookie,
int count,
int total,
bool& deleteCookie) override {
const std::string& name = CefString(&cookie.name);
const std::string& value = CefString(&cookie.value);
if (name == "name1" && value == "value1")
handler_->got_cookie_.yes();
return true;
}
private:
CookieTestHandler* handler_;
IMPLEMENT_REFCOUNTING(TestVisitor);
};
cookie_manager_->VisitAllCookies(new TestVisitor(this));
}
void DestroyTest() override {
// Verify test expectations.
EXPECT_TRUE(got_get_cookie_manager_);
EXPECT_TRUE(got_cookie_);
context_handler_->Detach();
context_handler_ = NULL;
context_ = NULL;
TestHandler::DestroyTest();
}
std::string url_;
CefRefPtr<CefRequestContext> context_;
CefRefPtr<RequestContextHandler> context_handler_;
CefRefPtr<CefCookieManager> cookie_manager_;
TrackCallback got_get_cookie_manager_;
TrackCallback got_cookie_;
IMPLEMENT_REFCOUNTING(CookieTestHandler);
};
} // namespace
// Test that the cookie manager is retrieved via the associated request context.
TEST(RequestContextTest, GetCookieManager) {
CefRefPtr<CookieTestHandler> handler =
new CookieTestHandler("http://tests-simple-rch.com/nav1.html");
handler->ExecuteTest();
ReleaseAndWaitForDestructor(handler);
}
namespace {
class PopupTestHandler : public TestHandler {
public:
class RequestContextHandler : public CefRequestContextHandler {
public:
explicit RequestContextHandler(PopupTestHandler* handler)
: handler_(handler) {}
CefRefPtr<CefCookieManager> GetCookieManager() override {
EXPECT_TRUE(handler_);
if (url_ == handler_->url_)
handler_->got_get_cookie_manager1_.yes();
else if (url_ == handler_->popup_url_)
handler_->got_get_cookie_manager2_.yes();
return handler_->cookie_manager_;
}
void SetURL(const std::string& url) { url_ = url; }
void Detach() { handler_ = NULL; }
private:
PopupTestHandler* handler_;
std::string url_;
IMPLEMENT_REFCOUNTING(RequestContextHandler);
};
enum Mode {
MODE_WINDOW_OPEN,
MODE_TARGETED_LINK,
@ -394,11 +244,8 @@ class PopupTestHandler : public TestHandler {
CefRequestContextSettings settings;
context_handler_ = new RequestContextHandler(this);
context_handler_->SetURL(url_);
context_ =
CefRequestContext::CreateContext(settings, context_handler_.get());
cookie_manager_ = CefCookieManager::CreateManager(CefString(), true, NULL);
context_ = CefRequestContext::CreateContext(settings, NULL);
cookie_manager_ = context_->GetCookieManager(NULL);
// Create browser that loads the 1st URL.
CreateBrowser(url_, context_);
@ -421,7 +268,6 @@ class PopupTestHandler : public TestHandler {
const std::string& url = frame->GetURL();
if (url == url_) {
got_load_end1_.yes();
context_handler_->SetURL(popup_url_);
LaunchPopup(browser);
} else if (url == popup_url_) {
got_load_end2_.yes();
@ -497,10 +343,13 @@ class PopupTestHandler : public TestHandler {
bool& deleteCookie) override {
const std::string& name = CefString(&cookie.name);
const std::string& value = CefString(&cookie.value);
if (name == "name1" && value == "value1")
if (name == "name1" && value == "value1") {
handler_->got_cookie1_.yes();
else if (name == "name2" && value == "value2")
deleteCookie = true;
} else if (name == "name2" && value == "value2") {
handler_->got_cookie2_.yes();
deleteCookie = true;
}
return true;
}
@ -514,16 +363,11 @@ class PopupTestHandler : public TestHandler {
void DestroyTest() override {
// Verify test expectations.
EXPECT_TRUE(got_get_cookie_manager1_);
EXPECT_TRUE(got_load_end1_);
EXPECT_TRUE(got_on_before_popup_);
EXPECT_TRUE(got_get_cookie_manager2_);
EXPECT_TRUE(got_load_end2_);
EXPECT_TRUE(got_cookie1_);
EXPECT_TRUE(got_cookie2_);
context_handler_->Detach();
context_handler_ = NULL;
context_ = NULL;
TestHandler::DestroyTest();
@ -534,13 +378,10 @@ class PopupTestHandler : public TestHandler {
Mode mode_;
CefRefPtr<CefRequestContext> context_;
CefRefPtr<RequestContextHandler> context_handler_;
CefRefPtr<CefCookieManager> cookie_manager_;
TrackCallback got_get_cookie_manager1_;
TrackCallback got_load_end1_;
TrackCallback got_on_before_popup_;
TrackCallback got_get_cookie_manager2_;
TrackCallback got_load_end2_;
TrackCallback got_cookie1_;
TrackCallback got_cookie2_;

259
tests/ceftests/request_handler_unittest.cc
View File

@ -60,36 +60,6 @@ class NetNotifyBrowserTest : public ClientAppBrowser::Delegate {
// Browser side.
class NetNotifyTestHandler : public TestHandler {
public:
class RequestContextHandler : public CefRequestContextHandler {
public:
explicit RequestContextHandler(NetNotifyTestHandler* handler)
: handler_(handler) {}
CefRefPtr<CefCookieManager> GetCookieManager() override {
EXPECT_TRUE(handler_);
EXPECT_TRUE(CefCurrentlyOn(TID_IO));
if (url_.find(handler_->url1_) == 0)
handler_->got_get_cookie_manager1_.yes();
else if (url_.find(handler_->url2_) == 0)
handler_->got_get_cookie_manager2_.yes();
else
EXPECT_TRUE(false); // Not reached
return handler_->cookie_manager_;
}
void SetURL(const std::string& url) { url_ = url; }
void Detach() { handler_ = NULL; }
private:
std::string url_;
NetNotifyTestHandler* handler_;
IMPLEMENT_REFCOUNTING(RequestContextHandler);
};
NetNotifyTestHandler(CompletionState* completion_state,
NetNotifyTestType test_type,
bool same_origin)
@ -106,8 +76,6 @@ class NetNotifyTestHandler : public TestHandler {
<< "nav2.html?t=" << test_type_;
url2_ = ss.str();
cookie_manager_ = CefCookieManager::CreateManager(CefString(), true, NULL);
const std::string& resource1 =
"<html>"
"<head><script>document.cookie='name1=value1';</script></head>"
@ -124,13 +92,11 @@ class NetNotifyTestHandler : public TestHandler {
response_length2_ = static_cast<int64>(resource2.size());
AddResource(url2_, resource2, "text/html");
context_handler_ = new RequestContextHandler(this);
context_handler_->SetURL(url1_);
// Create the request context that will use an in-memory cache.
CefRequestContextSettings settings;
CefRefPtr<CefRequestContext> request_context =
CefRequestContext::CreateContext(settings, context_handler_.get());
CefRequestContext::CreateContext(settings, NULL);
cookie_manager_ = request_context->GetCookieManager(NULL);
// Create browser that loads the 1st URL.
CreateBrowser(url1_, request_context);
@ -138,7 +104,6 @@ class NetNotifyTestHandler : public TestHandler {
void RunTest() override {
// Navigate to the 2nd URL.
context_handler_->SetURL(url2_);
GetBrowser()->GetMainFrame()->LoadURL(url2_);
// Time out the test after a reasonable period of time.
@ -320,10 +285,13 @@ class NetNotifyTestHandler : public TestHandler {
bool& deleteCookie) override {
const std::string& name = CefString(&cookie.name);
const std::string& value = CefString(&cookie.value);
if (name == "name1" && value == "value1")
if (name == "name1" && value == "value1") {
handler_->got_cookie1_.yes();
else if (name == "name2" && value == "value2")
deleteCookie = true;
} else if (name == "name2" && value == "value2") {
handler_->got_cookie2_.yes();
deleteCookie = true;
}
return true;
}
@ -344,7 +312,6 @@ class NetNotifyTestHandler : public TestHandler {
EXPECT_TRUE(got_before_resource_load1_) << " browser " << browser_id;
EXPECT_TRUE(got_get_resource_handler1_) << " browser " << browser_id;
EXPECT_TRUE(got_resource_load_complete1_) << " browser " << browser_id;
EXPECT_TRUE(got_get_cookie_manager1_) << " browser " << browser_id;
EXPECT_TRUE(got_cookie1_) << " browser " << browser_id;
EXPECT_TRUE(got_process_message1_) << " browser " << browser_id;
EXPECT_TRUE(got_before_browse2_) << " browser " << browser_id;
@ -352,7 +319,6 @@ class NetNotifyTestHandler : public TestHandler {
EXPECT_TRUE(got_before_resource_load2_) << " browser " << browser_id;
EXPECT_TRUE(got_get_resource_handler2_) << " browser " << browser_id;
EXPECT_TRUE(got_resource_load_complete2_) << " browser " << browser_id;
EXPECT_TRUE(got_get_cookie_manager2_) << " browser " << browser_id;
EXPECT_TRUE(got_cookie2_) << " browser " << browser_id;
EXPECT_TRUE(got_process_message2_) << " browser " << browser_id;
@ -365,8 +331,6 @@ class NetNotifyTestHandler : public TestHandler {
EXPECT_FALSE(got_before_browse2_delayed_) << " browser " << browser_id;
}
context_handler_->Detach();
context_handler_ = NULL;
cookie_manager_ = NULL;
TestHandler::DestroyTest();
@ -377,8 +341,6 @@ class NetNotifyTestHandler : public TestHandler {
std::string url1_;
std::string url2_;
CefRefPtr<RequestContextHandler> context_handler_;
CefRefPtr<CefCookieManager> cookie_manager_;
TrackCallback got_before_browse1_;
@ -386,7 +348,6 @@ class NetNotifyTestHandler : public TestHandler {
TrackCallback got_before_resource_load1_;
TrackCallback got_get_resource_handler1_;
TrackCallback got_resource_load_complete1_;
TrackCallback got_get_cookie_manager1_;
TrackCallback got_cookie1_;
TrackCallback got_process_message1_;
TrackCallback got_before_browse2_;
@ -394,7 +355,6 @@ class NetNotifyTestHandler : public TestHandler {
TrackCallback got_before_resource_load2_;
TrackCallback got_get_resource_handler2_;
TrackCallback got_resource_load_complete2_;
TrackCallback got_get_cookie_manager2_;
TrackCallback got_cookie2_;
TrackCallback got_process_message2_;
TrackCallback got_before_browse2_will_delay_;
@ -2183,45 +2143,13 @@ class CookieAccessTestHandler : public RoutingTestHandler {
BLOCK_READ = 1 << 0,
BLOCK_WRITE = 1 << 1,
BLOCK_READ_WRITE = BLOCK_READ | BLOCK_WRITE,
BLOCK_ALL = 1 << 2,
};
class RequestContextHandler : public CefRequestContextHandler {
public:
explicit RequestContextHandler(CookieAccessTestHandler* handler)
: handler_(handler) {}
CefRefPtr<CefCookieManager> GetCookieManager() override {
EXPECT_TRUE(handler_);
EXPECT_TRUE(CefCurrentlyOn(TID_IO));
handler_->got_cookie_manager_.yes();
return handler_->cookie_manager_;
}
void Detach() { handler_ = NULL; }
private:
CookieAccessTestHandler* handler_;
IMPLEMENT_REFCOUNTING(RequestContextHandler);
};
CookieAccessTestHandler(TestMode test_mode, bool server_backend)
: test_mode_(test_mode), server_backend_(server_backend) {}
void RunTest() override {
if (test_mode_ == BLOCK_ALL) {
cookie_manager_ = CefCookieManager::GetBlockingManager();
context_handler_ = new RequestContextHandler(this);
// Create a request context that uses |context_handler_|.
CefRequestContextSettings settings;
context_ =
CefRequestContext::CreateContext(settings, context_handler_.get());
} else {
cookie_manager_ = CefCookieManager::GetGlobalManager(nullptr);
}
cookie_manager_ = CefCookieManager::GetGlobalManager(nullptr);
SetTestTimeout();
CefPostTask(TID_UI,
@ -2240,128 +2168,90 @@ class CookieAccessTestHandler : public RoutingTestHandler {
cookie_manager_ = NULL;
if (context_)
context_ = NULL;
if (context_handler_) {
context_handler_->Detach();
context_handler_ = NULL;
}
// Got both network requests.
EXPECT_TRUE(data1_.got_request_);
EXPECT_TRUE(data2_.got_request_);
if (test_mode_ == BLOCK_ALL) {
EXPECT_TRUE(got_cookie_manager_);
EXPECT_FALSE(got_cookie_manager_);
// The callback to set the cookie comes before the actual storage fails.
EXPECT_TRUE(got_can_set_cookie1_);
// Always get a call to CanSetCookie for the 1st network request due to
// the network cookie.
EXPECT_TRUE(got_can_set_cookie1_);
// Always get a call to CanGetCookies for the 2nd network request due to
// the JS cookie.
EXPECT_TRUE(got_can_get_cookies2_);
if (!server_backend_) {
// The callback to set the cookie comes before the actual storage fails.
EXPECT_TRUE(data1_.got_can_set_cookie_net_);
} else {
EXPECT_FALSE(data1_.got_can_set_cookie_net_);
}
// Always get the JS cookie via JS.
EXPECT_TRUE(got_cookie_js1_);
EXPECT_TRUE(got_cookie_js2_);
EXPECT_TRUE(got_cookie_js3_);
// No cookies stored anywhere.
EXPECT_FALSE(got_can_get_cookies2_);
EXPECT_FALSE(got_cookie_js1_);
EXPECT_FALSE(got_cookie_js2_);
EXPECT_FALSE(got_cookie_js3_);
// Only get the net cookie via JS if cookie write was allowed.
if (test_mode_ & BLOCK_WRITE) {
EXPECT_FALSE(got_cookie_net1_);
EXPECT_FALSE(got_cookie_net2_);
EXPECT_FALSE(got_cookie_net3_);
EXPECT_FALSE(data1_.got_cookie_js_);
EXPECT_FALSE(data1_.got_cookie_net_);
EXPECT_FALSE(data1_.got_can_get_cookie_js_);
EXPECT_FALSE(data1_.got_can_get_cookie_net_);
EXPECT_FALSE(data1_.got_can_set_cookie_js_);
} else {
EXPECT_TRUE(got_cookie_net1_);
EXPECT_TRUE(got_cookie_net2_);
EXPECT_TRUE(got_cookie_net3_);
}
// No cookies sent for the 1st network request.
EXPECT_FALSE(data1_.got_cookie_js_);
EXPECT_FALSE(data1_.got_cookie_net_);
// 2nd network request...
if (test_mode_ & BLOCK_READ) {
// No cookies sent if reading was blocked.
EXPECT_FALSE(data2_.got_cookie_js_);
EXPECT_FALSE(data2_.got_cookie_net_);
EXPECT_FALSE(data2_.got_can_get_cookie_js_);
EXPECT_FALSE(data2_.got_can_get_cookie_net_);
EXPECT_FALSE(data2_.got_can_set_cookie_js_);
EXPECT_FALSE(data2_.got_can_set_cookie_net_);
} else if (test_mode_ & BLOCK_WRITE) {
// Only JS cookie sent if writing was blocked.
EXPECT_TRUE(data2_.got_cookie_js_);
EXPECT_FALSE(data2_.got_cookie_net_);
} else {
EXPECT_FALSE(got_cookie_manager_);
// All cookies sent.
EXPECT_TRUE(data2_.got_cookie_js_);
EXPECT_TRUE(data2_.got_cookie_net_);
}
// Always get a call to CanSetCookie for the 1st network request due to
// the network cookie.
EXPECT_TRUE(got_can_set_cookie1_);
// Always get a call to CanGetCookies for the 2nd network request due to
// the JS cookie.
EXPECT_TRUE(got_can_get_cookies2_);
if (!server_backend_) {
// No query to get cookies with the 1st network request because none
// have been set yet.
EXPECT_FALSE(data1_.got_can_get_cookie_js_);
EXPECT_FALSE(data1_.got_can_get_cookie_net_);
// Always get the JS cookie via JS.
EXPECT_TRUE(got_cookie_js1_);
EXPECT_TRUE(got_cookie_js2_);
EXPECT_TRUE(got_cookie_js3_);
// JS cookie is not set via a network request.
EXPECT_FALSE(data1_.got_can_set_cookie_js_);
EXPECT_FALSE(data2_.got_can_set_cookie_js_);
// Only get the net cookie via JS if cookie write was allowed.
// No query to set the net cookie for the 1st network request if write
// was blocked.
if (test_mode_ & BLOCK_WRITE) {
EXPECT_FALSE(got_cookie_net1_);
EXPECT_FALSE(got_cookie_net2_);
EXPECT_FALSE(got_cookie_net3_);
EXPECT_FALSE(data1_.got_can_set_cookie_net_);
} else {
EXPECT_TRUE(got_cookie_net1_);
EXPECT_TRUE(got_cookie_net2_);
EXPECT_TRUE(got_cookie_net3_);
EXPECT_TRUE(data1_.got_can_set_cookie_net_);
}
// No cookies sent for the 1st network request.
EXPECT_FALSE(data1_.got_cookie_js_);
EXPECT_FALSE(data1_.got_cookie_net_);
// Net cookie is not set via the 2nd network request.
EXPECT_FALSE(data2_.got_can_set_cookie_net_);
// 2nd network request...
// No query to get the JS cookie for the 2nd network request if read was
// blocked.
if (test_mode_ & BLOCK_READ) {
// No cookies sent if reading was blocked.
EXPECT_FALSE(data2_.got_cookie_js_);
EXPECT_FALSE(data2_.got_cookie_net_);
} else if (test_mode_ & BLOCK_WRITE) {
// Only JS cookie sent if writing was blocked.
EXPECT_TRUE(data2_.got_cookie_js_);
EXPECT_FALSE(data2_.got_cookie_net_);
EXPECT_FALSE(data2_.got_can_get_cookie_js_);
} else {
// All cookies sent.
EXPECT_TRUE(data2_.got_cookie_js_);
EXPECT_TRUE(data2_.got_cookie_net_);
EXPECT_TRUE(data2_.got_can_get_cookie_js_);
}
if (!server_backend_) {
// No query to get cookies with the 1st network request because none
// have been set yet.
EXPECT_FALSE(data1_.got_can_get_cookie_js_);
EXPECT_FALSE(data1_.got_can_get_cookie_net_);
// JS cookie is not set via a network request.
EXPECT_FALSE(data1_.got_can_set_cookie_js_);
EXPECT_FALSE(data2_.got_can_set_cookie_js_);
// No query to set the net cookie for the 1st network request if write
// was blocked.
if (test_mode_ & BLOCK_WRITE) {
EXPECT_FALSE(data1_.got_can_set_cookie_net_);
} else {
EXPECT_TRUE(data1_.got_can_set_cookie_net_);
}
// Net cookie is not set via the 2nd network request.
EXPECT_FALSE(data2_.got_can_set_cookie_net_);
// No query to get the JS cookie for the 2nd network request if read was
// blocked.
if (test_mode_ & BLOCK_READ) {
EXPECT_FALSE(data2_.got_can_get_cookie_js_);
} else {
EXPECT_TRUE(data2_.got_can_get_cookie_js_);
}
// No query to get the net cookie for the 2nd network request if read or
// write (of the net cookie) was blocked.
if (test_mode_ & (BLOCK_READ | BLOCK_WRITE)) {
EXPECT_FALSE(data2_.got_can_get_cookie_net_);
} else {
EXPECT_TRUE(data2_.got_can_get_cookie_net_);
}
// No query to get the net cookie for the 2nd network request if read or
// write (of the net cookie) was blocked.
if (test_mode_ & (BLOCK_READ | BLOCK_WRITE)) {
EXPECT_FALSE(data2_.got_can_get_cookie_net_);
} else {
EXPECT_TRUE(data2_.got_can_get_cookie_net_);
}
}
@ -2581,7 +2471,6 @@ class CookieAccessTestHandler : public RoutingTestHandler {
TestMode test_mode_;
bool server_backend_;
CefRefPtr<RequestContextHandler> context_handler_;
CefRefPtr<CefRequestContext> context_;
CefRefPtr<CefCookieManager> cookie_manager_;
@ -2645,14 +2534,6 @@ TEST(RequestHandlerTest, CookieAccessServerBlockReadWrite) {
ReleaseAndWaitForDestructor(handler);
}
// Block all cookies with server backend.
TEST(RequestHandlerTest, CookieAccessServerBlockAll) {
CefRefPtr<CookieAccessTestHandler> handler =
new CookieAccessTestHandler(CookieAccessTestHandler::BLOCK_ALL, true);
handler->ExecuteTest();
ReleaseAndWaitForDestructor(handler);
}
// Allow reading and writing of cookies with scheme handler backend.
TEST(RequestHandlerTest, CookieAccessSchemeAllow) {
CefRefPtr<CookieAccessTestHandler> handler =
@ -2685,14 +2566,6 @@ TEST(RequestHandlerTest, CookieAccessSchemeBlockReadWrite) {
ReleaseAndWaitForDestructor(handler);
}
// Block all cookies with scheme handler backend.
TEST(RequestHandlerTest, CookieAccessSchemeBlockAll) {
CefRefPtr<CookieAccessTestHandler> handler =
new CookieAccessTestHandler(CookieAccessTestHandler::BLOCK_ALL, false);
handler->ExecuteTest();
ReleaseAndWaitForDestructor(handler);
}
// Entry point for creating request handler browser test objects.
// Called from client_app_delegates.cc.
void CreateRequestHandlerBrowserTests(

6
tests/ceftests/urlrequest_unittest.cc
View File

@ -343,7 +343,7 @@ void SetTestCookie(CefRefPtr<CefRequestContext> request_context,
CefString(&cookie.domain) = GetRequestHost(server_backend, false);
CefString(&cookie.path) = "/";
cookie.has_expires = false;
EXPECT_TRUE(request_context->GetDefaultCookieManager(NULL)->SetCookie(
EXPECT_TRUE(request_context->GetCookieManager(NULL)->SetCookie(
GetRequestOrigin(server_backend), cookie, new Callback(callback)));
}
@ -383,7 +383,7 @@ void GetTestCookie(CefRefPtr<CefRequestContext> request_context,
};
CefRefPtr<CefCookieManager> cookie_manager =
request_context->GetDefaultCookieManager(NULL);
request_context->GetCookieManager(NULL);
cookie_manager->VisitUrlCookies(GetRequestOrigin(server_backend), true,
new Visitor(callback));
}
@ -2183,7 +2183,7 @@ class RequestTestHandler : public TestHandler {
supported_schemes.push_back(GetRequestScheme(false));
// Continue the test once supported schemes has been set.
request_context->GetDefaultCookieManager(NULL)->SetSupportedSchemes(
request_context->GetCookieManager(NULL)->SetSupportedSchemes(
supported_schemes,
new SupportedSchemesCompletionCallback(
base::Bind(&RequestTestHandler::PreSetupComplete, this)));

1
tests/shared/common/client_switches.cc
View File

@ -30,7 +30,6 @@ const char kExternalBeginFrameEnabled[] = "external-begin-frame-enabled";
const char kMouseCursorChangeDisabled[] = "mouse-cursor-change-disabled";
const char kRequestContextPerBrowser[] = "request-context-per-browser";
const char kRequestContextSharedCache[] = "request-context-shared-cache";
const char kRequestContextBlockCookies[] = "request-context-block-cookies";
const char kBackgroundColor[] = "background-color";
const char kEnableGPU[] = "enable-gpu";
const char kFilterURL[] = "filter-url";

1
tests/shared/common/client_switches.h
View File

@ -24,7 +24,6 @@ extern const char kExternalBeginFrameEnabled[];
extern const char kMouseCursorChangeDisabled[];
extern const char kRequestContextPerBrowser[];
extern const char kRequestContextSharedCache[];
extern const char kRequestContextBlockCookies[];
extern const char kBackgroundColor[];
extern const char kEnableGPU[];
extern const char kFilterURL[];