bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-02-13 02:20:45 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge revision 1098 changes:

Browse Source 
- Add the ability to persist session cookies (issue #881).

git-svn-id: https://chromiumembedded.googlecode.com/svn/branches/1364@1099 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt 2013-02-13 19:54:19 +00:00
parent 1f9f57722a
commit a038925a77
23 changed files with 489 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cef3/cef_paths.gypi
View File

@ -126,6 +126,8 @@
'libcef_dll/ctocpp/client_ctocpp.h',
'libcef_dll/cpptoc/command_line_cpptoc.cc',
'libcef_dll/cpptoc/command_line_cpptoc.h',
'libcef_dll/ctocpp/completion_handler_ctocpp.cc',
'libcef_dll/ctocpp/completion_handler_ctocpp.h',
'libcef_dll/ctocpp/context_menu_handler_ctocpp.cc',
'libcef_dll/ctocpp/context_menu_handler_ctocpp.h',
'libcef_dll/cpptoc/context_menu_params_cpptoc.cc',
@ -276,6 +278,8 @@
'libcef_dll/cpptoc/client_cpptoc.h',
'libcef_dll/ctocpp/command_line_ctocpp.cc',
'libcef_dll/ctocpp/command_line_ctocpp.h',
'libcef_dll/cpptoc/completion_handler_cpptoc.cc',
'libcef_dll/cpptoc/completion_handler_cpptoc.h',
'libcef_dll/cpptoc/context_menu_handler_cpptoc.cc',
'libcef_dll/cpptoc/context_menu_handler_cpptoc.h',
'libcef_dll/ctocpp/context_menu_params_ctocpp.cc',

16
cef3/include/capi/cef_callback_capi.h
View File

@ -66,6 +66,22 @@ typedef struct _cef_callback_t {
} cef_callback_t;
///
// Generic callback structure used for asynchronous completion.
///
typedef struct _cef_completion_handler_t {
///
// Base structure.
///
cef_base_t base;
///
// Method that will be called once the task is complete.
///
void (CEF_CALLBACK *on_complete)(struct _cef_completion_handler_t* self);
} cef_completion_handler_t;
#ifdef __cplusplus
}
#endif

26
cef3/include/capi/cef_cookie_capi.h
View File

@ -106,11 +106,23 @@ typedef struct _cef_cookie_manager_t {
///
// Sets the directory path that will be used for storing cookie data. If
// |path| is NULL data will be stored in memory only. Returns false (0) if
// cookies cannot be accessed.
// |path| is NULL data will be stored in memory only. Otherwise, data will be
// stored at the specified |path|. To persist session cookies (cookies without
// an expiry date or validity interval) set |persist_session_cookies| to true
// (1). Session cookies are generally intended to be transient and most Web
// browsers do not persist them. Returns false (0) if cookies cannot be
// accessed.
///
int (CEF_CALLBACK *set_storage_path)(struct _cef_cookie_manager_t* self,
const cef_string_t* path);
const cef_string_t* path, int persist_session_cookies);
///
// Flush the backing store (if any) to disk and execute the specified
// |handler| on the IO thread when done. Returns false (0) if cookies cannot
// be accessed.
///
int (CEF_CALLBACK *flush_store)(struct _cef_cookie_manager_t* self,
struct _cef_completion_handler_t* handler);
} cef_cookie_manager_t;
@ -122,10 +134,14 @@ CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_get_global_manager();
///
// Creates a new cookie manager. If |path| is NULL data will be stored in memory
// only. Returns NULL if creation fails.
// only. Otherwise, data will be stored at the specified |path|. To persist
// session cookies (cookies without an expiry date or validity interval) set
// |persist_session_cookies| to true (1). Session cookies are generally intended
// to be transient and most Web browsers do not persist them. Returns NULL if
// creation fails.
///
CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_create_manager(
const cef_string_t* path);
const cef_string_t* path, int persist_session_cookies);
///

13
cef3/include/cef_callback.h
View File

@ -59,4 +59,17 @@ class CefCallback : public virtual CefBase {
virtual void Cancel() =0;
};
///
// Generic callback interface used for asynchronous completion.
///
/*--cef(source=client)--*/
class CefCompletionHandler : public virtual CefBase {
public:
///
// Method that will be called once the task is complete.
///
/*--cef()--*/
virtual void OnComplete() =0;
};
#endif // CEF_INCLUDE_CEF_CALLBACK_H_

29
cef3/include/cef_cookie.h
View File

