LOG(INFO) << msg_type;
#define TYPE_BEGIN(x) (!strncmp(msg_type, x, strlen(x)))
#define TYPE_IS(x) (!strcmp(msg_type, x))
+ auto extension_server = extensions::XWalkExtensionServer::GetInstance();
if (TYPE_BEGIN("xwalk://")) {
- auto extension_server = extensions::XWalkExtensionServer::GetInstance();
extension_server->HandleIPCMessage(msg);
} else {
Eina_Stringshare* msg_id = msg->GetId();
Eina_Stringshare* msg_value = msg->GetValue();
if (TYPE_IS("tizen://exit")) {
atom::Browser::Get()->Quit();
+ } else if (TYPE_IS("tizen://deleteAllCookies")) {
+ atom::Browser::Get()->ClearCookie();
+ extension_server->SendWrtMessage(msg_type, msg_ref_id, "success");
}
-
eina_stringshare_del(msg_ref_id);
eina_stringshare_del(msg_id);
eina_stringshare_del(msg_value);
return blob_reader_.get();
}
+net::URLRequestContextGetter* AtomBrowserContext::CreateRequestContext(
+ content::ProtocolHandlerMap* protocol_handlers,
+ content::URLRequestInterceptorScopedVector protocol_interceptors) {
+ brightray::BrowserContext::CreateRequestContext(protocol_handlers,
+ std::move(protocol_interceptors));
+
+ CookieManager* manager = Browser::Get()->GetCookieManager();
+ manager->SetRequestContextGetter(url_request_context_getter());
+ return url_request_context_getter();
+}
+
// static
scoped_refptr<AtomBrowserContext> AtomBrowserContext::From(
const std::string& partition, bool in_memory,
std::vector<std::string> GetCookieableSchemes() override;
net::TransportSecurityState::RequireCTDelegate* GetRequireCTDelegate()
override;
+ net::URLRequestContextGetter* CreateRequestContext(
+ content::ProtocolHandlerMap* protocol_handlers,
+ content::URLRequestInterceptorScopedVector request_interceptors) override;
// content::BrowserContext:
content::DownloadManagerDelegate* GetDownloadManagerDelegate() override;
* limitations under the License.
*/
+#include <app.h>
+
#include "atom/common/api/api_messages.h"
#include "common/string_utils.h"
#include "tizen/browser/tizen_browser_parts.h"
TizenBrowserParts::TizenBrowserParts()
: locale_manager_(new common::LocaleManager()),
+ cookie_manager_(new CookieManager()),
is_suspended_(false) {
}
} else {
security_model_version_ = 1;
}
+
+ std::unique_ptr<char, decltype(std::free)*> path{app_get_data_path(),
+ std::free};
+ if (path.get() != NULL) {
+ std::string app_data_path = path.get();
+ cookie_manager_->SetCookiePolicy(EWK_COOKIE_ACCEPT_POLICY_ALWAYS);
+ std::string cookie_path = app_data_path + ".cookie";
+ LOG(ERROR) << "Cookie path " << cookie_path;
+ cookie_manager_->SetStoragePath(cookie_path, true ,
+ EWK_COOKIE_PERSISTENT_STORAGE_SQLITE);
+ }
+
tizen::VibrationManager::CreateInstance();
}
+void TizenBrowserParts::ClearCookie() {
+ cookie_manager_->DeleteCookiesAsync();
+}
+
void TizenBrowserParts::GetCSP(std::string &csp_rule, std::string &csp_report_rule) {
csp_rule = csp_rule_;
csp_report_rule = csp_report_rule_;
#include "tizen/common/application_data.h"
#include "tizen/common/locale_manager.h"
#include "tizen/common/resource_manager.h"
+#include "vendor/brightray/browser/efl/cookie_manager.h"
namespace tizen {
bool ShouldAllowNavigation(const std::string &url);
void Initialize();
+ void ClearCookie();
+ CookieManager* GetCookieManager() { return cookie_manager_; }
+
protected:
std::unique_ptr<common::LocaleManager> locale_manager_;
std::unique_ptr<common::ResourceManager> resource_manager_;
void SetLongPollingTimeout(content::RenderViewHost* render_view_host);
common::ApplicationData* app_data_;
+ CookieManager* cookie_manager_;
int security_model_version_;
bool is_suspended_;
std::string csp_rule_;
ewk_ipc_wrt_message_data_value_set(data, reply_str.c_str());
}
+void XWalkExtensionServer::SendWrtMessage(
+ Eina_Stringshare* type, Eina_Stringshare* id, const char* val) {
+ Ewk_IPC_Wrt_Message_Data* ans = ewk_ipc_wrt_message_data_new();
+ ewk_ipc_wrt_message_data_type_set(ans, type);
+ ewk_ipc_wrt_message_data_id_set(ans, id);
+ ewk_ipc_wrt_message_data_value_set(ans, val);
+ WrtWidgetHost::Get()->SendWrtMessage(*ans);
+ ewk_ipc_wrt_message_data_del(ans);
+}
+
void XWalkExtensionServer::HandleCreateInstance(
Ewk_IPC_Wrt_Message_Data* data) {
Eina_Stringshare* extension_name = ewk_ipc_wrt_message_data_value_get(data);
void Shutdown();
void LoadUserExtensions(const std::string app_path);
+ void SendWrtMessage(Eina_Stringshare* type,
+ Eina_Stringshare* id, const char* val);
private:
XWalkExtensionServer();
'<(libchromiumcontent_src_dir)/tizen_src/chromium_impl',
'<(libchromiumcontent_src_dir)/skia/config',
'<(libchromiumcontent_src_dir)/third_party/boringssl/src/include',
+ '<(libchromiumcontent_src_dir)/third_party/leveldatabase/src/include',
'<(libchromiumcontent_src_dir)/third_party/skia/include/core',
'<(libchromiumcontent_src_dir)/third_party/skia/include/config',
'<(libchromiumcontent_src_dir)/third_party/mojo/src',
'<(libchromiumcontent_src_dir)/gpu',
'<(libchromiumcontent_src_dir)/skia/config',
'<(libchromiumcontent_src_dir)/third_party/boringssl/src/include',
+ '<(libchromiumcontent_src_dir)/third_party/leveldatabase/src/include',
'<(libchromiumcontent_src_dir)/third_party/skia/include/core',
'<(libchromiumcontent_src_dir)/third_party/skia/include/config',
'<(libchromiumcontent_src_dir)/third_party/icu/source/common',
#include "browser/browser_context.h"
+#include "base/files/file_path.h"
+#include "base/path_service.h"
+#include "base/strings/string_util.h"
#include "browser/media/media_device_id_salt.h"
#include "browser/brightray_paths.h"
#include "browser/browser_client.h"
#include "browser/special_storage_policy.h"
#include "browser/zoom_level_delegate.h"
#include "common/application_info.h"
-
-#include "base/files/file_path.h"
-#include "base/path_service.h"
-
#include "components/prefs/json_pref_store.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/pref_service.h"
#include "components/prefs/pref_service_factory.h"
-
-#include "base/strings/string_util.h"
+#include "content/common/paths_efl.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/resource_context.h"
#include "content/public/browser/storage_partition.h"
resource_context_(new ResourceContext),
storage_policy_(new SpecialStoragePolicy),
weak_factory_(this) {
+#if defined(OS_TIZEN)
+ if (!PathService::Get(PathsEfl::DIR_USER_DATA, &path_)) {
+#else
if (!PathService::Get(DIR_USER_DATA, &path_)) {
+#endif
PathService::Get(DIR_APP_DATA, &path_);
path_ = path_.Append(base::FilePath::FromUTF8Unsafe(GetApplicationName()));
PathService::Override(DIR_USER_DATA, path_);
--- /dev/null
+// Copyright 2018 Samsung Electronics. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cookie_manager.h"
+
+#include "utility"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/stl_util.h"
+#include "base/synchronization/waitable_event.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/browser/storage_partition_impl.h"
+#include "net/base/net_errors.h"
+#include "net/base/static_cookie_policy.h"
+#include "net/cookies/canonical_cookie.h"
+#include "net/cookies/cookie_util.h"
+#include "net/cookies/parsed_cookie.h"
+#include "net/cookies/cookie_monster.h"
+#include "net/cookies/cookie_options.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "tizen_src/ewk/efl_integration/browser/scoped_allow_wait_for_legacy_web_view_api.h"
+#include "url/gurl.h"
+
+#include <Eina.h>
+
+using content::BrowserThread;
+using net::CookieList;
+using net::CookieMonster;
+using base::AutoLock;
+
+namespace {
+
+void TriggerHostPolicyGetCallbackAsyncOnUIThread(Ewk_Cookie_Accept_Policy policy,
+ Ewk_Cookie_Manager_Policy_Async_Get_Cb callback,
+ void *data) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ if (callback)
+ (*callback)(policy, data);
+}
+
+}
+
+struct CookieManager::EwkGetHostCallback {
+ public:
+ EwkGetHostCallback(AsyncHostnamesGetCb callback, void* user_data)
+ : callback_(callback),
+ user_data_(user_data) {}
+
+ /* LCOV_EXCL_START */
+ void TriggerCallback(const net::CookieList& cookies) {
+ Eina_List* hostnames = 0;
+ if (cookies.size()) {
+ net::CookieList::const_iterator it = cookies.begin();
+ while (it != cookies.end()) {
+ hostnames = eina_list_append(hostnames, eina_stringshare_add(it->Name().c_str()));
+ ++it;
+ }
+ }
+ (*callback_)(hostnames, NULL, user_data_);
+ void* item = 0;
+ EINA_LIST_FREE(hostnames, item)
+ eina_stringshare_del(static_cast<Eina_Stringshare*>(item));
+ }
+ /* LCOV_EXCL_STOP */
+
+ private:
+ AsyncHostnamesGetCb callback_;
+ void* user_data_;
+};
+
+CookieManager::CookieManager()
+ : cookie_policy_(EWK_COOKIE_ACCEPT_POLICY_ALWAYS),
+ weak_ptr_factory_(this) {
+}
+
+CookieManager::~CookieManager() {
+ DeleteSessionCookiesOnIOThread();
+}
+
+void CookieManager::SetRequestContextGetter(
+ scoped_refptr<brightray::URLRequestContextGetter> getter) {
+ request_context_getter_ = getter;
+}
+
+void CookieManager::DeleteSessionCookiesOnIOThread() {
+ DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+
+ net::CookieStore* cookie_store = GetCookieStore();
+ if (cookie_store)
+ cookie_store->DeleteSessionCookiesAsync(base::Callback<void(int)>());
+}
+
+void CookieManager::DeleteCookiesOnIOThread(const std::string& url,
+ const std::string& cookie_name) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+ net::CookieStore* cookie_store = GetCookieStore();
+ if (!cookie_store)
+ return;
+
+ if (url.empty()) { // Delete all cookies.
+ cookie_store->DeleteAllAsync(net::CookieMonster::DeleteCallback());
+ return;
+ }
+
+ GURL gurl(url);
+ if (!gurl.is_valid())
+ return;
+
+ if (cookie_name.empty()) {
+ // Delete all matching host cookies.
+ cookie_store->DeleteAllCreatedBetweenWithPredicateAsync(
+ base::Time(),
+ base::Time::Max(),
+ content::StoragePartitionImpl::CreatePredicateForHostCookies(gurl),
+ net::CookieMonster::DeleteCallback());
+ } else {
+ // Delete all matching host and domain cookies.
+ cookie_store->DeleteCookieAsync(gurl, cookie_name, base::Closure());
+ }
+}
+
+void CookieManager::DeleteCookiesAsync(const std::string& url,
+ const std::string& cookie_name) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ BrowserThread::PostTask(
+ BrowserThread::IO, FROM_HERE,
+ base::Bind(&CookieManager::DeleteCookiesOnIOThread,
+ base::Unretained(this), url, cookie_name));
+}
+
+static void SetStoragePathOnIOThread(
+ scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+ const std::string& path,
+ bool persist_session_cookies,
+ Ewk_Cookie_Persistent_Storage file_storage_type) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ LOG(ERROR)<<__FUNCTION__;
+ if (request_context_getter.get()) {
+ base::FilePath storage_path(path);
+ request_context_getter->SetCookieStoragePath(storage_path, persist_session_cookies,
+ file_storage_type);
+ }
+}
+
+void CookieManager::SetStoragePath(const std::string& path,
+ bool persist_session_cookies,
+ Ewk_Cookie_Persistent_Storage file_storage_type) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ LOG(ERROR)<<__FUNCTION__;
+
+ scoped_refptr<brightray::URLRequestContextGetter> context_getter = GetContextGetter();
+ if (context_getter.get()) {
+ BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+ base::Bind(SetStoragePathOnIOThread,
+ context_getter,
+ path,
+ persist_session_cookies,
+ file_storage_type));
+ }
+}
+
+void CookieManager::GetAcceptPolicyAsync(Ewk_Cookie_Manager_Policy_Async_Get_Cb callback, void *data) {
+ AutoLock lock(lock_);
+ BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+ base::Bind(&TriggerHostPolicyGetCallbackAsyncOnUIThread,
+ cookie_policy_,
+ callback,
+ data));
+}
+
+/* LCOV_EXCL_START */
+void CookieManager::GetHostNamesWithCookiesAsync(AsyncHostnamesGetCb callback, void *data) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ host_callback_queue_.push(new EwkGetHostCallback(callback, data));
+ BrowserThread::PostTask(
+ BrowserThread::IO, FROM_HERE,
+ base::Bind(&CookieManager::FetchCookiesOnIOThread, GetSharedThis()));
+}
+
+void CookieManager::FetchCookiesOnIOThread() {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+ net::CookieStore* cookie_store = GetCookieStore();
+ if (cookie_store) {
+ cookie_store->GetAllCookiesAsync(base::Bind(&CookieManager::OnFetchComplete,
+ GetSharedThis()));
+ } else {
+ OnFetchComplete(net::CookieList());
+ }
+}
+
+void CookieManager::OnFetchComplete(const net::CookieList& cookies) {
+ if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+ BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+ base::Bind(&CookieManager::OnFetchComplete,
+ GetSharedThis(),
+ cookies));
+ return;
+ }
+ if (!host_callback_queue_.empty()) {
+ EwkGetHostCallback* host_callback = host_callback_queue_.front();
+ if (host_callback) {
+ host_callback->TriggerCallback(cookies);
+ delete host_callback;
+ }
+ host_callback_queue_.pop();
+ }
+}
+/* LCOV_EXCL_STOP */
+
+bool CookieManager::GetGlobalAllowAccess() {
+ AutoLock lock(lock_);
+ if (EWK_COOKIE_ACCEPT_POLICY_ALWAYS == cookie_policy_)
+ return true;
+ else
+ return false; // LCOV_EXCL_LINE
+}
+
+void CookieManager::SetCookiePolicy(Ewk_Cookie_Accept_Policy policy) {
+ AutoLock lock(lock_);
+ cookie_policy_ = policy;
+}
+
+/* LCOV_EXCL_START */
+bool CookieManager::ShouldBlockThirdPartyCookies() {
+ AutoLock lock(lock_);
+ if (EWK_COOKIE_ACCEPT_POLICY_NO_THIRD_PARTY == cookie_policy_)
+ return true;
+ else
+ return false;
+}
+/* LCOV_EXCL_STOP */
+
+bool CookieManager::AllowCookies(const GURL& url,
+ const GURL& first_party_url,
+ bool setting_cookie) {
+ if (GetGlobalAllowAccess())
+ return true;
+
+ if (ShouldBlockThirdPartyCookies()) {
+ net::StaticCookiePolicy policy(net::StaticCookiePolicy::BLOCK_ALL_THIRD_PARTY_COOKIES);
+ int rv;
+ if (setting_cookie)
+ rv = policy.CanSetCookie(url, first_party_url);
+ else
+ rv = policy.CanGetCookies(url, first_party_url);
+
+ if (net::OK == rv)
+ return true;
+ }
+
+ return false;
+}
+
+bool CookieManager::OnCanGetCookies(const net::URLRequest& request,
+ const net::CookieList& cookie_list) {
+ return AllowCookies(request.url(), request.first_party_for_cookies(), false);
+}
+
+bool CookieManager::OnCanSetCookie(const net::URLRequest& request,
+ const std::string& cookie_line,
+ net::CookieOptions* options) {
+ return AllowCookies(request.url(), request.first_party_for_cookies(), true);
+}
+
+bool CookieManager::AllowGetCookie(const GURL& url,
+ const GURL& first_party,
+ const net::CookieList& cookie_list,
+ content::ResourceContext* context,
+ int render_process_id,
+ int render_frame_id) {
+ return AllowCookies(url, first_party, false);
+}
+
+bool CookieManager::AllowSetCookie(const GURL& url,
+ const GURL& first_party,
+ const std::string& cookie_line,
+ content::ResourceContext* context,
+ int render_process_id,
+ int render_frame_id,
+ const net::CookieOptions& options) {
+ return AllowCookies(url, first_party, true);
+}
+
+bool CookieManager::IsFileSchemeCookiesAllowed() {
+ auto cookie_monster = static_cast<net::CookieMonster*>(GetCookieStore());
+ if (!cookie_monster)
+ return false;
+
+ AutoLock lock(file_scheme_lock_);
+ return cookie_monster->IsCookieableScheme(url::kFileScheme);
+}
+
+void CookieManager::SetAcceptFileSchemeCookies(bool accept) {
+ auto cookie_monster = static_cast<net::CookieMonster*>(GetCookieStore());
+ if (!cookie_monster)
+ return; // LCOV_EXCL_LINE
+
+ std::vector<std::string> schemes(
+ CookieMonster::kDefaultCookieableSchemes,
+ CookieMonster::kDefaultCookieableSchemes +
+ CookieMonster::kDefaultCookieableSchemesCount);
+ if (accept)
+ schemes.push_back(url::kFileScheme);
+
+ AutoLock lock(file_scheme_lock_);
+ LOG(ERROR)<<__FUNCTION__;
+ cookie_monster->SetCookieableSchemes(schemes);
+}
+
+/* LCOV_EXCL_START */
+static void SignalGetCookieValueCompleted(base::WaitableEvent* completion,
+ std::string* result,
+ const std::string& value) {
+ DCHECK(completion);
+
+ *result = value;
+ completion->Signal();
+}
+
+static void GetCookieValueOnIOThread(net::CookieStore* cookie_store,
+ const GURL& host,
+ std::string* result,
+ base::WaitableEvent* completion) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ net::CookieOptions options;
+ options.set_include_httponly();
+
+ if (cookie_store) {
+ cookie_store->GetCookiesWithOptionsAsync(host,
+ options,
+ base::Bind(SignalGetCookieValueCompleted,
+ completion,
+ result));
+ } else {
+ DCHECK(completion);
+ completion->Signal();
+ }
+}
+
+std::string CookieManager::GetCookiesForURL(const std::string& url) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ net::CookieStore* cookie_store = GetCookieStore();
+ if (!cookie_store)
+ return std::string();
+
+ std::string cookie_value;
+ base::WaitableEvent completion(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+ base::WaitableEvent::InitialState::NOT_SIGNALED);
+ BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+ base::Bind(GetCookieValueOnIOThread, cookie_store,
+ GURL(url), &cookie_value, &completion));
+ // allow wait temporarily.
+ ScopedAllowWaitForLegacyWebViewApi allow_wait;
+ completion.Wait();
+ return cookie_value;
+}
+/* LCOV_EXCL_STOP */
+
+scoped_refptr<CookieManager> CookieManager::GetSharedThis() {
+ return scoped_refptr<CookieManager>(this);
+}
+
+scoped_refptr<brightray::URLRequestContextGetter> CookieManager::GetContextGetter() const {
+ return scoped_refptr<brightray::URLRequestContextGetter>(request_context_getter_.get());
+}
+
+net::CookieStore* CookieManager::GetCookieStore() const {
+ if (request_context_getter_)
+ return request_context_getter_->GetURLRequestContext()->cookie_store();
+ return nullptr;
+}
+
+#if defined(OS_TIZEN_TV_PRODUCT) || defined(TIZEN_DESKTOP_SUPPORT)
+void CookieManager::SetCookiesChangedCallbackOnIOThread(
+ Ewk_Cookie_Manager_Changes_Watch_Cb callback,
+ void* data) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+ auto cookie_monster = static_cast<net::CookieMonster*>(GetCookieStore());
+ if (cookie_monster)
+ cookie_monster->RegisterCookiesChangedCallback(callback, data);
+}
+
+void CookieManager::SetCookiesChangedCallback(
+ Ewk_Cookie_Manager_Changes_Watch_Cb callback,
+ void* data) {
+ BrowserThread::PostTask(
+ BrowserThread::IO, FROM_HERE,
+ base::Bind(&CookieManager::SetCookiesChangedCallbackOnIOThread,
+ GetSharedThis(), callback, data));
+}
+#endif
--- /dev/null
+// Copyright 2018 Samsung Electronics. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// cookie manager already existed in |tizen_src/ewk/efl_integration/cookie_manager.cc|
+// but it have dependency on |URLRequestContextGetterEfl|, which internaly as
+// dependency |ewk_context|. So, it is not possible to directly use this from
+// electron. Instead copied |cookie_manager.*| file to electron and added required
+// changes in |CookieManager| and atom |URLRequestContextGetter|.
+
+#ifndef cookie_manager_h
+#define cookie_manager_h
+
+#include <Eina.h>
+#include <queue>
+
+#include "base/memory/ref_counted.h"
+#include "base/synchronization/lock.h"
+#include "browser/url_request_context_getter.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "net/cookies/canonical_cookie.h"
+#include "net/cookies/cookie_monster.h"
+#include "net/cookies/cookie_options.h"
+#include "net/cookies/cookie_util.h"
+#include "tizen_src/ewk/efl_integration/public/ewk_cookie_manager.h"
+#include "url/gurl.h"
+
+#if defined(OS_TIZEN_TV_PRODUCT) || defined(TIZEN_DESKTOP_SUPPORT)
+#include "tizen_src/ewk/efl_integration/public/ewk_cookie_manager_product.h"
+#endif
+
+namespace content {
+class ResourceContext;
+}
+
+struct _Ewk_Error;
+
+//TODO: Remove unused apis from cookie manager class
+class CookieManager : public base::RefCountedThreadSafe<CookieManager> {
+ public:
+ typedef void (*AsyncHostnamesGetCb)(Eina_List*, _Ewk_Error*, void *);
+
+ CookieManager();
+ // 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. This method must be
+ // called on the IO thread.
+ void DeleteCookiesAsync(const std::string& url = std::string(),
+ const std::string& cookie_name = std::string());
+ // Sets the directory path that will be used for storing cookie data. If
+ // |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.
+ void SetStoragePath(const std::string& path,
+ bool persist_session_cookies,
+ Ewk_Cookie_Persistent_Storage file_storage);
+ //get the accept policy asynchronous
+ void GetAcceptPolicyAsync(Ewk_Cookie_Manager_Policy_Async_Get_Cb callback, void *data);
+ //get host name asynchronous
+ void GetHostNamesWithCookiesAsync(AsyncHostnamesGetCb callback, void *data);
+
+ // These manage the global access state shared across requests regardless of
+ // source (i.e. network or JavaScript).
+ bool GetGlobalAllowAccess();
+ void SetCookiePolicy(Ewk_Cookie_Accept_Policy policy);
+ // These are the functions called when operating over cookies from the
+ // network. See NetworkDelegate for further descriptions.
+ bool OnCanGetCookies(const net::URLRequest& request,
+ const net::CookieList& cookie_list);
+ bool OnCanSetCookie(const net::URLRequest& request,
+ const std::string& cookie_line,
+ net::CookieOptions* options);
+
+ // These are the functions called when operating over cookies from the
+ // renderer. See ContentBrowserClient for further descriptions.
+ bool AllowGetCookie(const GURL& url,
+ const GURL& first_party,
+ const net::CookieList& cookie_list,
+ content::ResourceContext* context,
+ int render_process_id,
+ int render_frame_id);
+ bool AllowSetCookie(const GURL& url,
+ const GURL& first_party,
+ const std::string& cookie_line,
+ content::ResourceContext* context,
+ int render_process_id,
+ int render_frame_id,
+ const net::CookieOptions& options);
+ bool ShouldBlockThirdPartyCookies();
+ //This is synchronous call
+ std::string GetCookiesForURL(const std::string& url);
+
+ //void SetRequestContextGetter(scoped_refptr<content::URLRequestContextGetter> getter);
+ void SetRequestContextGetter(scoped_refptr<brightray::URLRequestContextGetter> getter);
+
+ base::WeakPtr<CookieManager> GetWeakPtr() {
+ return weak_ptr_factory_.GetWeakPtr();
+ }
+
+ // file scheme
+ bool IsFileSchemeCookiesAllowed();
+ void SetAcceptFileSchemeCookies(bool accept);
+
+#if defined(OS_TIZEN_TV_PRODUCT) || defined(TIZEN_DESKTOP_SUPPORT)
+ void SetCookiesChangedCallback(Ewk_Cookie_Manager_Changes_Watch_Cb callback,
+ void* data);
+#endif
+
+ private:
+ friend class base::RefCountedThreadSafe<CookieManager>;
+ struct EwkGetHostCallback;
+
+ ~CookieManager();
+ void DeleteSessionCookiesOnIOThread();
+ void DeleteCookiesOnIOThread(const std::string& url,
+ const std::string& cookie_name);
+
+#if defined(OS_TIZEN_TV_PRODUCT) || defined(TIZEN_DESKTOP_SUPPORT)
+ void SetCookiesChangedCallbackOnIOThread(
+ Ewk_Cookie_Manager_Changes_Watch_Cb callback,
+ void* data);
+#endif
+
+ bool AllowCookies(const GURL& url,
+ const GURL& first_party_url,
+ bool setting_cookie);
+ // Fetch the cookies. This must be called in the IO thread.
+ void FetchCookiesOnIOThread();
+ void OnFetchComplete(const net::CookieList& cookies);
+
+ scoped_refptr<CookieManager> GetSharedThis();
+ scoped_refptr<brightray::URLRequestContextGetter> GetContextGetter() const;
+ net::CookieStore* GetCookieStore() const;
+ scoped_refptr<brightray::URLRequestContextGetter> request_context_getter_;
+ //cookie policy information
+ base::Lock lock_;
+ Ewk_Cookie_Accept_Policy cookie_policy_;
+ // This only mutates on the UI thread.
+ std::queue< EwkGetHostCallback* > host_callback_queue_;
+ base::WeakPtrFactory<CookieManager> weak_ptr_factory_;
+ // file scheme
+ base::Lock file_scheme_lock_;
+
+ DISALLOW_COPY_AND_ASSIGN(CookieManager);
+};
+
+#endif //cookie_manager_h
#include "common/switches.h"
#include "base/command_line.h"
+#include "base/files/file_util.h"
#include "base/memory/ptr_util.h"
#include "base/strings/string_util.h"
#include "base/threading/sequenced_worker_pool.h"
#include "net/cert/multi_log_ct_verifier.h"
#include "net/cookies/cookie_monster.h"
#include "net/dns/mapped_host_resolver.h"
+#include "net/extras/sqlite/sqlite_persistent_cookie_store.h"
#include "net/http/http_auth_filter.h"
#include "net/http/http_auth_handler_factory.h"
#include "net/http/http_auth_preferences.h"
#endif
using content::BrowserThread;
+using net::SQLitePersistentCookieStore;
namespace brightray {
return BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
}
+void URLRequestContextGetter::SetCookieStoragePath(
+ const base::FilePath& path,
+ bool persist_session_cookies,
+ Ewk_Cookie_Persistent_Storage file_storage) {
+ if (url_request_context_->cookie_store() &&
+ (cookie_store_path_ == path)) {
+ // The path has not changed so don't do anything.
+ return;
+ }
+
+ if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+ BrowserThread::PostTask(
+ BrowserThread::IO, FROM_HERE,
+ base::Bind(&URLRequestContextGetter::SetCookieStoragePath,
+ this, path, persist_session_cookies, file_storage));
+ return;
+ }
+
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ if (file_storage == EWK_COOKIE_PERSISTENT_STORAGE_SQLITE) {
+ CreateSQLitePersistentCookieStore(path, persist_session_cookies);
+ } else {
+ CreatePersistentCookieStore(path, persist_session_cookies);
+ }
+}
+
+void URLRequestContextGetter::CreateSQLitePersistentCookieStore(
+ const base::FilePath& path,
+ bool persist_session_cookies)
+{
+ using content::CookieStoreConfig;
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ scoped_refptr<SQLitePersistentCookieStore> persistent_store;
+
+ if (path.empty())
+ return; // LCOV_EXCL_LINE
+ base::ThreadRestrictions::ScopedAllowIO allow_io;
+ if (base::DirectoryExists(path) ||
+ base::CreateDirectory(path)) {
+ const base::FilePath& cookie_path = path.AppendASCII("Cookies");
+ persistent_store =
+ new SQLitePersistentCookieStore(
+ cookie_path,
+ BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
+ BrowserThread::GetTaskRunnerForThread(BrowserThread::DB),
+ persist_session_cookies, NULL);
+ } else {
+ NOTREACHED() << "The cookie storage directory could not be created";
+ return;
+ }
+ // 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.
+ std::unique_ptr<net::CookieMonster> cookie_monster(
+ new net::CookieMonster(persistent_store.get(), NULL));
+
+ if (persistent_store.get() && persist_session_cookies)
+ cookie_monster->SetPersistSessionCookies(true);
+
+ std::vector<std::string> schemes;
+ for (int i = 0; i < net::CookieMonster::kDefaultCookieableSchemesCount; ++i)
+ schemes.push_back(std::string(net::CookieMonster::kDefaultCookieableSchemes[i]));
+ schemes.push_back(url::kFileScheme);
+ cookie_monster->SetCookieableSchemes(schemes);
+
+ storage_->set_cookie_store(std::move(cookie_monster));
+
+ cookie_store_path_ = path;
+}
+
+void URLRequestContextGetter::CreatePersistentCookieStore(const base::FilePath& path,
+ bool persist_session_cookies)
+{
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ cookie_store_path_ = path;
+
+ content::CookieStoreConfig config(
+ cookie_store_path_.Append(FILE_PATH_LITERAL("Cookies")),
+ content::CookieStoreConfig::RESTORED_SESSION_COOKIES,
+ NULL,
+ NULL);
+ cookie_store_= CreateCookieStore(config);
+ net::CookieMonster* cookie_monster = static_cast<net::CookieMonster*>(
+ cookie_store_.get());
+ cookie_monster->SetPersistSessionCookies(persist_session_cookies);
+
+ std::vector<std::string> schemes;
+ for (int i = 0; i < net::CookieMonster::kDefaultCookieableSchemesCount; ++i)
+ schemes.push_back(std::string(net::CookieMonster::kDefaultCookieableSchemes[i]));
+ schemes.push_back(url::kFileScheme);
+ cookie_monster->SetCookieableSchemes(schemes);
+
+ DCHECK(url_request_context_);
+ url_request_context_->set_cookie_store(cookie_store_.get());
+}
+
} // namespace brightray
#include "net/http/transport_security_state.h"
#include "net/http/url_security_manager.h"
#include "net/url_request/url_request_context_getter.h"
+#include "tizen_src/ewk/efl_integration/public/ewk_cookie_manager_internal.h"
namespace base {
class MessageLoop;
return delegate_->GetMediaDeviceIDSalt();
}
+ void SetCookieStoragePath(const base::FilePath& path,
+ bool persist_session_cookies,
+ Ewk_Cookie_Persistent_Storage file_storage);
private:
+ void CreateSQLitePersistentCookieStore(const base::FilePath& path,
+ bool persist_session_cookies);
+ void CreatePersistentCookieStore(const base::FilePath& path,
+ bool persist_session_cookies);
+
Delegate* delegate_;
DevToolsNetworkControllerHandle* network_controller_handle_;
NetLog* net_log_;
base::FilePath base_path_;
bool in_memory_;
+ base::FilePath cookie_store_path_;
+ std::unique_ptr<net::CookieStore> cookie_store_;
scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
'browser/devtools_manager_delegate.h',
'browser/devtools_ui.cc',
'browser/devtools_ui.h',
- 'browser/efl/notification_presenter_efl.h',
+ 'browser/efl/cookie_manager.cc',
+ 'browser/efl/cookie_manager.h',
'browser/efl/notification_presenter_efl.cc',
+ 'browser/efl/notification_presenter_efl.h',
'browser/inspectable_web_contents.cc',
'browser/inspectable_web_contents.h',
'browser/inspectable_web_contents_delegate.h',
projects / platform / framework / web / crosswalk-tizen.git / commitdiff