From e258cbc5363b2f37149640d94798cf04946d9619 Mon Sep 17 00:00:00 2001 From: Marshall Greenblatt Date: Wed, 21 Mar 2012 16:14:14 +0000 Subject: [PATCH] Revert revision 534 changes: Add CefCookieManager interface and CefRequestHandler::GetCookieManager for custom cookie handling (issue #542). git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@541 5089003a-bbd8-11dd-ad1f-f1f9622dbc98 --- cef.gyp | 1 - cef_paths.gypi | 4 - include/capi/cef_cookie_capi.h | 100 ++--- include/capi/cef_request_handler_capi.h | 8 - include/cef_cookie.h | 109 ++--- include/cef_request_handler.h | 10 - libcef/browser_resource_loader_bridge.cc | 87 ++++ libcef/browser_resource_loader_bridge.h | 8 + libcef/browser_webcookiejar_impl.cc | 141 +----- libcef/browser_webcookiejar_impl.h | 14 +- libcef/browser_webview_delegate.cc | 9 +- libcef/browser_webview_delegate.h | 4 - libcef/cookie_impl.cc | 254 +++++------ libcef/cookie_impl.h | 41 -- libcef_dll/cpptoc/cookie_manager_cpptoc.cc | 177 -------- libcef_dll/cpptoc/cookie_manager_cpptoc.h | 37 -- libcef_dll/cpptoc/request_handler_cpptoc.cc | 23 - libcef_dll/ctocpp/cookie_manager_ctocpp.cc | 152 ------- libcef_dll/ctocpp/cookie_manager_ctocpp.h | 49 --- libcef_dll/ctocpp/request_handler_ctocpp.cc | 21 - libcef_dll/ctocpp/request_handler_ctocpp.h | 2 - libcef_dll/libcef_dll.cc | 98 ++++- libcef_dll/wrapper/libcef_dll_wrapper.cc | 88 +++- tests/unittests/cookie_unittest.cc | 457 ++++---------------- 24 files changed, 573 insertions(+), 1321 deletions(-) delete mode 100644 libcef/cookie_impl.h delete mode 100644 libcef_dll/cpptoc/cookie_manager_cpptoc.cc delete mode 100644 libcef_dll/cpptoc/cookie_manager_cpptoc.h delete mode 100644 libcef_dll/ctocpp/cookie_manager_ctocpp.cc delete mode 100644 libcef_dll/ctocpp/cookie_manager_ctocpp.h diff --git a/cef.gyp b/cef.gyp index ce67fa297..e0f7cde3d 100644 --- a/cef.gyp +++ b/cef.gyp @@ -721,7 +721,6 @@ 'libcef/cef_time_util.h', 'libcef/command_line_impl.cc', 'libcef/cookie_impl.cc', - 'libcef/cookie_impl.h', 'libcef/drag_data_impl.cc', 'libcef/drag_data_impl.h', 'libcef/drag_download_file.cc', diff --git a/cef_paths.gypi b/cef_paths.gypi index 5c9075fdd..630bdf6f1 100644 --- a/cef_paths.gypi +++ b/cef_paths.gypi @@ -102,8 +102,6 @@ 'libcef_dll/cpptoc/command_line_cpptoc.h', 'libcef_dll/ctocpp/content_filter_ctocpp.cc', 'libcef_dll/ctocpp/content_filter_ctocpp.h', - 'libcef_dll/cpptoc/cookie_manager_cpptoc.cc', - 'libcef_dll/cpptoc/cookie_manager_cpptoc.h', 'libcef_dll/ctocpp/cookie_visitor_ctocpp.cc', 'libcef_dll/ctocpp/cookie_visitor_ctocpp.h', 'libcef_dll/cpptoc/domdocument_cpptoc.cc', @@ -210,8 +208,6 @@ 'libcef_dll/ctocpp/command_line_ctocpp.h', 'libcef_dll/cpptoc/content_filter_cpptoc.cc', 'libcef_dll/cpptoc/content_filter_cpptoc.h', - 'libcef_dll/ctocpp/cookie_manager_ctocpp.cc', - 'libcef_dll/ctocpp/cookie_manager_ctocpp.h', 'libcef_dll/cpptoc/cookie_visitor_cpptoc.cc', 'libcef_dll/cpptoc/cookie_visitor_cpptoc.h', 'libcef_dll/ctocpp/domdocument_ctocpp.cc', diff --git a/include/capi/cef_cookie_capi.h b/include/capi/cef_cookie_capi.h index 941652832..cf5dd535c 100644 --- a/include/capi/cef_cookie_capi.h +++ b/include/capi/cef_cookie_capi.h @@ -46,79 +46,49 @@ extern "C" { /// -// Structure used for managing cookies. The functions of this structure may be -// called on any thread unless otherwise indicated. +// Visit all cookies. The returned cookies are ordered by longest path, then by +// earliest creation date. Returns false (0) if cookies cannot be accessed. /// -typedef struct _cef_cookie_manager_t { - /// - // Base structure. - /// - cef_base_t base; - - /// - // Visit all cookies. The returned cookies are ordered by longest path, then - // by earliest creation date. Returns false (0) if cookies cannot be accessed. - /// - int (CEF_CALLBACK *visit_all_cookies)(struct _cef_cookie_manager_t* self, - struct _cef_cookie_visitor_t* visitor); - - /// - // Visit a subset of cookies. The results are filtered by the given url - // scheme, host, domain and path. If |includeHttpOnly| is true (1) HTTP-only - // cookies will also be included in the results. The returned cookies are - // ordered by longest path, then by earliest creation date. Returns false (0) - // if cookies cannot be accessed. - /// - int (CEF_CALLBACK *visit_url_cookies)(struct _cef_cookie_manager_t* self, - const cef_string_t* url, int includeHttpOnly, - struct _cef_cookie_visitor_t* visitor); - - /// - // Sets a cookie given a valid URL and explicit user-provided cookie - // attributes. This function expects each attribute to be well-formed. It will - // check for disallowed characters (e.g. the ';' character is disallowed - // within the cookie value attribute) and will return false (0) without - // setting the cookie if such characters are found. This function must be - // called on the IO thread. - /// - int (CEF_CALLBACK *set_cookie)(struct _cef_cookie_manager_t* self, - const cef_string_t* url, const struct _cef_cookie_t* cookie); - - /// - // Delete all cookies that match the specified parameters. If both |url| and - // values |cookie_name| are specified all host and domain cookies matching - // both will be deleted. If only |url| is specified all host cookies (but not - // domain cookies) irrespective of path will be deleted. If |url| is NULL all - // cookies for all hosts and domains will be deleted. Returns false (0) if a - // non- NULL invalid URL is specified or if cookies cannot be accessed. This - // function must be called on the IO thread. - /// - int (CEF_CALLBACK *delete_cookies)(struct _cef_cookie_manager_t* self, - const cef_string_t* url, const cef_string_t* cookie_name); - - /// - // 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. - /// - int (CEF_CALLBACK *set_storage_path)(struct _cef_cookie_manager_t* self, - const cef_string_t* path); -} cef_cookie_manager_t; - +CEF_EXPORT int cef_visit_all_cookies(struct _cef_cookie_visitor_t* visitor); /// -// Returns the global cookie manager. By default data will be stored at -// CefSettings.cache_path if specified or in memory otherwise. +// Visit a subset of cookies. The results are filtered by the given url scheme, +// host, domain and path. If |includeHttpOnly| is true (1) HTTP-only cookies +// will also be included in the results. The returned cookies are ordered by +// longest path, then by earliest creation date. Returns false (0) if cookies +// cannot be accessed. /// -CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_get_global_manager(); +CEF_EXPORT int cef_visit_url_cookies(const cef_string_t* url, + int includeHttpOnly, struct _cef_cookie_visitor_t* visitor); /// -// Creates a new cookie manager. If |path| is NULL data will be stored in memory -// only. Returns NULL if creation fails. +// Sets a cookie given a valid URL and explicit user-provided cookie attributes. +// This function expects each attribute to be well-formed. It will check for +// disallowed characters (e.g. the ';' character is disallowed within the cookie +// value attribute) and will return false (0) without setting the cookie if such +// characters are found. This function must be called on the IO thread. /// -CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_create_manager( - const cef_string_t* path); +CEF_EXPORT int cef_set_cookie(const cef_string_t* url, + const struct _cef_cookie_t* cookie); +/// +// Delete all cookies that match the specified parameters. If both |url| and +// |cookie_name| are specified all host and domain cookies matching both values +// will be deleted. If only |url| is specified all host cookies (but not domain +// cookies) irrespective of path will be deleted. If |url| is NULL all cookies +// for all hosts and domains will be deleted. Returns false (0) if a non-NULL +// invalid URL is specified or if cookies cannot be accessed. This function must +// be called on the IO thread. +/// +CEF_EXPORT int cef_delete_cookies(const cef_string_t* url, + const cef_string_t* cookie_name); + +/// +// Sets the directory path that will be used for storing cookie data. If |path| +// is NULL data will be stored in memory only. By default the cookie path is the +// same as the cache path. Returns false (0) if cookies cannot be accessed. +/// +CEF_EXPORT int cef_set_cookie_path(const cef_string_t* path); /// // Structure to implement for visiting cookie values. The functions of this diff --git a/include/capi/cef_request_handler_capi.h b/include/capi/cef_request_handler_capi.h index b4ac623be..3fe0ab48f 100644 --- a/include/capi/cef_request_handler_capi.h +++ b/include/capi/cef_request_handler_capi.h @@ -139,14 +139,6 @@ typedef struct _cef_request_handler_t { struct _cef_browser_t* browser, int isProxy, const cef_string_t* host, int port, const cef_string_t* realm, const cef_string_t* scheme, cef_string_t* username, cef_string_t* password); - - /// - // Called on the UI thread to retrieve the cookie manager. Cookies managers - // can be unique per browser or shared across multiple browsers. The global - // cookie manager will be used if this function returns NULL. - /// - struct _cef_cookie_manager_t* (CEF_CALLBACK *get_cookie_manager)( - struct _cef_request_handler_t* self, struct _cef_browser_t* browser); } cef_request_handler_t; diff --git a/include/cef_cookie.h b/include/cef_cookie.h index fa5086034..932bab20f 100644 --- a/include/cef_cookie.h +++ b/include/cef_cookie.h @@ -1,4 +1,4 @@ -// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are @@ -42,78 +42,53 @@ class CefCookieVisitor; +/// +// Visit all cookies. The returned cookies are ordered by longest path, then by +// earliest creation date. Returns false if cookies cannot be accessed. +/// +/*--cef()--*/ +bool CefVisitAllCookies(CefRefPtr visitor); /// -// Class used for managing cookies. The methods of this class may be called on -// any thread unless otherwise indicated. +// Visit a subset of cookies. The results are filtered by the given url scheme, +// host, domain and path. If |includeHttpOnly| is true HTTP-only cookies will +// also be included in the results. The returned cookies are ordered by longest +// path, then by earliest creation date. Returns false if cookies cannot be +// accessed. /// -/*--cef(source=library)--*/ -class CefCookieManager : public virtual CefBase { - public: - /// - // Returns the global cookie manager. By default data will be stored at - // CefSettings.cache_path if specified or in memory otherwise. - /// - /*--cef()--*/ - static CefRefPtr GetGlobalManager(); +/*--cef()--*/ +bool CefVisitUrlCookies(const CefString& url, bool includeHttpOnly, + CefRefPtr visitor); - /// - // Creates a new cookie manager. If |path| is empty data will be stored in - // memory only. Returns NULL if creation fails. - /// - /*--cef(optional_param=path)--*/ - static CefRefPtr CreateManager(const CefString& path); +/// +// Sets a cookie given a valid URL and explicit user-provided cookie attributes. +// This function expects each attribute to be well-formed. It will check for +// disallowed characters (e.g. the ';' character is disallowed within the cookie +// value attribute) and will return false without setting the cookie if such +// characters are found. This method must be called on the IO thread. +/// +/*--cef()--*/ +bool CefSetCookie(const CefString& url, const CefCookie& cookie); - /// - // Visit all cookies. The returned cookies are ordered by longest path, then - // by earliest creation date. Returns false if cookies cannot be accessed. - /// - /*--cef()--*/ - virtual bool VisitAllCookies(CefRefPtr visitor) =0; +/// +// Delete all cookies that match the specified parameters. If both |url| and +// |cookie_name| are specified all host and domain cookies matching both values +// will be deleted. If only |url| is specified all host cookies (but not domain +// cookies) irrespective of path will be deleted. If |url| is empty all cookies +// for all hosts and domains will be deleted. Returns false if a non-empty +// invalid URL is specified or if cookies cannot be accessed. This method must +// be called on the IO thread. +/// +/*--cef(optional_param=url,optional_param=cookie_name)--*/ +bool CefDeleteCookies(const CefString& url, const CefString& cookie_name); - /// - // Visit a subset of cookies. The results are filtered by the given url - // scheme, host, domain and path. If |includeHttpOnly| is true HTTP-only - // cookies will also be included in the results. The returned cookies are - // ordered by longest path, then by earliest creation date. Returns false if - // cookies cannot be accessed. - /// - /*--cef()--*/ - virtual bool VisitUrlCookies(const CefString& url, bool includeHttpOnly, - CefRefPtr visitor) =0; - - /// - // Sets a cookie given a valid URL and explicit user-provided cookie - // attributes. This function expects each attribute to be well-formed. It will - // check for disallowed characters (e.g. the ';' character is disallowed - // within the cookie value attribute) and will return false without setting - // the cookie if such characters are found. This method must be called on the - // IO thread. - /// - /*--cef()--*/ - virtual bool SetCookie(const CefString& url, const CefCookie& cookie) =0; - - /// - // Delete all cookies that match the specified parameters. If both |url| and - // values |cookie_name| are specified all host and domain cookies matching - // both will be deleted. If only |url| is specified all host cookies (but not - // domain cookies) irrespective of path will be deleted. If |url| is empty all - // cookies for all hosts and domains will be deleted. Returns false if a non- - // empty invalid URL is specified or if cookies cannot be accessed. This - // method must be called on the IO thread. - /// - /*--cef(optional_param=url,optional_param=cookie_name)--*/ - virtual bool DeleteCookies(const CefString& url, - const CefString& cookie_name) =0; - - /// - // 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. - /// - /*--cef(optional_param=path)--*/ - virtual bool SetStoragePath(const CefString& path) =0; -}; +/// +// Sets the directory path that will be used for storing cookie data. If |path| +// is empty data will be stored in memory only. By default the cookie path is +// the same as the cache path. Returns false if cookies cannot be accessed. +/// +/*--cef(optional_param=path)--*/ +bool CefSetCookiePath(const CefString& path); /// diff --git a/include/cef_request_handler.h b/include/cef_request_handler.h index f5a18e178..ceb005de0 100644 --- a/include/cef_request_handler.h +++ b/include/cef_request_handler.h @@ -40,7 +40,6 @@ #include "include/cef_base.h" #include "include/cef_browser.h" -#include "include/cef_cookie.h" #include "include/cef_download_handler.h" #include "include/cef_frame.h" #include "include/cef_content_filter.h" @@ -155,15 +154,6 @@ class CefRequestHandler : public virtual CefBase { const CefString& scheme, CefString& username, CefString& password) { return false; } - - /// - // Called on the UI thread to retrieve the cookie manager. Cookies managers - // can be unique per browser or shared across multiple browsers. The global - // cookie manager will be used if this method returns NULL. - /// - /*--cef()--*/ - virtual CefRefPtr GetCookieManager( - CefRefPtr browser) { return NULL; } }; #endif // CEF_INCLUDE_CEF_REQUEST_HANDLER_H_ diff --git a/libcef/browser_resource_loader_bridge.cc b/libcef/browser_resource_loader_bridge.cc index 8c70d9134..7aae106cc 100644 --- a/libcef/browser_resource_loader_bridge.cc +++ b/libcef/browser_resource_loader_bridge.cc @@ -51,11 +51,13 @@ #include "base/memory/ref_counted.h" #include "base/message_loop.h" #include "base/message_loop_proxy.h" +#include "base/synchronization/waitable_event.h" #include "base/time.h" #include "base/timer.h" #include "base/threading/thread.h" #include "base/utf_string_conversions.h" #include "net/base/auth.h" +#include "net/base/cookie_store.h" #include "net/base/file_stream.h" #include "net/base/io_buffer.h" #include "net/base/load_flags.h" @@ -1111,6 +1113,61 @@ class ResourceLoaderBridgeImpl : public ResourceLoaderBridge { RequestProxy* proxy_; }; +//----------------------------------------------------------------------------- + +class CookieSetter : public base::RefCountedThreadSafe { + public: + void Set(const GURL& url, const std::string& cookie) { + REQUIRE_IOT(); + net::CookieStore* cookie_store = + _Context->request_context()->cookie_store(); + if (cookie_store) { + cookie_store->SetCookieWithOptionsAsync( + url, cookie, net::CookieOptions(), + net::CookieStore::SetCookiesCallback()); + } + } + + private: + friend class base::RefCountedThreadSafe; + + ~CookieSetter() {} +}; + +class CookieGetter : public base::RefCountedThreadSafe { + public: + CookieGetter() : event_(false, false) { + } + + void Get(const GURL& url) { + REQUIRE_IOT(); + net::CookieStore* cookie_store = + _Context->request_context()->cookie_store(); + if (cookie_store) { + cookie_store->GetCookiesWithOptionsAsync( + url, net::CookieOptions(), + base::Bind(&CookieGetter::OnGetCookies, this)); + } + } + + std::string GetResult() { + event_.Wait(); + return result_; + } + + private: + void OnGetCookies(const std::string& cookie_line) { + result_ = cookie_line; + event_.Signal(); + } + friend class base::RefCountedThreadSafe; + + ~CookieGetter() {} + + base::WaitableEvent event_; + std::string result_; +}; + } // anonymous namespace //----------------------------------------------------------------------------- @@ -1125,6 +1182,36 @@ webkit_glue::ResourceLoaderBridge* BrowserResourceLoaderBridge::Create( //----------------------------------------------------------------------------- +// static +void BrowserResourceLoaderBridge::SetCookie(const GURL& url, + const GURL& first_party_for_cookies, + const std::string& cookie) { + // Proxy to IO thread to synchronize w/ network loading. + scoped_refptr cookie_setter = new CookieSetter(); + CefThread::PostTask(CefThread::IO, FROM_HERE, base::Bind( + &CookieSetter::Set, cookie_setter.get(), url, cookie)); +} + +// static +std::string BrowserResourceLoaderBridge::GetCookies( + const GURL& url, const GURL& first_party_for_cookies) { + // Proxy to IO thread to synchronize w/ network loading. + scoped_refptr cookie_getter = new CookieGetter(); + CefThread::PostTask(CefThread::IO, FROM_HERE, base::Bind( + &CookieGetter::Get, cookie_getter.get(), url)); + + // Blocks until the result is available. + return cookie_getter->GetResult(); +} + +// static +void BrowserResourceLoaderBridge::SetAcceptAllCookies(bool accept_all_cookies) { + // Proxy to IO thread to synchronize w/ network loading. + CefThread::PostTask(CefThread::IO, FROM_HERE, base::Bind( + &BrowserRequestContext::SetAcceptAllCookies, + _Context->request_context().get(), accept_all_cookies)); +} + // static CefRefPtr BrowserResourceLoaderBridge::GetBrowserForRequest( net::URLRequest* request) { diff --git a/libcef/browser_resource_loader_bridge.h b/libcef/browser_resource_loader_bridge.h index 6eee00142..47219ea2d 100644 --- a/libcef/browser_resource_loader_bridge.h +++ b/libcef/browser_resource_loader_bridge.h @@ -19,6 +19,14 @@ class GURL; class BrowserResourceLoaderBridge { public: + // May only be called after Init. + static void SetCookie(const GURL& url, + const GURL& first_party_for_cookies, + const std::string& cookie); + static std::string GetCookies(const GURL& url, + const GURL& first_party_for_cookies); + static void SetAcceptAllCookies(bool accept_all_cookies); + // Return the CefBrowser associated with the specified request. The browser // will be NULL in cases where the request was initiated using the // CefWebURLRequest API. diff --git a/libcef/browser_webcookiejar_impl.cc b/libcef/browser_webcookiejar_impl.cc index 3c74878cb..3ce8d0eaa 100644 --- a/libcef/browser_webcookiejar_impl.cc +++ b/libcef/browser_webcookiejar_impl.cc @@ -1,152 +1,25 @@ -// Copyright (c) 2012 the Chromium Embedded Framework authors. -// Portions copyright (c) 2010 The Chromium Authors. All rights reserved. +// Copyright (c) 2010 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "libcef/browser_webcookiejar_impl.h" - -#include - #include "libcef/browser_resource_loader_bridge.h" -#include "libcef/browser_impl.h" -#include "libcef/cookie_impl.h" -#include "libcef/cef_context.h" -#include "libcef/cef_thread.h" -#include "base/synchronization/waitable_event.h" -#include "net/base/cookie_store.h" #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURL.h" using WebKit::WebString; using WebKit::WebURL; -namespace { - -class CookieSetter : public base::RefCountedThreadSafe { - public: - void Set(net::CookieStore* cookie_store, - const GURL& url, - const std::string& cookie) { - REQUIRE_IOT(); - cookie_store->SetCookieWithOptionsAsync( - url, cookie, net::CookieOptions(), - net::CookieStore::SetCookiesCallback()); - } - - private: - friend class base::RefCountedThreadSafe; - - ~CookieSetter() {} -}; - -class CookieGetter : public base::RefCountedThreadSafe { - public: - CookieGetter() : event_(false, false) { - } - - void Get(net::CookieStore* cookie_store, const GURL& url) { - REQUIRE_IOT(); - cookie_store->GetCookiesWithOptionsAsync( - url, net::CookieOptions(), - base::Bind(&CookieGetter::OnGetCookies, this)); - } - - std::string GetResult() { - event_.Wait(); - return result_; - } - - private: - void OnGetCookies(const std::string& cookie_line) { - result_ = cookie_line; - event_.Signal(); - } - friend class base::RefCountedThreadSafe; - - ~CookieGetter() {} - - base::WaitableEvent event_; - std::string result_; -}; - -} // namespace - -BrowserWebCookieJarImpl::BrowserWebCookieJarImpl() - : browser_(NULL) { -} - -BrowserWebCookieJarImpl::BrowserWebCookieJarImpl(CefBrowserImpl* browser) - : browser_(browser) { -} - void BrowserWebCookieJarImpl::setCookie(const WebURL& url, - const WebURL& first_party_for_cookies, - const WebString& value) { - GURL gurl = url; - std::string cookie = value.utf8(); - - scoped_refptr cookie_store; - if (browser_) { - CefRefPtr client = browser_->GetClient(); - if (client.get()) { - CefRefPtr handler = client->GetRequestHandler(); - if (handler.get()) { - // Get the manager from the handler. - CefRefPtr manager = - handler->GetCookieManager(browser_); - if (manager.get()) { - cookie_store = - reinterpret_cast( - manager.get())->cookie_monster(); - } - } - } - } - - if (!cookie_store) { - // Use the global cookie store. - cookie_store = _Context->request_context()->cookie_store(); - } - - // Proxy to IO thread to synchronize w/ network loading. - scoped_refptr cookie_setter = new CookieSetter(); - CefThread::PostTask(CefThread::IO, FROM_HERE, base::Bind( - &CookieSetter::Set, cookie_setter.get(), cookie_store, gurl, cookie)); + const WebURL& first_party_for_cookies, + const WebString& value) { + BrowserResourceLoaderBridge::SetCookie( + url, first_party_for_cookies, value.utf8()); } WebString BrowserWebCookieJarImpl::cookies( const WebURL& url, const WebURL& first_party_for_cookies) { - GURL gurl = url; - - scoped_refptr cookie_store; - if (browser_) { - CefRefPtr client = browser_->GetClient(); - if (client.get()) { - CefRefPtr handler = client->GetRequestHandler(); - if (handler.get()) { - // Get the manager from the handler. - CefRefPtr manager = - handler->GetCookieManager(browser_); - if (manager.get()) { - cookie_store = - reinterpret_cast( - manager.get())->cookie_monster(); - } - } - } - } - - if (!cookie_store) { - // Use the global cookie store. - cookie_store = _Context->request_context()->cookie_store(); - } - - // Proxy to IO thread to synchronize w/ network loading. - scoped_refptr cookie_getter = new CookieGetter(); - CefThread::PostTask(CefThread::IO, FROM_HERE, base::Bind( - &CookieGetter::Get, cookie_getter.get(), cookie_store, gurl)); - - // Blocks until the result is available. - return WebString::fromUTF8(cookie_getter->GetResult()); + return WebString::fromUTF8( + BrowserResourceLoaderBridge::GetCookies(url, first_party_for_cookies)); } diff --git a/libcef/browser_webcookiejar_impl.h b/libcef/browser_webcookiejar_impl.h index 2e833be78..705f0d133 100644 --- a/libcef/browser_webcookiejar_impl.h +++ b/libcef/browser_webcookiejar_impl.h @@ -1,5 +1,4 @@ -// Copyright (c) 2012 the Chromium Embedded Framework authors. -// Portions copyright (c) 2010 The Chromium Authors. All rights reserved. +// Copyright (c) 2010 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -7,25 +6,18 @@ #define CEF_LIBCEF_BROWSER_WEBCOOKIEJAR_IMPL_H_ #pragma once +// TODO(darin): WebCookieJar.h is missing a WebString.h include! +#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h" #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCookieJar.h" -class CefBrowserImpl; - class BrowserWebCookieJarImpl : public WebKit::WebCookieJar { public: - BrowserWebCookieJarImpl(); - explicit BrowserWebCookieJarImpl(CefBrowserImpl* browser); - // WebKit::WebCookieJar methods: virtual void setCookie( const WebKit::WebURL& url, const WebKit::WebURL& first_party_for_cookies, const WebKit::WebString& cookie); virtual WebKit::WebString cookies( const WebKit::WebURL& url, const WebKit::WebURL& first_party_for_cookies); - - private: - // May be NULL for the global implementation. - CefBrowserImpl* browser_; }; #endif // CEF_LIBCEF_BROWSER_WEBCOOKIEJAR_IMPL_H_ diff --git a/libcef/browser_webview_delegate.cc b/libcef/browser_webview_delegate.cc index c6e311e11..d8523d013 100644 --- a/libcef/browser_webview_delegate.cc +++ b/libcef/browser_webview_delegate.cc @@ -510,7 +510,7 @@ bool BrowserWebViewDelegate::allowScriptExtension( // WebPluginPageDelegate ----------------------------------------------------- WebCookieJar* BrowserWebViewDelegate::GetCookieJar() { - return &cookie_jar_; + return WebKit::webKitPlatformSupport()->cookieJar(); } // WebWidgetClient ----------------------------------------------------------- @@ -688,10 +688,6 @@ WebApplicationCacheHost* BrowserWebViewDelegate::createApplicationCacheHost( return BrowserAppCacheSystem::CreateApplicationCacheHost(client); } -WebKit::WebCookieJar* BrowserWebViewDelegate::cookieJar(WebFrame* frame) { - return &cookie_jar_; -} - void BrowserWebViewDelegate::willClose(WebFrame* frame) { browser_->UIT_BeforeFrameClosed(frame); } @@ -1011,8 +1007,7 @@ BrowserWebViewDelegate::BrowserWebViewDelegate(CefBrowserImpl* browser) #else select_trailing_whitespace_enabled_(false), #endif - block_redirects_(false), - cookie_jar_(browser) { + block_redirects_(false) { } BrowserWebViewDelegate::~BrowserWebViewDelegate() { diff --git a/libcef/browser_webview_delegate.h b/libcef/browser_webview_delegate.h index 89a4e546a..917928faa 100644 --- a/libcef/browser_webview_delegate.h +++ b/libcef/browser_webview_delegate.h @@ -16,7 +16,6 @@ #include #include "libcef/browser_navigation_controller.h" -#include "libcef/browser_webcookiejar_impl.h" #include "base/basictypes.h" #include "base/compiler_specific.h" @@ -158,7 +157,6 @@ class BrowserWebViewDelegate : public WebKit::WebViewClient, virtual WebKit::WebApplicationCacheHost* createApplicationCacheHost( WebKit::WebFrame* frame, WebKit::WebApplicationCacheHostClient* client) OVERRIDE; - virtual WebKit::WebCookieJar* cookieJar(WebKit::WebFrame*) OVERRIDE; virtual void willClose(WebKit::WebFrame*) OVERRIDE; virtual void loadURLExternally( WebKit::WebFrame*, const WebKit::WebURLRequest&, @@ -386,8 +384,6 @@ class BrowserWebViewDelegate : public WebKit::WebViewClient, std::string edit_command_name_; std::string edit_command_value_; - BrowserWebCookieJarImpl cookie_jar_; - DISALLOW_COPY_AND_ASSIGN(BrowserWebViewDelegate); }; diff --git a/libcef/cookie_impl.cc b/libcef/cookie_impl.cc index a492d3eff..a420285a4 100644 --- a/libcef/cookie_impl.cc +++ b/libcef/cookie_impl.cc @@ -1,33 +1,32 @@ -// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights // reserved. Use of this source code is governed by a BSD-style license that can // be found in the LICENSE file. -#include "libcef/cookie_impl.h" - -#include - -#include "libcef/browser_persistent_cookie_store.h" +#include "include/cef_cookie.h" #include "libcef/cef_context.h" #include "libcef/cef_thread.h" #include "libcef/cef_time_util.h" #include "base/bind.h" -#include "base/logging.h" +#include "net/base/cookie_monster.h" namespace { // Callback class for visiting cookies. class VisitCookiesCallback : public base::RefCounted { public: - explicit VisitCookiesCallback(net::CookieMonster* cookie_monster, - CefRefPtr visitor) - : cookie_monster_(cookie_monster), - visitor_(visitor) { + explicit VisitCookiesCallback(CefRefPtr visitor) + : visitor_(visitor) { } void Run(const net::CookieList& list) { REQUIRE_IOT(); + net::CookieMonster* cookie_monster = static_cast( + _Context->request_context()->cookie_store()); + if (!cookie_monster) + return; + int total = list.size(), count = 0; net::CookieList::const_iterator it = list.begin(); @@ -50,7 +49,7 @@ class VisitCookiesCallback : public base::RefCounted { bool deleteCookie = false; bool keepLooping = visitor_->Visit(cookie, count, total, deleteCookie); if (deleteCookie) { - cookie_monster_->DeleteCanonicalCookieAsync(cc, + cookie_monster->DeleteCanonicalCookieAsync(cc, net::CookieMonster::DeleteCookieCallback()); } if (!keepLooping) @@ -59,78 +58,104 @@ class VisitCookiesCallback : public base::RefCounted { } private: - scoped_refptr cookie_monster_; CefRefPtr visitor_; }; +void IOT_VisitAllCookies(CefRefPtr visitor) { + REQUIRE_IOT(); + + net::CookieMonster* cookie_monster = static_cast( + _Context->request_context()->cookie_store()); + if (!cookie_monster) + return; + + scoped_refptr callback( + new VisitCookiesCallback(visitor)); + + cookie_monster->GetAllCookiesAsync( + base::Bind(&VisitCookiesCallback::Run, callback.get())); +} + +void IOT_VisitUrlCookies(const GURL& url, bool includeHttpOnly, + CefRefPtr visitor) { + REQUIRE_IOT(); + + net::CookieMonster* cookie_monster = static_cast( + _Context->request_context()->cookie_store()); + if (!cookie_monster) + return; + + net::CookieOptions options; + if (includeHttpOnly) + options.set_include_httponly(); + + scoped_refptr callback( + new VisitCookiesCallback(visitor)); + + cookie_monster->GetAllCookiesForURLWithOptionsAsync(url, options, + base::Bind(&VisitCookiesCallback::Run, callback.get())); +} + +void IOT_SetCookiePath(const CefString& path) { + REQUIRE_IOT(); + + FilePath cookie_path; + if (!path.empty()) + cookie_path = FilePath(path); + + _Context->request_context()->SetCookieStoragePath(cookie_path); +} + } // namespace - -CefCookieManagerImpl::CefCookieManagerImpl() - : is_global_(true) { - cookie_monster_ = - static_cast( - _Context->request_context()->cookie_store()); - DCHECK(cookie_monster_); -} - - // Creates a new cookie monster with storage at the specified |path|. -CefCookieManagerImpl::CefCookieManagerImpl(const CefString& path) - :is_global_(false) { - SetStoragePath(path); -} - -bool CefCookieManagerImpl::VisitAllCookies( - CefRefPtr visitor) { - if (CefThread::CurrentlyOn(CefThread::IO)) { - scoped_refptr callback( - new VisitCookiesCallback(cookie_monster_, visitor)); - - cookie_monster_->GetAllCookiesAsync( - base::Bind(&VisitCookiesCallback::Run, callback.get())); - } else { - // Execute on the IO thread. - CefThread::PostTask(CefThread::IO, FROM_HERE, - base::Bind(base::IgnoreResult(&CefCookieManagerImpl::VisitAllCookies), - this, visitor)); +bool CefVisitAllCookies(CefRefPtr visitor) { + // Verify that the context is in a valid state. + if (!CONTEXT_STATE_VALID()) { + NOTREACHED() << "context not valid"; + return false; } - return true; + return CefThread::PostTask(CefThread::IO, FROM_HERE, + base::Bind(IOT_VisitAllCookies, visitor)); } -bool CefCookieManagerImpl::VisitUrlCookies( - const CefString& url, bool includeHttpOnly, - CefRefPtr visitor) { - if (CefThread::CurrentlyOn(CefThread::IO)) { - net::CookieOptions options; - if (includeHttpOnly) - options.set_include_httponly(); - - scoped_refptr callback( - new VisitCookiesCallback(cookie_monster_, visitor)); - - GURL gurl = GURL(url.ToString()); - cookie_monster_->GetAllCookiesForURLWithOptionsAsync(gurl, options, - base::Bind(&VisitCookiesCallback::Run, callback.get())); - } else { - // Execute on the IO thread. - CefThread::PostTask(CefThread::IO, FROM_HERE, - base::Bind(base::IgnoreResult(&CefCookieManagerImpl::VisitUrlCookies), - this, url, includeHttpOnly, visitor)); +bool CefVisitUrlCookies(const CefString& url, bool includeHttpOnly, + CefRefPtr visitor) { + // Verify that the context is in a valid state. + if (!CONTEXT_STATE_VALID()) { + NOTREACHED() << "context not valid"; + return false; } - return true; + std::string urlStr = url; + GURL gurl = GURL(urlStr); + if (!gurl.is_valid()) + return false; + + return CefThread::PostTask(CefThread::IO, FROM_HERE, + base::Bind(IOT_VisitUrlCookies, gurl, includeHttpOnly, visitor)); } -bool CefCookieManagerImpl::SetCookie(const CefString& url, - const CefCookie& cookie) { +bool CefSetCookie(const CefString& url, const CefCookie& cookie) { + // Verify that the context is in a valid state. + if (!CONTEXT_STATE_VALID()) { + NOTREACHED() << "context not valid"; + return false; + } + // Verify that this function is being called on the IO thread. if (!CefThread::CurrentlyOn(CefThread::IO)) { NOTREACHED() << "called on invalid thread"; return false; } - GURL gurl = GURL(url.ToString()); + net::CookieMonster* cookie_monster = static_cast( + _Context->request_context()->cookie_store()); + if (!cookie_monster) + return false; + + std::string urlStr = url; + GURL gurl = GURL(urlStr); if (!gurl.is_valid()) return false; @@ -143,110 +168,65 @@ bool CefCookieManagerImpl::SetCookie(const CefString& url, if (cookie.has_expires) cef_time_to_basetime(cookie.expires, expiration_time); - cookie_monster_->SetCookieWithDetailsAsync(gurl, name, value, domain, path, + cookie_monster->SetCookieWithDetailsAsync(gurl, name, value, domain, path, expiration_time, cookie.secure, cookie.httponly, net::CookieStore::SetCookiesCallback()); return true; } -bool CefCookieManagerImpl::DeleteCookies(const CefString& url, - const CefString& cookie_name) { +bool CefDeleteCookies(const CefString& url, const CefString& cookie_name) { + // Verify that the context is in a valid state. + if (!CONTEXT_STATE_VALID()) { + NOTREACHED() << "context not valid"; + return false; + } + // Verify that this function is being called on the IO thread. if (!CefThread::CurrentlyOn(CefThread::IO)) { NOTREACHED() << "called on invalid thread"; return false; } + net::CookieMonster* cookie_monster = static_cast( + _Context->request_context()->cookie_store()); + if (!cookie_monster) + return false; + if (url.empty()) { // Delete all cookies. - cookie_monster_->DeleteAllAsync(net::CookieMonster::DeleteCallback()); + cookie_monster->DeleteAllAsync(net::CookieMonster::DeleteCallback()); return true; } - GURL gurl = GURL(url.ToString()); + std::string urlStr = url; + GURL gurl = GURL(urlStr); if (!gurl.is_valid()) return false; if (cookie_name.empty()) { // Delete all matching host cookies. - cookie_monster_->DeleteAllForHostAsync(gurl, + cookie_monster->DeleteAllForHostAsync(gurl, net::CookieMonster::DeleteCallback()); } else { // Delete all matching host and domain cookies. - cookie_monster_->DeleteCookieAsync(gurl, cookie_name, base::Closure()); + cookie_monster->DeleteCookieAsync(gurl, cookie_name, base::Closure()); } return true; } -bool CefCookieManagerImpl::SetStoragePath(const CefString& path) { +bool CefSetCookiePath(const CefString& path) { + // Verify that the context is in a valid state. + if (!CONTEXT_STATE_VALID()) { + NOTREACHED() << "context not valid"; + return false; + } + if (CefThread::CurrentlyOn(CefThread::IO)) { - FilePath new_path; - if (!path.empty()) - new_path = FilePath(path); - - if (is_global_) { - // Global path changes are handled by the request context. - _Context->request_context()->SetCookieStoragePath(new_path); - cookie_monster_ = - static_cast( - _Context->request_context()->cookie_store()); - return true; - } - - if (cookie_monster_ && ((storage_path_.empty() && path.empty()) || - storage_path_ == new_path)) { - // The path has not changed so don't do anything. - return true; - } - - scoped_refptr persistent_store; - if (!new_path.empty()) { - if (file_util::CreateDirectory(new_path)) { - const FilePath& cookie_path = new_path.AppendASCII("Cookies"); - persistent_store = new BrowserPersistentCookieStore(cookie_path, false); - } else { - NOTREACHED() << "The cookie storage directory could not be created"; - storage_path_.clear(); - } - } - - // 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. - cookie_monster_ = new net::CookieMonster(persistent_store.get(), NULL); - storage_path_ = new_path; + IOT_SetCookiePath(path); } else { - // Execute on the IO thread. CefThread::PostTask(CefThread::IO, FROM_HERE, - base::Bind(base::IgnoreResult(&CefCookieManagerImpl::SetStoragePath), - this, path)); + base::Bind(&IOT_SetCookiePath, path)); } return true; } - - -// CefCookieManager methods ---------------------------------------------------- - -// static -CefRefPtr CefCookieManager::GetGlobalManager() { - // Verify that the context is in a valid state. - if (!CONTEXT_STATE_VALID()) { - NOTREACHED() << "context not valid"; - return NULL; - } - - return new CefCookieManagerImpl(); -} - -// static -CefRefPtr CefCookieManager::CreateManager( - const CefString& path) { - // Verify that the context is in a valid state. - if (!CONTEXT_STATE_VALID()) { - NOTREACHED() << "context not valid"; - return NULL; - } - - return new CefCookieManagerImpl(path); -} diff --git a/libcef/cookie_impl.h b/libcef/cookie_impl.h deleted file mode 100644 index 2d0c1d6a1..000000000 --- a/libcef/cookie_impl.h +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright (c) 2012 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. - -#ifndef CEF_LIBCEF_COOKIE_IMPL_H_ -#define CEF_LIBCEF_COOKIE_IMPL_H_ - -#include "include/cef_cookie.h" -#include "base/file_path.h" -#include "net/base/cookie_monster.h" - -// Implementation of the CefCookieManager interface. -class CefCookieManagerImpl : public CefCookieManager { - public: - // Creates a new reference to the existing global cookie monster. - CefCookieManagerImpl(); - - // Creates a new cookie monster with storage at the specified |path|. - explicit CefCookieManagerImpl(const CefString& path); - - // CefCookieManager methods. - virtual bool VisitAllCookies(CefRefPtr visitor) OVERRIDE; - virtual bool VisitUrlCookies(const CefString& url, bool includeHttpOnly, - CefRefPtr visitor) OVERRIDE; - virtual bool SetCookie(const CefString& url, - const CefCookie& cookie) OVERRIDE; - virtual bool DeleteCookies(const CefString& url, - const CefString& cookie_name) OVERRIDE; - virtual bool SetStoragePath(const CefString& path) OVERRIDE; - - net::CookieMonster* cookie_monster() { return cookie_monster_; } - - private: - scoped_refptr cookie_monster_; - bool is_global_; - FilePath storage_path_; - - IMPLEMENT_REFCOUNTING(CefCookieManagerImpl); -}; - -#endif // CEF_LIBCEF_COOKIE_IMPL_H_ diff --git a/libcef_dll/cpptoc/cookie_manager_cpptoc.cc b/libcef_dll/cpptoc/cookie_manager_cpptoc.cc deleted file mode 100644 index 034a873f8..000000000 --- a/libcef_dll/cpptoc/cookie_manager_cpptoc.cc +++ /dev/null @@ -1,177 +0,0 @@ -// Copyright (c) 2012 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/cookie_manager_cpptoc.h" -#include "libcef_dll/ctocpp/cookie_visitor_ctocpp.h" - - -// GLOBAL FUNCTIONS - Body may be edited by hand. - -CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_get_global_manager() { - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - // Execute - CefRefPtr _retval = CefCookieManager::GetGlobalManager(); - - // Return type: refptr_same - return CefCookieManagerCppToC::Wrap(_retval); -} - -CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_create_manager( - const cef_string_t* path) { - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - // Unverified params: path - - // Execute - CefRefPtr _retval = CefCookieManager::CreateManager( - CefString(path)); - - // Return type: refptr_same - return CefCookieManagerCppToC::Wrap(_retval); -} - - -// MEMBER FUNCTIONS - Body may be edited by hand. - -int CEF_CALLBACK cookie_manager_visit_all_cookies( - struct _cef_cookie_manager_t* self, - struct _cef_cookie_visitor_t* visitor) { - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - DCHECK(self); - if (!self) - return 0; - // Verify param: visitor; type: refptr_diff - DCHECK(visitor); - if (!visitor) - return 0; - - // Execute - bool _retval = CefCookieManagerCppToC::Get(self)->VisitAllCookies( - CefCookieVisitorCToCpp::Wrap(visitor)); - - // Return type: bool - return _retval; -} - -int CEF_CALLBACK cookie_manager_visit_url_cookies( - struct _cef_cookie_manager_t* self, const cef_string_t* url, - int includeHttpOnly, struct _cef_cookie_visitor_t* visitor) { - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - DCHECK(self); - if (!self) - return 0; - // Verify param: url; type: string_byref_const - DCHECK(url); - if (!url) - return 0; - // Verify param: visitor; type: refptr_diff - DCHECK(visitor); - if (!visitor) - return 0; - - // Execute - bool _retval = CefCookieManagerCppToC::Get(self)->VisitUrlCookies( - CefString(url), - includeHttpOnly?true:false, - CefCookieVisitorCToCpp::Wrap(visitor)); - - // Return type: bool - return _retval; -} - -int CEF_CALLBACK cookie_manager_set_cookie(struct _cef_cookie_manager_t* self, - const cef_string_t* url, const struct _cef_cookie_t* cookie) { - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - DCHECK(self); - if (!self) - return 0; - // Verify param: url; type: string_byref_const - DCHECK(url); - if (!url) - return 0; - // Verify param: cookie; type: struct_byref_const - DCHECK(cookie); - if (!cookie) - return 0; - - // Translate param: cookie; type: struct_byref_const - CefCookie cookieObj; - if (cookie) - cookieObj.Set(*cookie, false); - - // Execute - bool _retval = CefCookieManagerCppToC::Get(self)->SetCookie( - CefString(url), - cookieObj); - - // Return type: bool - return _retval; -} - -int CEF_CALLBACK cookie_manager_delete_cookies( - struct _cef_cookie_manager_t* self, const cef_string_t* url, - const cef_string_t* cookie_name) { - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - DCHECK(self); - if (!self) - return 0; - // Unverified params: url, cookie_name - - // Execute - bool _retval = CefCookieManagerCppToC::Get(self)->DeleteCookies( - CefString(url), - CefString(cookie_name)); - - // Return type: bool - return _retval; -} - -int CEF_CALLBACK cookie_manager_set_storage_path( - struct _cef_cookie_manager_t* self, const cef_string_t* path) { - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - DCHECK(self); - if (!self) - return 0; - // Unverified params: path - - // Execute - bool _retval = CefCookieManagerCppToC::Get(self)->SetStoragePath( - CefString(path)); - - // Return type: bool - return _retval; -} - - -// CONSTRUCTOR - Do not edit by hand. - -CefCookieManagerCppToC::CefCookieManagerCppToC(CefCookieManager* cls) - : CefCppToC( - cls) { - struct_.struct_.visit_all_cookies = cookie_manager_visit_all_cookies; - struct_.struct_.visit_url_cookies = cookie_manager_visit_url_cookies; - 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; -} - -#ifndef NDEBUG -template<> long CefCppToC::DebugObjCt = 0; -#endif - diff --git a/libcef_dll/cpptoc/cookie_manager_cpptoc.h b/libcef_dll/cpptoc/cookie_manager_cpptoc.h deleted file mode 100644 index cacc919f4..000000000 --- a/libcef_dll/cpptoc/cookie_manager_cpptoc.h +++ /dev/null @@ -1,37 +0,0 @@ -// Copyright (c) 2012 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_COOKIE_MANAGER_CPPTOC_H_ -#define CEF_LIBCEF_DLL_CPPTOC_COOKIE_MANAGER_CPPTOC_H_ -#pragma once - -#ifndef BUILDING_CEF_SHARED -#pragma message("Warning: "__FILE__" may be accessed DLL-side only") -#else // BUILDING_CEF_SHARED - -#include "include/cef_cookie.h" -#include "include/capi/cef_cookie_capi.h" -#include "libcef_dll/cpptoc/cpptoc.h" - -// Wrap a C++ class with a C structure. -// This class may be instantiated and accessed DLL-side only. -class CefCookieManagerCppToC - : public CefCppToC { - public: - explicit CefCookieManagerCppToC(CefCookieManager* cls); - virtual ~CefCookieManagerCppToC() {} -}; - -#endif // BUILDING_CEF_SHARED -#endif // CEF_LIBCEF_DLL_CPPTOC_COOKIE_MANAGER_CPPTOC_H_ - diff --git a/libcef_dll/cpptoc/request_handler_cpptoc.cc b/libcef_dll/cpptoc/request_handler_cpptoc.cc index 3777d01fe..6e9d66bb1 100644 --- a/libcef_dll/cpptoc/request_handler_cpptoc.cc +++ b/libcef_dll/cpptoc/request_handler_cpptoc.cc @@ -14,7 +14,6 @@ #include "libcef_dll/cpptoc/download_handler_cpptoc.h" #include "libcef_dll/cpptoc/request_handler_cpptoc.h" #include "libcef_dll/ctocpp/browser_ctocpp.h" -#include "libcef_dll/ctocpp/cookie_manager_ctocpp.h" #include "libcef_dll/ctocpp/frame_ctocpp.h" #include "libcef_dll/ctocpp/request_ctocpp.h" #include "libcef_dll/ctocpp/response_ctocpp.h" @@ -348,27 +347,6 @@ int CEF_CALLBACK request_handler_get_auth_credentials( return _retval; } -cef_cookie_manager_t* CEF_CALLBACK request_handler_get_cookie_manager( - struct _cef_request_handler_t* self, cef_browser_t* browser) { - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - DCHECK(self); - if (!self) - return NULL; - // Verify param: browser; type: refptr_diff - DCHECK(browser); - if (!browser) - return NULL; - - // Execute - CefRefPtr _retval = CefRequestHandlerCppToC::Get( - self)->GetCookieManager( - CefBrowserCToCpp::Wrap(browser)); - - // Return type: refptr_diff - return CefCookieManagerCToCpp::Unwrap(_retval); -} - // CONSTRUCTOR - Do not edit by hand. @@ -383,7 +361,6 @@ CefRequestHandlerCppToC::CefRequestHandlerCppToC(CefRequestHandler* cls) struct_.struct_.on_protocol_execution = request_handler_on_protocol_execution; struct_.struct_.get_download_handler = request_handler_get_download_handler; struct_.struct_.get_auth_credentials = request_handler_get_auth_credentials; - struct_.struct_.get_cookie_manager = request_handler_get_cookie_manager; } #ifndef NDEBUG diff --git a/libcef_dll/ctocpp/cookie_manager_ctocpp.cc b/libcef_dll/ctocpp/cookie_manager_ctocpp.cc deleted file mode 100644 index aef6394a1..000000000 --- a/libcef_dll/ctocpp/cookie_manager_ctocpp.cc +++ /dev/null @@ -1,152 +0,0 @@ -// Copyright (c) 2012 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/cookie_visitor_cpptoc.h" -#include "libcef_dll/ctocpp/cookie_manager_ctocpp.h" - - -// STATIC METHODS - Body may be edited by hand. - -CefRefPtr CefCookieManager::GetGlobalManager() { - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - // Execute - cef_cookie_manager_t* _retval = cef_cookie_manager_get_global_manager(); - - // Return type: refptr_same - return CefCookieManagerCToCpp::Wrap(_retval); -} - -CefRefPtr CefCookieManager::CreateManager( - const CefString& path) { - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - // Unverified params: path - - // Execute - cef_cookie_manager_t* _retval = cef_cookie_manager_create_manager( - path.GetStruct()); - - // Return type: refptr_same - return CefCookieManagerCToCpp::Wrap(_retval); -} - - -// VIRTUAL METHODS - Body may be edited by hand. - -bool CefCookieManagerCToCpp::VisitAllCookies( - CefRefPtr visitor) { - if (CEF_MEMBER_MISSING(struct_, visit_all_cookies)) - return false; - - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - // Verify param: visitor; type: refptr_diff - DCHECK(visitor.get()); - if (!visitor.get()) - return false; - - // Execute - int _retval = struct_->visit_all_cookies(struct_, - CefCookieVisitorCppToC::Wrap(visitor)); - - // Return type: bool - return _retval?true:false; -} - -bool CefCookieManagerCToCpp::VisitUrlCookies(const CefString& url, - bool includeHttpOnly, CefRefPtr visitor) { - if (CEF_MEMBER_MISSING(struct_, visit_url_cookies)) - return false; - - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - // Verify param: url; type: string_byref_const - DCHECK(!url.empty()); - if (url.empty()) - return false; - // Verify param: visitor; type: refptr_diff - DCHECK(visitor.get()); - if (!visitor.get()) - return false; - - // Execute - int _retval = struct_->visit_url_cookies(struct_, - url.GetStruct(), - includeHttpOnly, - CefCookieVisitorCppToC::Wrap(visitor)); - - // Return type: bool - return _retval?true:false; -} - -bool CefCookieManagerCToCpp::SetCookie(const CefString& url, - const CefCookie& cookie) { - if (CEF_MEMBER_MISSING(struct_, set_cookie)) - return false; - - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - // Verify param: url; type: string_byref_const - DCHECK(!url.empty()); - if (url.empty()) - return false; - - // Execute - int _retval = struct_->set_cookie(struct_, - url.GetStruct(), - &cookie); - - // Return type: bool - return _retval?true:false; -} - -bool CefCookieManagerCToCpp::DeleteCookies(const CefString& url, - const CefString& cookie_name) { - if (CEF_MEMBER_MISSING(struct_, delete_cookies)) - return false; - - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - // Unverified params: url, cookie_name - - // Execute - int _retval = struct_->delete_cookies(struct_, - url.GetStruct(), - cookie_name.GetStruct()); - - // Return type: bool - return _retval?true:false; -} - -bool CefCookieManagerCToCpp::SetStoragePath(const CefString& path) { - if (CEF_MEMBER_MISSING(struct_, set_storage_path)) - return false; - - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - // Unverified params: path - - // Execute - int _retval = struct_->set_storage_path(struct_, - path.GetStruct()); - - // Return type: bool - return _retval?true:false; -} - - -#ifndef NDEBUG -template<> long CefCToCpp::DebugObjCt = 0; -#endif - diff --git a/libcef_dll/ctocpp/cookie_manager_ctocpp.h b/libcef_dll/ctocpp/cookie_manager_ctocpp.h deleted file mode 100644 index ae2f4e627..000000000 --- a/libcef_dll/ctocpp/cookie_manager_ctocpp.h +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright (c) 2012 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_COOKIE_MANAGER_CTOCPP_H_ -#define CEF_LIBCEF_DLL_CTOCPP_COOKIE_MANAGER_CTOCPP_H_ -#pragma once - -#ifndef USING_CEF_SHARED -#pragma message("Warning: "__FILE__" may be accessed wrapper-side only") -#else // USING_CEF_SHARED - -#include "include/cef_cookie.h" -#include "include/capi/cef_cookie_capi.h" -#include "libcef_dll/ctocpp/ctocpp.h" - -// Wrap a C structure with a C++ class. -// This class may be instantiated and accessed wrapper-side only. -class CefCookieManagerCToCpp - : public CefCToCpp { - public: - explicit CefCookieManagerCToCpp(cef_cookie_manager_t* str) - : CefCToCpp(str) {} - virtual ~CefCookieManagerCToCpp() {} - - // CefCookieManager methods - virtual bool VisitAllCookies(CefRefPtr visitor) OVERRIDE; - virtual bool VisitUrlCookies(const CefString& url, bool includeHttpOnly, - CefRefPtr visitor) OVERRIDE; - virtual bool SetCookie(const CefString& url, - const CefCookie& cookie) OVERRIDE; - virtual bool DeleteCookies(const CefString& url, - const CefString& cookie_name) OVERRIDE; - virtual bool SetStoragePath(const CefString& path) OVERRIDE; -}; - -#endif // USING_CEF_SHARED -#endif // CEF_LIBCEF_DLL_CTOCPP_COOKIE_MANAGER_CTOCPP_H_ - diff --git a/libcef_dll/ctocpp/request_handler_ctocpp.cc b/libcef_dll/ctocpp/request_handler_ctocpp.cc index 1893c81b0..79b035172 100644 --- a/libcef_dll/ctocpp/request_handler_ctocpp.cc +++ b/libcef_dll/ctocpp/request_handler_ctocpp.cc @@ -11,7 +11,6 @@ // #include "libcef_dll/cpptoc/browser_cpptoc.h" -#include "libcef_dll/cpptoc/cookie_manager_cpptoc.h" #include "libcef_dll/cpptoc/frame_cpptoc.h" #include "libcef_dll/cpptoc/request_cpptoc.h" #include "libcef_dll/cpptoc/response_cpptoc.h" @@ -290,26 +289,6 @@ bool CefRequestHandlerCToCpp::GetAuthCredentials(CefRefPtr browser, return _retval?true:false; } -CefRefPtr CefRequestHandlerCToCpp::GetCookieManager( - CefRefPtr browser) { - if (CEF_MEMBER_MISSING(struct_, get_cookie_manager)) - return NULL; - - // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING - - // Verify param: browser; type: refptr_diff - DCHECK(browser.get()); - if (!browser.get()) - return NULL; - - // Execute - cef_cookie_manager_t* _retval = struct_->get_cookie_manager(struct_, - CefBrowserCppToC::Wrap(browser)); - - // Return type: refptr_diff - return CefCookieManagerCppToC::Unwrap(_retval); -} - #ifndef NDEBUG template<> long CefCToCpp GetCookieManager( - CefRefPtr browser) OVERRIDE; }; #endif // BUILDING_CEF_SHARED diff --git a/libcef_dll/libcef_dll.cc b/libcef_dll/libcef_dll.cc index 4052ad84a..05097c7f2 100644 --- a/libcef_dll/libcef_dll.cc +++ b/libcef_dll/libcef_dll.cc @@ -12,6 +12,8 @@ #include "include/cef_app.h" #include "include/capi/cef_app_capi.h" +#include "include/cef_cookie.h" +#include "include/capi/cef_cookie_capi.h" #include "include/cef_origin_whitelist.h" #include "include/capi/cef_origin_whitelist_capi.h" #include "include/cef_scheme.h" @@ -25,7 +27,6 @@ #include "include/cef_v8.h" #include "include/capi/cef_v8_capi.h" #include "libcef_dll/cpptoc/browser_cpptoc.h" -#include "libcef_dll/cpptoc/cookie_manager_cpptoc.h" #include "libcef_dll/cpptoc/domdocument_cpptoc.h" #include "libcef_dll/cpptoc/domevent_cpptoc.h" #include "libcef_dll/cpptoc/domnode_cpptoc.h" @@ -113,7 +114,6 @@ CEF_EXPORT void cef_shutdown() { // Check that all wrapper objects have been destroyed DCHECK_EQ(CefBrowserCppToC::DebugObjCt, 0); DCHECK_EQ(CefContentFilterCToCpp::DebugObjCt, 0); - DCHECK_EQ(CefCookieManagerCppToC::DebugObjCt, 0); DCHECK_EQ(CefCookieVisitorCToCpp::DebugObjCt, 0); DCHECK_EQ(CefDOMDocumentCppToC::DebugObjCt, 0); DCHECK_EQ(CefDOMEventCppToC::DebugObjCt, 0); @@ -185,6 +185,100 @@ CEF_EXPORT void cef_quit_message_loop() { CefQuitMessageLoop(); } +CEF_EXPORT int cef_visit_all_cookies(struct _cef_cookie_visitor_t* visitor) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: visitor; type: refptr_diff + DCHECK(visitor); + if (!visitor) + return 0; + + // Execute + bool _retval = CefVisitAllCookies( + CefCookieVisitorCToCpp::Wrap(visitor)); + + // Return type: bool + return _retval; +} + +CEF_EXPORT int cef_visit_url_cookies(const cef_string_t* url, + int includeHttpOnly, struct _cef_cookie_visitor_t* visitor) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: url; type: string_byref_const + DCHECK(url); + if (!url) + return 0; + // Verify param: visitor; type: refptr_diff + DCHECK(visitor); + if (!visitor) + return 0; + + // Execute + bool _retval = CefVisitUrlCookies( + CefString(url), + includeHttpOnly?true:false, + CefCookieVisitorCToCpp::Wrap(visitor)); + + // Return type: bool + return _retval; +} + +CEF_EXPORT int cef_set_cookie(const cef_string_t* url, + const struct _cef_cookie_t* cookie) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: url; type: string_byref_const + DCHECK(url); + if (!url) + return 0; + // Verify param: cookie; type: struct_byref_const + DCHECK(cookie); + if (!cookie) + return 0; + + // Translate param: cookie; type: struct_byref_const + CefCookie cookieObj; + if (cookie) + cookieObj.Set(*cookie, false); + + // Execute + bool _retval = CefSetCookie( + CefString(url), + cookieObj); + + // Return type: bool + return _retval; +} + +CEF_EXPORT int cef_delete_cookies(const cef_string_t* url, + const cef_string_t* cookie_name) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Unverified params: url, cookie_name + + // Execute + bool _retval = CefDeleteCookies( + CefString(url), + CefString(cookie_name)); + + // Return type: bool + return _retval; +} + +CEF_EXPORT int cef_set_cookie_path(const cef_string_t* path) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Unverified params: path + + // Execute + bool _retval = CefSetCookiePath( + CefString(path)); + + // Return type: bool + return _retval; +} + CEF_EXPORT int cef_add_cross_origin_whitelist_entry( const cef_string_t* source_origin, const cef_string_t* target_protocol, const cef_string_t* target_domain, int allow_target_subdomains) { diff --git a/libcef_dll/wrapper/libcef_dll_wrapper.cc b/libcef_dll/wrapper/libcef_dll_wrapper.cc index f275c1d8b..9f00bc4a1 100644 --- a/libcef_dll/wrapper/libcef_dll_wrapper.cc +++ b/libcef_dll/wrapper/libcef_dll_wrapper.cc @@ -12,6 +12,8 @@ #include "include/cef_app.h" #include "include/capi/cef_app_capi.h" +#include "include/cef_cookie.h" +#include "include/capi/cef_cookie_capi.h" #include "include/cef_origin_whitelist.h" #include "include/capi/cef_origin_whitelist_capi.h" #include "include/cef_scheme.h" @@ -57,7 +59,6 @@ #include "libcef_dll/cpptoc/web_urlrequest_client_cpptoc.h" #include "libcef_dll/cpptoc/write_handler_cpptoc.h" #include "libcef_dll/ctocpp/browser_ctocpp.h" -#include "libcef_dll/ctocpp/cookie_manager_ctocpp.h" #include "libcef_dll/ctocpp/domdocument_ctocpp.h" #include "libcef_dll/ctocpp/domevent_ctocpp.h" #include "libcef_dll/ctocpp/domnode_ctocpp.h" @@ -115,7 +116,6 @@ CEF_GLOBAL void CefShutdown() { // Check that all wrapper objects have been destroyed DCHECK_EQ(CefBrowserCToCpp::DebugObjCt, 0); DCHECK_EQ(CefContentFilterCppToC::DebugObjCt, 0); - DCHECK_EQ(CefCookieManagerCToCpp::DebugObjCt, 0); DCHECK_EQ(CefCookieVisitorCppToC::DebugObjCt, 0); DCHECK_EQ(CefDOMDocumentCToCpp::DebugObjCt, 0); DCHECK_EQ(CefDOMEventCToCpp::DebugObjCt, 0); @@ -187,6 +187,90 @@ CEF_GLOBAL void CefQuitMessageLoop() { cef_quit_message_loop(); } +CEF_GLOBAL bool CefVisitAllCookies(CefRefPtr visitor) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: visitor; type: refptr_diff + DCHECK(visitor.get()); + if (!visitor.get()) + return false; + + // Execute + int _retval = cef_visit_all_cookies( + CefCookieVisitorCppToC::Wrap(visitor)); + + // Return type: bool + return _retval?true:false; +} + +CEF_GLOBAL bool CefVisitUrlCookies(const CefString& url, bool includeHttpOnly, + CefRefPtr visitor) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: url; type: string_byref_const + DCHECK(!url.empty()); + if (url.empty()) + return false; + // Verify param: visitor; type: refptr_diff + DCHECK(visitor.get()); + if (!visitor.get()) + return false; + + // Execute + int _retval = cef_visit_url_cookies( + url.GetStruct(), + includeHttpOnly, + CefCookieVisitorCppToC::Wrap(visitor)); + + // Return type: bool + return _retval?true:false; +} + +CEF_GLOBAL bool CefSetCookie(const CefString& url, const CefCookie& cookie) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: url; type: string_byref_const + DCHECK(!url.empty()); + if (url.empty()) + return false; + + // Execute + int _retval = cef_set_cookie( + url.GetStruct(), + &cookie); + + // Return type: bool + return _retval?true:false; +} + +CEF_GLOBAL bool CefDeleteCookies(const CefString& url, + const CefString& cookie_name) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Unverified params: url, cookie_name + + // Execute + int _retval = cef_delete_cookies( + url.GetStruct(), + cookie_name.GetStruct()); + + // Return type: bool + return _retval?true:false; +} + +CEF_GLOBAL bool CefSetCookiePath(const CefString& path) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Unverified params: path + + // Execute + int _retval = cef_set_cookie_path( + path.GetStruct()); + + // Return type: bool + return _retval?true:false; +} + CEF_GLOBAL bool CefAddCrossOriginWhitelistEntry(const CefString& source_origin, const CefString& target_protocol, const CefString& target_domain, bool allow_target_subdomains) { diff --git a/tests/unittests/cookie_unittest.cc b/tests/unittests/cookie_unittest.cc index 441aa08ec..b0c096087 100644 --- a/tests/unittests/cookie_unittest.cc +++ b/tests/unittests/cookie_unittest.cc @@ -1,11 +1,10 @@ -// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights // reserved. Use of this source code is governed by a BSD-style license that // can be found in the LICENSE file. #include #include "include/cef_cookie.h" #include "include/cef_runnable.h" -#include "tests/unittests/test_handler.h" #include "tests/unittests/test_suite.h" #include "base/scoped_temp_dir.h" #include "base/synchronization/waitable_event.h" @@ -19,19 +18,17 @@ const char* kTestPath = "/path/to/cookietest"; typedef std::vector CookieVector; -void IOT_Set(CefRefPtr manager, - const CefString& url, CookieVector* cookies, +void IOT_Set(const CefString& url, CookieVector* cookies, base::WaitableEvent* event) { CookieVector::const_iterator it = cookies->begin(); for (; it != cookies->end(); ++it) - EXPECT_TRUE(manager->SetCookie(url, *it)); + EXPECT_TRUE(CefSetCookie(url, *it)); event->Signal(); } -void IOT_Delete(CefRefPtr manager, - const CefString& url, const CefString& cookie_name, +void IOT_Delete(const CefString& url, const CefString& cookie_name, base::WaitableEvent* event) { - EXPECT_TRUE(manager->DeleteCookies(url, cookie_name)); + EXPECT_TRUE(CefDeleteCookies(url, cookie_name)); event->Signal(); } @@ -62,29 +59,10 @@ class TestVisitor : public CefCookieVisitor { IMPLEMENT_REFCOUNTING(TestVisitor); }; -// Set the cookies. -void SetCookies(CefRefPtr manager, - const CefString& url, CookieVector& cookies, - base::WaitableEvent& event) { - CefPostTask(TID_IO, NewCefRunnableFunction(IOT_Set, manager, url, - &cookies, &event)); - event.Wait(); -} - -// Delete the cookie. -void DeleteCookies(CefRefPtr manager, - const CefString& url, const CefString& cookie_name, - base::WaitableEvent& event) { - CefPostTask(TID_IO, NewCefRunnableFunction(IOT_Delete, manager, url, - cookie_name, &event)); - event.Wait(); -} - // Create a test cookie. If |withDomain| is true a domain cookie will be // created, otherwise a host cookie will be created. -void CreateCookie(CefRefPtr manager, - CefCookie& cookie, bool withDomain, - base::WaitableEvent& event) { +void CreateCookie(CefCookie& cookie, bool withDomain, + base::WaitableEvent& event) { CefString(&cookie.name).FromASCII("my_cookie"); CefString(&cookie.value).FromASCII("My Value"); if (withDomain) @@ -101,19 +79,21 @@ void CreateCookie(CefRefPtr manager, CookieVector cookies; cookies.push_back(cookie); - SetCookies(manager, kTestUrl, cookies, event); + // Set the cookie. + CefPostTask(TID_IO, NewCefRunnableFunction(IOT_Set, kTestUrl, &cookies, + &event)); + event.Wait(); } // Retrieve the test cookie. If |withDomain| is true check that the cookie // is a domain cookie, otherwise a host cookie. if |deleteCookies| is true // the cookie will be deleted when it's retrieved. -void GetCookie(CefRefPtr manager, - const CefCookie& cookie, bool withDomain, +void GetCookie(const CefCookie& cookie, bool withDomain, base::WaitableEvent& event, bool deleteCookies) { CookieVector cookies; // Get the cookie and delete it. - EXPECT_TRUE(manager->VisitUrlCookies(kTestUrl, false, + EXPECT_TRUE(CefVisitUrlCookies(kTestUrl, false, new TestVisitor(&cookies, deleteCookies, &event))); event.Wait(); @@ -140,41 +120,17 @@ void GetCookie(CefRefPtr manager, EXPECT_EQ(cookie.expires.millisecond, cookie_read.expires.millisecond); } -// Visit URL cookies. -void VisitUrlCookies(CefRefPtr manager, - const CefString& url, - bool includeHttpOnly, - CookieVector& cookies, - bool deleteCookies, - base::WaitableEvent& event) { - EXPECT_TRUE(manager->VisitUrlCookies(url, includeHttpOnly, - new TestVisitor(&cookies, deleteCookies, &event))); - event.Wait(); -} - -// Visit all cookies. -void VisitAllCookies(CefRefPtr manager, - CookieVector& cookies, - bool deleteCookies, - base::WaitableEvent& event) { - EXPECT_TRUE(manager->VisitAllCookies( - new TestVisitor(&cookies, deleteCookies, &event))); - event.Wait(); -} - // Verify that no cookies exist. If |withUrl| is true it will only check for // cookies matching the URL. -void VerifyNoCookies(CefRefPtr manager, - base::WaitableEvent& event, bool withUrl) { +void VerifyNoCookies(base::WaitableEvent& event, bool withUrl) { CookieVector cookies; // Verify that the cookie has been deleted. if (withUrl) { - EXPECT_TRUE(manager->VisitUrlCookies(kTestUrl, false, + EXPECT_TRUE(CefVisitUrlCookies(kTestUrl, false, new TestVisitor(&cookies, false, &event))); } else { - EXPECT_TRUE(manager->VisitAllCookies( - new TestVisitor(&cookies, false, &event))); + EXPECT_TRUE(CefVisitAllCookies(new TestVisitor(&cookies, false, &event))); } event.Wait(); @@ -182,42 +138,46 @@ void VerifyNoCookies(CefRefPtr manager, } // Delete all system cookies. -void DeleteAllCookies(CefRefPtr manager, - base::WaitableEvent& event) { - CefPostTask(TID_IO, NewCefRunnableFunction(IOT_Delete, manager, CefString(), +void DeleteAllCookies(base::WaitableEvent& event) { + CefPostTask(TID_IO, NewCefRunnableFunction(IOT_Delete, CefString(), CefString(), &event)); event.Wait(); } -void TestDomainCookie(CefRefPtr manager) { +} // namespace + +// Test creation of a domain cookie. +TEST(CookieTest, DomainCookie) { base::WaitableEvent event(false, false); CefCookie cookie; // Create a domain cookie. - CreateCookie(manager, cookie, true, event); + CreateCookie(cookie, true, event); // Retrieve, verify and delete the domain cookie. - GetCookie(manager, cookie, true, event, true); + GetCookie(cookie, true, event, true); // Verify that the cookie was deleted. - VerifyNoCookies(manager, event, true); + VerifyNoCookies(event, true); } -void TestHostCookie(CefRefPtr manager) { +// Test creation of a host cookie. +TEST(CookieTest, HostCookie) { base::WaitableEvent event(false, false); CefCookie cookie; // Create a host cookie. - CreateCookie(manager, cookie, false, event); + CreateCookie(cookie, false, event); // Retrieve, verify and delete the host cookie. - GetCookie(manager, cookie, false, event, true); + GetCookie(cookie, false, event, true); // Verify that the cookie was deleted. - VerifyNoCookies(manager, event, true); + VerifyNoCookies(event, true); } -void TestMultipleCookies(CefRefPtr manager) { +// Test creation of multiple cookies. +TEST(CookieTest, MultipleCookies) { base::WaitableEvent event(false, false); std::stringstream ss; int i; @@ -241,11 +201,15 @@ void TestMultipleCookies(CefRefPtr manager) { } // Set the cookies. - SetCookies(manager, kTestUrl, cookies, event); + CefPostTask(TID_IO, NewCefRunnableFunction(IOT_Set, kTestUrl, &cookies, + &event)); + event.Wait(); cookies.clear(); // Get the cookies without deleting them. - VisitUrlCookies(manager, kTestUrl, false, cookies, false, event); + EXPECT_TRUE(CefVisitUrlCookies(kTestUrl, false, + new TestVisitor(&cookies, false, &event))); + event.Wait(); EXPECT_EQ((CookieVector::size_type)kNumCookies, cookies.size()); @@ -264,10 +228,14 @@ void TestMultipleCookies(CefRefPtr manager) { cookies.clear(); // Delete the 2nd cookie. - DeleteCookies(manager, kTestUrl, CefString("my_cookie1"), event); + CefPostTask(TID_IO, NewCefRunnableFunction(IOT_Delete, kTestUrl, + CefString("my_cookie1"), &event)); + event.Wait(); // Verify that the cookie has been deleted. - VisitUrlCookies(manager, kTestUrl, false, cookies, false, event); + EXPECT_TRUE(CefVisitUrlCookies(kTestUrl, false, + new TestVisitor(&cookies, false, &event))); + event.Wait(); EXPECT_EQ((CookieVector::size_type)3, cookies.size()); EXPECT_EQ(CefString(&cookies[0].name), "my_cookie0"); @@ -277,10 +245,14 @@ void TestMultipleCookies(CefRefPtr manager) { cookies.clear(); // Delete the rest of the cookies. - DeleteCookies(manager, kTestUrl, CefString(), event); + CefPostTask(TID_IO, NewCefRunnableFunction(IOT_Delete, kTestUrl, + CefString(), &event)); + event.Wait(); // Verify that the cookies have been deleted. - VisitUrlCookies(manager, kTestUrl, false, cookies, false, event); + EXPECT_TRUE(CefVisitUrlCookies(kTestUrl, false, + new TestVisitor(&cookies, false, &event))); + event.Wait(); EXPECT_EQ((CookieVector::size_type)0, cookies.size()); @@ -299,26 +271,33 @@ void TestMultipleCookies(CefRefPtr manager) { } // Delete all of the cookies using the visitor. - VisitUrlCookies(manager, kTestUrl, false, cookies, true, event); + EXPECT_TRUE(CefVisitUrlCookies(kTestUrl, false, + new TestVisitor(&cookies, true, &event))); + event.Wait(); cookies.clear(); // Verify that the cookies have been deleted. - VisitUrlCookies(manager, kTestUrl, false, cookies, false, event); + EXPECT_TRUE(CefVisitUrlCookies(kTestUrl, false, + new TestVisitor(&cookies, false, &event))); + event.Wait(); EXPECT_EQ((CookieVector::size_type)0, cookies.size()); } -void TestAllCookies(CefRefPtr manager) { +TEST(CookieTest, AllCookies) { base::WaitableEvent event(false, false); CookieVector cookies; // Delete all system cookies just in case something is left over from a // different test. - DeleteCookies(manager, CefString(), CefString(), event); + CefPostTask(TID_IO, NewCefRunnableFunction(IOT_Delete, CefString(), + CefString(), &event)); + event.Wait(); // Verify that all system cookies have been deleted. - VisitAllCookies(manager, cookies, false, event); + EXPECT_TRUE(CefVisitAllCookies(new TestVisitor(&cookies, false, &event))); + event.Wait(); EXPECT_EQ((CookieVector::size_type)0, cookies.size()); @@ -329,7 +308,8 @@ void TestAllCookies(CefRefPtr manager) { CefString(&cookie1.value).FromASCII("My Value 1"); cookies.push_back(cookie1); - SetCookies(manager, kUrl1, cookies, event); + CefPostTask(TID_IO, NewCefRunnableFunction(IOT_Set, kUrl1, &cookies, &event)); + event.Wait(); cookies.clear(); CefCookie cookie2; @@ -338,11 +318,13 @@ void TestAllCookies(CefRefPtr manager) { CefString(&cookie2.value).FromASCII("My Value 2"); cookies.push_back(cookie2); - SetCookies(manager, kUrl2, cookies, event); + CefPostTask(TID_IO, NewCefRunnableFunction(IOT_Set, kUrl2, &cookies, &event)); + event.Wait(); cookies.clear(); // Verify that all system cookies can be retrieved. - VisitAllCookies(manager, cookies, false, event); + EXPECT_TRUE(CefVisitAllCookies(new TestVisitor(&cookies, false, &event))); + event.Wait(); EXPECT_EQ((CookieVector::size_type)2, cookies.size()); EXPECT_EQ(CefString(&cookies[0].name), "my_cookie1"); @@ -354,7 +336,9 @@ void TestAllCookies(CefRefPtr manager) { cookies.clear(); // Verify that the cookies can be retrieved separately. - VisitUrlCookies(manager, kUrl1, false, cookies, false, event); + EXPECT_TRUE(CefVisitUrlCookies(kUrl1, false, + new TestVisitor(&cookies, false, &event))); + event.Wait(); EXPECT_EQ((CookieVector::size_type)1, cookies.size()); EXPECT_EQ(CefString(&cookies[0].name), "my_cookie1"); @@ -362,7 +346,9 @@ void TestAllCookies(CefRefPtr manager) { EXPECT_EQ(CefString(&cookies[0].domain), "www.foo.com"); cookies.clear(); - VisitUrlCookies(manager, kUrl2, false, cookies, false, event); + EXPECT_TRUE(CefVisitUrlCookies(kUrl2, false, + new TestVisitor(&cookies, false, &event))); + event.Wait(); EXPECT_EQ((CookieVector::size_type)1, cookies.size()); EXPECT_EQ(CefString(&cookies[0].name), "my_cookie2"); @@ -371,314 +357,51 @@ void TestAllCookies(CefRefPtr manager) { cookies.clear(); // Delete all of the system cookies. - DeleteAllCookies(manager, event); + DeleteAllCookies(event); // Verify that all system cookies have been deleted. - VerifyNoCookies(manager, event, false); + VerifyNoCookies(event, false); } -void TestChangeDirectory(CefRefPtr manager, - const CefString& original_dir) { +TEST(CookieTest, ChangeDirectory) { base::WaitableEvent event(false, false); CefCookie cookie; + std::string cache_path; + CefTestSuite::GetCachePath(cache_path); + ScopedTempDir temp_dir; // Create a new temporary directory. EXPECT_TRUE(temp_dir.CreateUniqueTempDir()); // Delete all of the system cookies. - DeleteAllCookies(manager, event); + DeleteAllCookies(event); // Set the new temporary directory as the storage location. - EXPECT_TRUE(manager->SetStoragePath(temp_dir.path().value())); - - // Wait for the storage location change to complete on the IO thread. - WaitForIOThread(); + EXPECT_TRUE(CefSetCookiePath(temp_dir.path().value())); // Verify that no cookies exist. - VerifyNoCookies(manager, event, true); + VerifyNoCookies(event, true); // Create a domain cookie. - CreateCookie(manager, cookie, true, event); + CreateCookie(cookie, true, event); // Retrieve and verify the domain cookie. - GetCookie(manager, cookie, true, event, false); + GetCookie(cookie, true, event, false); // Restore the original storage location. - EXPECT_TRUE(manager->SetStoragePath(original_dir)); - - // Wait for the storage location change to complete on the IO thread. - WaitForIOThread(); + EXPECT_TRUE(CefSetCookiePath(cache_path)); // Verify that no cookies exist. - VerifyNoCookies(manager, event, true); + VerifyNoCookies(event, true); // Set the new temporary directory as the storage location. - EXPECT_TRUE(manager->SetStoragePath(temp_dir.path().value())); - - // Wait for the storage location change to complete on the IO thread. - WaitForIOThread(); + EXPECT_TRUE(CefSetCookiePath(temp_dir.path().value())); // Retrieve and verify the domain cookie that was set previously. - GetCookie(manager, cookie, true, event, false); + GetCookie(cookie, true, event, false); // Restore the original storage location. - EXPECT_TRUE(manager->SetStoragePath(original_dir)); - - // Wait for the storage location change to complete on the IO thread. - WaitForIOThread(); -} - -} // namespace - -// Test creation of a domain cookie. -TEST(CookieTest, DomainCookieGlobal) { - CefRefPtr manager = CefCookieManager::GetGlobalManager(); - EXPECT_TRUE(manager.get()); - - TestDomainCookie(manager); -} - -// Test creation of a domain cookie. -TEST(CookieTest, DomainCookieInMemory) { - CefRefPtr manager = - CefCookieManager::CreateManager(CefString()); - EXPECT_TRUE(manager.get()); - - TestDomainCookie(manager); -} - -// Test creation of a domain cookie. -TEST(CookieTest, DomainCookieOnDisk) { - ScopedTempDir temp_dir; - - // Create a new temporary directory. - EXPECT_TRUE(temp_dir.CreateUniqueTempDir()); - - CefRefPtr manager = - CefCookieManager::CreateManager(temp_dir.path().value()); - EXPECT_TRUE(manager.get()); - - TestDomainCookie(manager); -} - -// Test creation of a host cookie. -TEST(CookieTest, HostCookieGlobal) { - CefRefPtr manager = CefCookieManager::GetGlobalManager(); - EXPECT_TRUE(manager.get()); - - TestHostCookie(manager); -} - -// Test creation of a host cookie. -TEST(CookieTest, HostCookieInMemory) { - CefRefPtr manager = - CefCookieManager::CreateManager(CefString()); - EXPECT_TRUE(manager.get()); - - TestHostCookie(manager); -} - -// Test creation of a host cookie. -TEST(CookieTest, HostCookieOnDisk) { - ScopedTempDir temp_dir; - - // Create a new temporary directory. - EXPECT_TRUE(temp_dir.CreateUniqueTempDir()); - - CefRefPtr manager = - CefCookieManager::CreateManager(temp_dir.path().value()); - EXPECT_TRUE(manager.get()); - - TestHostCookie(manager); -} - -// Test creation of multiple cookies. -TEST(CookieTest, MultipleCookiesGlobal) { - CefRefPtr manager = CefCookieManager::GetGlobalManager(); - EXPECT_TRUE(manager.get()); - - TestMultipleCookies(manager); -} - -// Test creation of multiple cookies. -TEST(CookieTest, MultipleCookiesInMemory) { - CefRefPtr manager = - CefCookieManager::CreateManager(CefString()); - EXPECT_TRUE(manager.get()); - - TestMultipleCookies(manager); -} - -// Test creation of multiple cookies. -TEST(CookieTest, MultipleCookiesOnDisk) { - ScopedTempDir temp_dir; - - // Create a new temporary directory. - EXPECT_TRUE(temp_dir.CreateUniqueTempDir()); - - CefRefPtr manager = - CefCookieManager::CreateManager(temp_dir.path().value()); - EXPECT_TRUE(manager.get()); - - TestMultipleCookies(manager); -} - -TEST(CookieTest, AllCookiesGlobal) { - CefRefPtr manager = CefCookieManager::GetGlobalManager(); - EXPECT_TRUE(manager.get()); - - TestAllCookies(manager); -} - -TEST(CookieTest, AllCookiesInMemory) { - CefRefPtr manager = - CefCookieManager::CreateManager(CefString()); - EXPECT_TRUE(manager.get()); - - TestAllCookies(manager); -} - -TEST(CookieTest, AllCookiesOnDisk) { - ScopedTempDir temp_dir; - - // Create a new temporary directory. - EXPECT_TRUE(temp_dir.CreateUniqueTempDir()); - - CefRefPtr manager = - CefCookieManager::CreateManager(temp_dir.path().value()); - EXPECT_TRUE(manager.get()); - - TestAllCookies(manager); -} - -TEST(CookieTest, ChangeDirectoryGlobal) { - CefRefPtr manager = CefCookieManager::GetGlobalManager(); - EXPECT_TRUE(manager.get()); - - std::string cache_path; - CefTestSuite::GetCachePath(cache_path); - - TestChangeDirectory(manager, cache_path); -} - -TEST(CookieTest, ChangeDirectoryCreated) { - CefRefPtr manager = - CefCookieManager::CreateManager(CefString()); - EXPECT_TRUE(manager.get()); - - TestChangeDirectory(manager, CefString()); -} - - -namespace { - -const char* kCookieUrl1 = "http://tests/cookie1.html"; -const char* kCookieUrl2 = "http://tests/cookie2.html"; - -class CookieTestHandler : public TestHandler { - public: - CookieTestHandler() {} - - virtual void RunTest() OVERRIDE { - // Create =new in-memory managers. - manager1_ = CefCookieManager::CreateManager(CefString()); - manager2_ = CefCookieManager::CreateManager(CefString()); - - std::string page = - "" - "" - "COOKIE TEST1"; - AddResource(kCookieUrl1, page, "text/html"); - - page = - "" - "" - "COOKIE TEST2"; - AddResource(kCookieUrl2, page, "text/html"); - - // Create the browser - CreateBrowser(kCookieUrl1); - } - - virtual void OnLoadEnd(CefRefPtr browser, - CefRefPtr frame, - int httpStatusCode) OVERRIDE { - std::string url = frame->GetURL(); - if (url == kCookieUrl1) { - got_load_end1_.yes(); - VerifyCookie(manager1_, url, "name1", "value1", got_cookie1_); - - // Go to the next URL - frame->LoadURL(kCookieUrl2); - } else { - got_load_end2_.yes(); - VerifyCookie(manager2_, url, "name2", "value2", got_cookie2_); - - DestroyTest(); - } - } - - virtual CefRefPtr GetCookieManager( - CefRefPtr browser) OVERRIDE { - std::string url = browser->GetMainFrame()->GetURL(); - if (url == kCookieUrl1) { - // Return the first cookie manager. - got_cookie_manager1_.yes(); - return manager1_; - } else { - // Return the second cookie manager. - got_cookie_manager2_.yes(); - return manager2_; - } - } - - // Verify that the cookie was set successfully. - void VerifyCookie(CefRefPtr manager, - const std::string& url, - const std::string& name, - const std::string& value, - TrackCallback& callback) { - base::WaitableEvent event(false, false); - CookieVector cookies; - - // Get the cookie. - VisitUrlCookies(manager, url, false, cookies, false, event); - - if (cookies.size() == 1 && CefString(&cookies[0].name) == name && - CefString(&cookies[0].value) == value) { - callback.yes(); - } - } - - CefRefPtr manager1_; - CefRefPtr manager2_; - - TrackCallback got_cookie_manager1_; - TrackCallback got_cookie_manager2_; - TrackCallback got_load_end1_; - TrackCallback got_load_end2_; - TrackCallback got_cookie1_; - TrackCallback got_cookie2_; -}; - -} // namespace - - -// Verify use of multiple cookie managers. -TEST(CookieTest, GetCookieManager) { - CefRefPtr handler = new CookieTestHandler(); - 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_); - EXPECT_TRUE(handler->got_cookie2_); + EXPECT_TRUE(CefSetCookiePath(cache_path)); }