@ -39,6 +39,7 @@
#pragma once
#include "include/cef_base.h"
#include "include/cef_callback.h"
#include <vector>
class CefCookieVisitor;
@ -60,10 +61,16 @@ class CefCookieManager : public virtual CefBase {
///
// Creates a new cookie manager. If |path| is empty data will be stored in
// memory only. Returns NULL if creation fails.
// memory only. Otherwise, data will be stored at the specified |path|. To
// persist session cookies (cookies without an expiry date or validity
// interval) set |persist_session_cookies| to true. Session cookies are
// generally intended to be transient and most Web browsers do not persist
// them. Returns NULL if creation fails.
///
/*--cef(optional_param=path)--*/
static CefRefPtr<CefCookieManager> CreateManager(const CefString& path);
static CefRefPtr<CefCookieManager> CreateManager(
const CefString& path,
bool persist_session_cookies);
///
// Set the schemes supported by this manager. By default only "http" and
@ -117,11 +124,23 @@ class CefCookieManager : public virtual CefBase {
///
// Sets the directory path that will be used for storing cookie data. If
// |path| is empty data will be stored in memory only. Returns false if
// cookies cannot be accessed.
// |path| is empty data will be stored in memory only. Otherwise, data will be
// stored at the specified |path|. To persist session cookies (cookies without
// an expiry date or validity interval) set |persist_session_cookies| to true.
// Session cookies are generally intended to be transient and most Web browsers
// do not persist them. Returns false if cookies cannot be accessed.
///
/*--cef(optional_param=path)--*/
virtual bool SetStoragePath(const CefString& path) =0;
virtual bool SetStoragePath(const CefString& path,
bool persist_session_cookies) =0;
///
// Flush the backing store (if any) to disk and execute the specified
// |handler| on the IO thread when done. Returns false if cookies cannot be
// accessed.
///
/*--cef(optional_param=handler)--*/
virtual bool FlushStore(CefRefPtr<CefCompletionHandler> handler) =0;
};

10
cef3/include/internal/cef_types.h
View File

@ -197,6 +197,16 @@ typedef struct _cef_settings_t {
///
cef_string_t cache_path;
///
// To persist session cookies (cookies without an expiry date or validity
// interval) by default when using the global cookie manager set this value to
// true. Session cookies are generally intended to be transient and most Web
// browsers do not persist them. A |cache_path| value must also be specified to
// enable this feature. Also configurable using the "persist-session-cookies"
// command-line switch.
///
bool persist_session_cookies;
///
// Value that will be returned as the User-Agent HTTP header. If empty the
// default User-Agent string will be used. Also configurable using the

2
cef3/include/internal/cef_types_wrappers.h
View File

@ -298,6 +298,8 @@ struct CefSettingsTraits {
cef_string_set(src->cache_path.str, src->cache_path.length,
&target->cache_path, copy);
target->persist_session_cookies = src->persist_session_cookies;
cef_string_set(src->user_agent.str, src->user_agent.length,
&target->user_agent, copy);
cef_string_set(src->product_version.str, src->product_version.length,

57
cef3/libcef/browser/cookie_manager_impl.cc
View File

@ -77,6 +77,11 @@ bool GetCookieDomain(const GURL& url,
result);
}
void RunCompletionOnIOThread(CefRefPtr<CefCompletionHandler> handler) {
CEF_POST_TASK(CEF_IOT,
base::Bind(&CefCompletionHandler::OnComplete, handler.get()));
}
} // namespace
@ -87,11 +92,13 @@ CefCookieManagerImpl::CefCookieManagerImpl(bool is_global)
CefCookieManagerImpl::~CefCookieManagerImpl() {
}
void CefCookieManagerImpl::Initialize(const CefString& path) {
void CefCookieManagerImpl::Initialize(
const CefString& path,
bool persist_session_cookies) {
if (is_global_)
SetGlobal();
else
SetStoragePath(path);
SetStoragePath(path, persist_session_cookies);
}
void CefCookieManagerImpl::SetSupportedSchemes(
@ -245,7 +252,9 @@ bool CefCookieManagerImpl::DeleteCookies(const CefString& url,
return true;
}
bool CefCookieManagerImpl::SetStoragePath(const CefString& path) {
bool CefCookieManagerImpl::SetStoragePath(
const CefString& path,
bool persist_session_cookies) {
if (CEF_CURRENTLY_ON_IOT()) {
FilePath new_path;
if (!path.empty())
@ -256,7 +265,7 @@ bool CefCookieManagerImpl::SetStoragePath(const CefString& path) {
CefURLRequestContextGetter* getter =
static_cast<CefURLRequestContextGetter*>(
_Context->browser_context()->GetRequestContext());
getter->SetCookieStoragePath(new_path);
getter->SetCookieStoragePath(new_path, persist_session_cookies);
cookie_monster_ = getter->GetURLRequestContext()->cookie_store()->
GetCookieMonster();
return true;
@ -277,7 +286,9 @@ bool CefCookieManagerImpl::SetStoragePath(const CefString& path) {
file_util::CreateDirectory(new_path)) {
const FilePath& cookie_path = new_path.AppendASCII("Cookies");
persistent_store =
new SQLitePersistentCookieStore(cookie_path, false, NULL);
new SQLitePersistentCookieStore(cookie_path,
persist_session_cookies,
NULL);
} else {
NOTREACHED() << "The cookie storage directory could not be created";
storage_path_.clear();
@ -288,6 +299,8 @@ bool CefCookieManagerImpl::SetStoragePath(const CefString& path) {
// cookie store, if any, will be automatically flushed and closed when no
// longer referenced.
cookie_monster_ = new net::CookieMonster(persistent_store.get(), NULL);
if (persistent_store.get() && persist_session_cookies)
cookie_monster_->SetPersistSessionCookies(true);
storage_path_ = new_path;
// Restore the previously supported schemes.
@ -296,7 +309,32 @@ bool CefCookieManagerImpl::SetStoragePath(const CefString& path) {
// Execute on the IO thread.
CEF_POST_TASK(CEF_IOT,
base::Bind(base::IgnoreResult(&CefCookieManagerImpl::SetStoragePath),
this, path));
this, path, persist_session_cookies));
}
return true;
}
bool CefCookieManagerImpl::FlushStore(CefRefPtr<CefCompletionHandler> handler) {
if (CEF_CURRENTLY_ON_IOT()) {
if (!cookie_monster_) {
if (handler.get())
RunCompletionOnIOThread(handler);
return true;
}
base::Closure callback;
if (handler.get())
callback = base::Bind(RunCompletionOnIOThread, handler);
else
callback = base::Bind(&base::DoNothing);
cookie_monster_->FlushStore(callback);
} else {
// Execute on the IO thread.
CEF_POST_TASK(CEF_IOT,
base::Bind(base::IgnoreResult(&CefCookieManagerImpl::FlushStore),
this, handler));
}
return true;
@ -378,13 +416,14 @@ CefRefPtr<CefCookieManager> CefCookieManager::GetGlobalManager() {
}
CefRefPtr<CefCookieManagerImpl> manager(new CefCookieManagerImpl(true));
manager->Initialize(CefString());
manager->Initialize(CefString(), false);
return manager.get();
}
// static
CefRefPtr<CefCookieManager> CefCookieManager::CreateManager(
const CefString& path) {
const CefString& path,
bool persist_session_cookies) {
// Verify that the context is in a valid state.
if (!CONTEXT_STATE_VALID()) {
NOTREACHED() << "context not valid";
@ -392,6 +431,6 @@ CefRefPtr<CefCookieManager> CefCookieManager::CreateManager(
}
CefRefPtr<CefCookieManagerImpl> manager(new CefCookieManagerImpl(false));
manager->Initialize(path);
manager->Initialize(path, persist_session_cookies);
return manager.get();
}

7
cef3/libcef/browser/cookie_manager_impl.h
View File

@ -16,7 +16,8 @@ class CefCookieManagerImpl : public CefCookieManager {
~CefCookieManagerImpl();
// Initialize the cookie manager.
void Initialize(const CefString& path);
void Initialize(const CefString& path,
bool persist_session_cookies);
// CefCookieManager methods.
virtual void SetSupportedSchemes(const std::vector<CefString>& schemes)
@ -28,7 +29,9 @@ class CefCookieManagerImpl : public CefCookieManager {
const CefCookie& cookie) OVERRIDE;
virtual bool DeleteCookies(const CefString& url,
const CefString& cookie_name) OVERRIDE;
virtual bool SetStoragePath(const CefString& path) OVERRIDE;
virtual bool SetStoragePath(const CefString& path,
bool persist_session_cookies) OVERRIDE;
virtual bool FlushStore(CefRefPtr<CefCompletionHandler> handler) OVERRIDE;
net::CookieMonster* cookie_monster() { return cookie_monster_; }

22
cef3/libcef/browser/url_request_context_getter.cc
View File

@ -15,6 +15,7 @@
#include "libcef/browser/url_network_delegate.h"
#include "libcef/browser/url_request_context_proxy.h"
#include "libcef/browser/url_request_interceptor.h"
#include "libcef/common/cef_switches.h"
#include "base/command_line.h"
#include "base/file_util.h"
@ -75,12 +76,16 @@ net::URLRequestContext* CefURLRequestContextGetter::GetURLRequestContext() {
if (!url_request_context_.get()) {
const FilePath& cache_path = _Context->cache_path();
const CommandLine& command_line = *CommandLine::ForCurrentProcess();
const CefSettings& settings = _Context->settings();
url_request_context_.reset(new net::URLRequestContext());
storage_.reset(
new net::URLRequestContextStorage(url_request_context_.get()));
SetCookieStoragePath(cache_path);
bool persist_session_cookies =
(settings.persist_session_cookies ||
command_line.HasSwitch(switches::kPersistSessionCookies));
SetCookieStoragePath(cache_path, persist_session_cookies);
storage_->set_network_delegate(new CefNetworkDelegate);
@ -176,7 +181,9 @@ net::HostResolver* CefURLRequestContextGetter::host_resolver() {
return url_request_context_->host_resolver();
}
void CefURLRequestContextGetter::SetCookieStoragePath(const FilePath& path) {
void CefURLRequestContextGetter::SetCookieStoragePath(
const FilePath& path,
bool persist_session_cookies) {
CEF_REQUIRE_IOT();
if (url_request_context_->cookie_store() &&
@ -195,7 +202,9 @@ void CefURLRequestContextGetter::SetCookieStoragePath(const FilePath& path) {
file_util::CreateDirectory(path)) {
const FilePath& cookie_path = path.AppendASCII("Cookies");
persistent_store =
new SQLitePersistentCookieStore(cookie_path, false, NULL);
new SQLitePersistentCookieStore(cookie_path,
persist_session_cookies,
NULL);
} else {
NOTREACHED() << "The cookie storage directory could not be created";
}
@ -204,8 +213,11 @@ void CefURLRequestContextGetter::SetCookieStoragePath(const FilePath& path) {
// Set the new cookie store that will be used for all new requests. The old
// cookie store, if any, will be automatically flushed and closed when no
// longer referenced.
storage_->set_cookie_store(
new net::CookieMonster(persistent_store.get(), NULL));
scoped_refptr<net::CookieMonster> cookie_monster =
new net::CookieMonster(persistent_store.get(), NULL);
storage_->set_cookie_store(cookie_monster);
if (persistent_store.get() && persist_session_cookies)
cookie_monster->SetPersistSessionCookies(true);
cookie_store_path_ = path;
// Restore the previously supported schemes.

3
cef3/libcef/browser/url_request_context_getter.h
View File

@ -85,7 +85,8 @@ class CefURLRequestContextGetter : public net::URLRequestContextGetter {
net::HostResolver* host_resolver();
void SetCookieStoragePath(const FilePath& path);
void SetCookieStoragePath(const FilePath& path,
bool persist_session_cookies);
void SetCookieSupportedSchemes(const std::vector<std::string>& schemes);
// Manage URLRequestContext proxy objects. It's important that proxy objects

3
cef3/libcef/common/cef_switches.cc
View File

@ -83,4 +83,7 @@ const char kDisableAuthorAndUserStyles[] = "disable-author-and-user-styles";
// Disable developer tools (WebKit Inspector).
const char kDisableDeveloperTools[] = "disable-developer-tools";
// Persist session cookies.
const char kPersistSessionCookies[] = "persist-session-cookies";
} // namespace switches

1
cef3/libcef/common/cef_switches.h
View File

@ -38,6 +38,7 @@ extern const char kDisableTextAreaResize[];
extern const char kDisableTabToLinks[];
extern const char kDisableAuthorAndUserStyles[];
extern const char kDisableDeveloperTools[];
extern const char kPersistSessionCookies[];
} // namespace switches

44
cef3/libcef_dll/cpptoc/completion_handler_cpptoc.cc Normal file
View File

@ -0,0 +1,44 @@
// Copyright (c) 2013 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.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
#include "libcef_dll/cpptoc/completion_handler_cpptoc.h"
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK completion_handler_on_complete(
struct _cef_completion_handler_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
if (!self)
return;
// Execute
CefCompletionHandlerCppToC::Get(self)->OnComplete();
}
// CONSTRUCTOR - Do not edit by hand.
CefCompletionHandlerCppToC::CefCompletionHandlerCppToC(
CefCompletionHandler* cls)
: CefCppToC<CefCompletionHandlerCppToC, CefCompletionHandler,
cef_completion_handler_t>(cls) {
struct_.struct_.on_complete = completion_handler_on_complete;
}
#ifndef NDEBUG
template<> long CefCppToC<CefCompletionHandlerCppToC, CefCompletionHandler,
cef_completion_handler_t>::DebugObjCt = 0;
#endif

37
cef3/libcef_dll/cpptoc/completion_handler_cpptoc.h Normal file
View File

@ -0,0 +1,37 @@
// Copyright (c) 2013 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.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
#ifndef CEF_LIBCEF_DLL_CPPTOC_COMPLETION_HANDLER_CPPTOC_H_
#define CEF_LIBCEF_DLL_CPPTOC_COMPLETION_HANDLER_CPPTOC_H_
#pragma once
#ifndef USING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed wrapper-side only")
#else // USING_CEF_SHARED
#include "include/cef_callback.h"
#include "include/capi/cef_callback_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefCompletionHandlerCppToC
: public CefCppToC<CefCompletionHandlerCppToC, CefCompletionHandler,
cef_completion_handler_t> {
public:
explicit CefCompletionHandlerCppToC(CefCompletionHandler* cls);
virtual ~CefCompletionHandlerCppToC() {}
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_COMPLETION_HANDLER_CPPTOC_H_

30
cef3/libcef_dll/cpptoc/cookie_manager_cpptoc.cc
View File

@ -11,6 +11,7 @@
//
#include "libcef_dll/cpptoc/cookie_manager_cpptoc.h"
#include "libcef_dll/ctocpp/completion_handler_ctocpp.h"
#include "libcef_dll/ctocpp/cookie_visitor_ctocpp.h"
#include "libcef_dll/transfer_util.h"
@ -28,14 +29,15 @@ CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_get_global_manager() {
}
CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_create_manager(
const cef_string_t* path) {
const cef_string_t* path, int persist_session_cookies) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Unverified params: path
// Execute
CefRefPtr<CefCookieManager> _retval = CefCookieManager::CreateManager(
CefString(path));
CefString(path),
persist_session_cookies?true:false);
// Return type: refptr_same
return CefCookieManagerCppToC::Wrap(_retval);
@ -163,7 +165,8 @@ int CEF_CALLBACK cookie_manager_delete_cookies(
}
int CEF_CALLBACK cookie_manager_set_storage_path(
struct _cef_cookie_manager_t* self, const cef_string_t* path) {
struct _cef_cookie_manager_t* self, const cef_string_t* path,
int persist_session_cookies) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
@ -173,7 +176,25 @@ int CEF_CALLBACK cookie_manager_set_storage_path(
// Execute
bool _retval = CefCookieManagerCppToC::Get(self)->SetStoragePath(
CefString(path));
CefString(path),
persist_session_cookies?true:false);
// Return type: bool
return _retval;
}
int CEF_CALLBACK cookie_manager_flush_store(struct _cef_cookie_manager_t* self,
cef_completion_handler_t* handler) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
if (!self)
return 0;
// Unverified params: handler
// Execute
bool _retval = CefCookieManagerCppToC::Get(self)->FlushStore(
CefCompletionHandlerCToCpp::Wrap(handler));
// Return type: bool
return _retval;
@ -191,6 +212,7 @@ CefCookieManagerCppToC::CefCookieManagerCppToC(CefCookieManager* cls)
struct_.struct_.set_cookie = cookie_manager_set_cookie;
struct_.struct_.delete_cookies = cookie_manager_delete_cookies;
struct_.struct_.set_storage_path = cookie_manager_set_storage_path;
struct_.struct_.flush_store = cookie_manager_flush_store;
}
#ifndef NDEBUG

33
cef3/libcef_dll/ctocpp/completion_handler_ctocpp.cc Normal file
View File

@ -0,0 +1,33 @@
// Copyright (c) 2013 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.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
#include "libcef_dll/ctocpp/completion_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
void CefCompletionHandlerCToCpp::OnComplete() {
if (CEF_MEMBER_MISSING(struct_, on_complete))
return;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Execute
struct_->on_complete(struct_);
}
#ifndef NDEBUG
template<> long CefCToCpp<CefCompletionHandlerCToCpp, CefCompletionHandler,
cef_completion_handler_t>::DebugObjCt = 0;
#endif

42
cef3/libcef_dll/ctocpp/completion_handler_ctocpp.h Normal file
View File

@ -0,0 +1,42 @@
// Copyright (c) 2013 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.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
#ifndef CEF_LIBCEF_DLL_CTOCPP_COMPLETION_HANDLER_CTOCPP_H_
#define CEF_LIBCEF_DLL_CTOCPP_COMPLETION_HANDLER_CTOCPP_H_
#pragma once
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef_callback.h"
#include "include/capi/cef_callback_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefCompletionHandlerCToCpp
: public CefCToCpp<CefCompletionHandlerCToCpp, CefCompletionHandler,
cef_completion_handler_t> {
public:
explicit CefCompletionHandlerCToCpp(cef_completion_handler_t* str)
: CefCToCpp<CefCompletionHandlerCToCpp, CefCompletionHandler,
cef_completion_handler_t>(str) {}
virtual ~CefCompletionHandlerCToCpp() {}
// CefCompletionHandler methods
virtual void OnComplete() OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CTOCPP_COMPLETION_HANDLER_CTOCPP_H_

29
cef3/libcef_dll/ctocpp/cookie_manager_ctocpp.cc
View File

@ -10,6 +10,7 @@
// for more information.
//
#include "libcef_dll/cpptoc/completion_handler_cpptoc.h"
#include "libcef_dll/cpptoc/cookie_visitor_cpptoc.h"
#include "libcef_dll/ctocpp/cookie_manager_ctocpp.h"
#include "libcef_dll/transfer_util.h"
@ -28,14 +29,15 @@ CefRefPtr<CefCookieManager> CefCookieManager::GetGlobalManager() {
}
CefRefPtr<CefCookieManager> CefCookieManager::CreateManager(
const CefString& path) {
const CefString& path, bool persist_session_cookies) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Unverified params: path
// Execute
cef_cookie_manager_t* _retval = cef_cookie_manager_create_manager(
path.GetStruct());
path.GetStruct(),
persist_session_cookies);
// Return type: refptr_same
return CefCookieManagerCToCpp::Wrap(_retval);
@ -151,7 +153,8 @@ bool CefCookieManagerCToCpp::DeleteCookies(const CefString& url,
return _retval?true:false;
}
bool CefCookieManagerCToCpp::SetStoragePath(const CefString& path) {
bool CefCookieManagerCToCpp::SetStoragePath(const CefString& path,
bool persist_session_cookies) {
if (CEF_MEMBER_MISSING(struct_, set_storage_path))
return false;
@ -161,7 +164,25 @@ bool CefCookieManagerCToCpp::SetStoragePath(const CefString& path) {
// Execute
int _retval = struct_->set_storage_path(struct_,
path.GetStruct());
path.GetStruct(),
persist_session_cookies);
// Return type: bool
return _retval?true:false;
}
bool CefCookieManagerCToCpp::FlushStore(
CefRefPtr<CefCompletionHandler> handler) {
if (CEF_MEMBER_MISSING(struct_, flush_store))
return false;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Unverified params: handler
// Execute
int _retval = struct_->flush_store(struct_,
CefCompletionHandlerCppToC::Wrap(handler));
// Return type: bool
return _retval?true:false;

4
cef3/libcef_dll/ctocpp/cookie_manager_ctocpp.h
View File

@ -44,7 +44,9 @@ class CefCookieManagerCToCpp
const CefCookie& cookie) OVERRIDE;
virtual bool DeleteCookies(const CefString& url,
const CefString& cookie_name) OVERRIDE;
virtual bool SetStoragePath(const CefString& path) OVERRIDE;
virtual bool SetStoragePath(const CefString& path,
bool persist_session_cookies) OVERRIDE;
virtual bool FlushStore(CefRefPtr<CefCompletionHandler> handler) OVERRIDE;
};
#endif // USING_CEF_SHARED

2
cef3/libcef_dll/libcef_dll.cc
View File

@ -70,6 +70,7 @@
#include "libcef_dll/cpptoc/zip_reader_cpptoc.h"
#include "libcef_dll/ctocpp/app_ctocpp.h"
#include "libcef_dll/ctocpp/browser_process_handler_ctocpp.h"
#include "libcef_dll/ctocpp/completion_handler_ctocpp.h"
#include "libcef_dll/ctocpp/context_menu_handler_ctocpp.h"
#include "libcef_dll/ctocpp/cookie_visitor_ctocpp.h"
#include "libcef_dll/ctocpp/domevent_listener_ctocpp.h"
@ -177,6 +178,7 @@ CEF_EXPORT void cef_shutdown() {
DCHECK_EQ(CefBrowserHostCppToC::DebugObjCt, 0);
DCHECK_EQ(CefBrowserProcessHandlerCToCpp::DebugObjCt, 0);
DCHECK_EQ(CefCallbackCppToC::DebugObjCt, 0);
DCHECK_EQ(CefCompletionHandlerCToCpp::DebugObjCt, 0);
DCHECK_EQ(CefContextMenuHandlerCToCpp::DebugObjCt, 0);
DCHECK_EQ(CefContextMenuParamsCppToC::DebugObjCt, 0);
DCHECK_EQ(CefCookieManagerCppToC::DebugObjCt, 0);

2
cef3/libcef_dll/wrapper/libcef_dll_wrapper.cc
View File

@ -35,6 +35,7 @@
#include "include/cef_version.h"
#include "libcef_dll/cpptoc/app_cpptoc.h"
#include "libcef_dll/cpptoc/browser_process_handler_cpptoc.h"
#include "libcef_dll/cpptoc/completion_handler_cpptoc.h"
#include "libcef_dll/cpptoc/context_menu_handler_cpptoc.h"
#include "libcef_dll/cpptoc/cookie_visitor_cpptoc.h"
#include "libcef_dll/cpptoc/domevent_listener_cpptoc.h"
@ -169,6 +170,7 @@ CEF_GLOBAL void CefShutdown() {
DCHECK_EQ(CefBrowserHostCToCpp::DebugObjCt, 0);
DCHECK_EQ(CefBrowserProcessHandlerCppToC::DebugObjCt, 0);
DCHECK_EQ(CefCallbackCToCpp::DebugObjCt, 0);
DCHECK_EQ(CefCompletionHandlerCppToC::DebugObjCt, 0);
DCHECK_EQ(CefContextMenuHandlerCppToC::DebugObjCt, 0);
DCHECK_EQ(CefContextMenuParamsCToCpp::DebugObjCt, 0);
DCHECK_EQ(CefCookieManagerCToCpp::DebugObjCt, 0);

135
cef3/tests/unittests/cookie_unittest.cc
View File

@ -85,17 +85,20 @@ void DeleteCookies(CefRefPtr<CefCookieManager> manager,
// created, otherwise a host cookie will be created.
void CreateCookie(CefRefPtr<CefCookieManager> manager,
CefCookie& cookie, bool withDomain,
bool sessionCookie,
base::WaitableEvent& event) {
CefString(&cookie.name).FromASCII("my_cookie");
CefString(&cookie.value).FromASCII("My Value");
if (withDomain)
CefString(&cookie.domain).FromASCII(kTestDomain);
CefString(&cookie.path).FromASCII(kTestPath);
cookie.has_expires = true;
cookie.expires.year = 2200;
cookie.expires.month = 4;
cookie.expires.day_of_week = 5;
cookie.expires.day_of_month = 11;
if (!sessionCookie) {
cookie.has_expires = true;
cookie.expires.year = 2200;
cookie.expires.month = 4;
cookie.expires.day_of_week = 5;
cookie.expires.day_of_month = 11;
}
CookieVector cookies;
cookies.push_back(cookie);
@ -126,7 +129,7 @@ void GetCookie(CefRefPtr<CefCookieManager> manager,
else
EXPECT_EQ(CefString(&cookie_read.domain), kTestDomain);
EXPECT_EQ(CefString(&cookie_read.path), kTestPath);
EXPECT_TRUE(cookie_read.has_expires);
EXPECT_EQ(cookie.has_expires, cookie_read.has_expires);
EXPECT_EQ(cookie.expires.year, cookie_read.expires.year);
EXPECT_EQ(cookie.expires.month, cookie_read.expires.month);
EXPECT_EQ(cookie.expires.day_of_week, cookie_read.expires.day_of_week);
@ -191,7 +194,7 @@ void TestDomainCookie(CefRefPtr<CefCookieManager> manager) {
CefCookie cookie;
// Create a domain cookie.
CreateCookie(manager, cookie, true, event);
CreateCookie(manager, cookie, true, false, event);
// Retrieve, verify and delete the domain cookie.
GetCookie(manager, cookie, true, event, true);
@ -205,7 +208,7 @@ void TestHostCookie(CefRefPtr<CefCookieManager> manager) {
CefCookie cookie;
// Create a host cookie.
CreateCookie(manager, cookie, false, event);
CreateCookie(manager, cookie, false, false, event);
// Retrieve, verify and delete the host cookie.
GetCookie(manager, cookie, false, event, true);
@ -388,7 +391,7 @@ void TestChangeDirectory(CefRefPtr<CefCookieManager> manager,
DeleteAllCookies(manager, event);
// Set the new temporary directory as the storage location.
EXPECT_TRUE(manager->SetStoragePath(temp_dir.path().value()));
EXPECT_TRUE(manager->SetStoragePath(temp_dir.path().value(), false));
// Wait for the storage location change to complete on the IO thread.
WaitForIOThread();
@ -397,13 +400,13 @@ void TestChangeDirectory(CefRefPtr<CefCookieManager> manager,
VerifyNoCookies(manager, event, true);
// Create a domain cookie.
CreateCookie(manager, cookie, true, event);
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));
EXPECT_TRUE(manager->SetStoragePath(original_dir, false));
// Wait for the storage location change to complete on the IO thread.
WaitForIOThread();
@ -412,7 +415,7 @@ void TestChangeDirectory(CefRefPtr<CefCookieManager> manager,
VerifyNoCookies(manager, event, true);
// Set the new temporary directory as the storage location.
EXPECT_TRUE(manager->SetStoragePath(temp_dir.path().value()));
EXPECT_TRUE(manager->SetStoragePath(temp_dir.path().value(), false));
// Wait for the storage location change to complete on the IO thread.
WaitForIOThread();
@ -421,7 +424,7 @@ void TestChangeDirectory(CefRefPtr<CefCookieManager> manager,
GetCookie(manager, cookie, true, event, false);
// Restore the original storage location.
EXPECT_TRUE(manager->SetStoragePath(original_dir));
EXPECT_TRUE(manager->SetStoragePath(original_dir, false));
// Wait for the storage location change to complete on the IO thread.
WaitForIOThread();
@ -440,7 +443,7 @@ TEST(CookieTest, DomainCookieGlobal) {
// Test creation of a domain cookie.
TEST(CookieTest, DomainCookieInMemory) {
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(CefString());
CefCookieManager::CreateManager(CefString(), false);
EXPECT_TRUE(manager.get());
TestDomainCookie(manager);
@ -454,7 +457,7 @@ TEST(CookieTest, DomainCookieOnDisk) {
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(temp_dir.path().value());
CefCookieManager::CreateManager(temp_dir.path().value(), false);
EXPECT_TRUE(manager.get());
TestDomainCookie(manager);
@ -471,7 +474,7 @@ TEST(CookieTest, HostCookieGlobal) {
// Test creation of a host cookie.
TEST(CookieTest, HostCookieInMemory) {
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(CefString());
CefCookieManager::CreateManager(CefString(), false);
EXPECT_TRUE(manager.get());
TestHostCookie(manager);
@ -485,7 +488,7 @@ TEST(CookieTest, HostCookieOnDisk) {
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(temp_dir.path().value());
CefCookieManager::CreateManager(temp_dir.path().value(), false);
EXPECT_TRUE(manager.get());
TestHostCookie(manager);
@ -502,7 +505,7 @@ TEST(CookieTest, MultipleCookiesGlobal) {
// Test creation of multiple cookies.
TEST(CookieTest, MultipleCookiesInMemory) {
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(CefString());
CefCookieManager::CreateManager(CefString(), false);
EXPECT_TRUE(manager.get());
TestMultipleCookies(manager);
@ -516,7 +519,7 @@ TEST(CookieTest, MultipleCookiesOnDisk) {
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(temp_dir.path().value());
CefCookieManager::CreateManager(temp_dir.path().value(), false);
EXPECT_TRUE(manager.get());
TestMultipleCookies(manager);
@ -531,7 +534,7 @@ TEST(CookieTest, AllCookiesGlobal) {
TEST(CookieTest, AllCookiesInMemory) {
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(CefString());
CefCookieManager::CreateManager(CefString(), false);
EXPECT_TRUE(manager.get());
TestAllCookies(manager);
@ -544,7 +547,7 @@ TEST(CookieTest, AllCookiesOnDisk) {
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(temp_dir.path().value());
CefCookieManager::CreateManager(temp_dir.path().value(), false);
EXPECT_TRUE(manager.get());
TestAllCookies(manager);
@ -562,13 +565,93 @@ TEST(CookieTest, ChangeDirectoryGlobal) {
TEST(CookieTest, ChangeDirectoryCreated) {
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(CefString());
CefCookieManager::CreateManager(CefString(), false);
EXPECT_TRUE(manager.get());
TestChangeDirectory(manager, CefString());
}
namespace {
class TestCompletionHandler : public CefCompletionHandler {
public:
explicit TestCompletionHandler(base::WaitableEvent* event)
: event_(event) {}
virtual void OnComplete() OVERRIDE {
event_->Signal();
}
private:
base::WaitableEvent* event_;
IMPLEMENT_REFCOUNTING(TestCompletionHandler);
};
} // namespace
TEST(CookieTest, SessionCookieNoPersist) {
base::ScopedTempDir temp_dir;
base::WaitableEvent event(false, false);
CefCookie cookie;
// Create a new temporary directory.
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(temp_dir.path().value(), false);
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 TestCompletionHandler(&event));
event.Wait();
// Create a new manager to read the same cookie store.
manager =
CefCookieManager::CreateManager(temp_dir.path().value(), false);
// Verify that the cookie doesn't exist.
VerifyNoCookies(manager, event, true);
}
TEST(CookieTest, SessionCookieWillPersist) {
base::ScopedTempDir temp_dir;
base::WaitableEvent event(false, false);
CefCookie cookie;
// Create a new temporary directory.
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(temp_dir.path().value(), true);
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 TestCompletionHandler(&event));
event.Wait();
// Create a new manager to read the same cookie store.
manager =
CefCookieManager::CreateManager(temp_dir.path().value(), true);
// Verify that the cookie exists.
GetCookie(manager, cookie, true, event, false);
}
namespace {
const char* kCookieJSUrl1 = "http://tests/cookie1.html";
@ -580,8 +663,8 @@ class CookieTestJSHandler : public TestHandler {
virtual void RunTest() OVERRIDE {
// Create =new in-memory managers.
manager1_ = CefCookieManager::CreateManager(CefString());
manager2_ = CefCookieManager::CreateManager(CefString());
manager1_ = CefCookieManager::CreateManager(CefString(), false);
manager2_ = CefCookieManager::CreateManager(CefString(), false);
std::string page =
"<html><head>"
@ -805,8 +888,8 @@ class CookieTestSchemeHandler : public TestHandler {
virtual void RunTest() OVERRIDE {
// Create new in-memory managers.
manager1_ = CefCookieManager::CreateManager(CefString());
manager2_ = CefCookieManager::CreateManager(CefString());
manager1_ = CefCookieManager::CreateManager(CefString(), false);
manager2_ = CefCookieManager::CreateManager(CefString(), false);
if (scheme_ != "http") {
std::vector<CefString> schemes;