mirror of
https://bitbucket.org/chromiumembedded/cef
synced 2024-12-12 09:37:37 +01:00
36ee304ed4
The CefSettings cookie scheme configuration will now only impact the global request context. Custom behavior for other request contexts must now be configured via CefRequestContextSettings.
446 lines
12 KiB
C++
446 lines
12 KiB
C++
// Copyright (c) 2012 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/browser_context.h"
|
|
|
|
#include <map>
|
|
#include <utility>
|
|
|
|
#include "libcef/browser/context.h"
|
|
#include "libcef/browser/media_router/media_router_manager.h"
|
|
#include "libcef/browser/request_context_impl.h"
|
|
#include "libcef/browser/thread_util.h"
|
|
#include "libcef/common/cef_switches.h"
|
|
#include "libcef/common/frame_util.h"
|
|
#include "libcef/features/runtime.h"
|
|
|
|
#include "base/files/file_util.h"
|
|
#include "base/lazy_instance.h"
|
|
#include "base/logging.h"
|
|
#include "base/no_destructor.h"
|
|
#include "base/strings/string_split.h"
|
|
#include "base/strings/string_util.h"
|
|
#include "chrome/browser/profiles/profile.h"
|
|
#include "content/public/browser/browser_context.h"
|
|
#include "content/public/browser/browser_task_traits.h"
|
|
#include "content/public/browser/browser_thread.h"
|
|
#include "content/public/browser/storage_partition.h"
|
|
|
|
using content::BrowserThread;
|
|
|
|
namespace {
|
|
|
|
// Manages the global list of Impl instances.
|
|
class ImplManager {
|
|
public:
|
|
using Vector = std::vector<CefBrowserContext*>;
|
|
|
|
ImplManager() {}
|
|
|
|
ImplManager(const ImplManager&) = delete;
|
|
ImplManager& operator=(const ImplManager&) = delete;
|
|
|
|
~ImplManager() {
|
|
DCHECK(all_.empty());
|
|
DCHECK(map_.empty());
|
|
}
|
|
|
|
void AddImpl(CefBrowserContext* impl) {
|
|
CEF_REQUIRE_UIT();
|
|
DCHECK(!IsValidImpl(impl));
|
|
all_.push_back(impl);
|
|
}
|
|
|
|
void RemoveImpl(CefBrowserContext* impl, const base::FilePath& path) {
|
|
CEF_REQUIRE_UIT();
|
|
|
|
{
|
|
Vector::iterator it = GetImplPos(impl);
|
|
DCHECK(it != all_.end());
|
|
all_.erase(it);
|
|
}
|
|
|
|
if (!path.empty()) {
|
|
PathMap::iterator it = map_.find(path);
|
|
DCHECK(it != map_.end());
|
|
if (it != map_.end()) {
|
|
map_.erase(it);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool IsValidImpl(const CefBrowserContext* impl) {
|
|
CEF_REQUIRE_UIT();
|
|
return GetImplPos(impl) != all_.end();
|
|
}
|
|
|
|
CefBrowserContext* GetImplFromGlobalId(
|
|
const content::GlobalRenderFrameHostId& global_id,
|
|
bool require_frame_match) {
|
|
CEF_REQUIRE_UIT();
|
|
for (const auto& context : all_) {
|
|
if (context->IsAssociatedContext(global_id, require_frame_match)) {
|
|
return context;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
CefBrowserContext* GetImplFromBrowserContext(
|
|
const content::BrowserContext* context) {
|
|
CEF_REQUIRE_UIT();
|
|
if (!context) {
|
|
return nullptr;
|
|
}
|
|
|
|
for (const auto& bc : all_) {
|
|
if (bc->AsBrowserContext() == context) {
|
|
return bc;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void SetImplPath(CefBrowserContext* impl, const base::FilePath& path) {
|
|
CEF_REQUIRE_UIT();
|
|
DCHECK(!path.empty());
|
|
DCHECK(IsValidImpl(impl));
|
|
DCHECK(GetImplFromPath(path) == nullptr);
|
|
map_.insert(std::make_pair(path, impl));
|
|
}
|
|
|
|
CefBrowserContext* GetImplFromPath(const base::FilePath& path) {
|
|
CEF_REQUIRE_UIT();
|
|
DCHECK(!path.empty());
|
|
PathMap::const_iterator it = map_.find(path);
|
|
if (it != map_.end()) {
|
|
return it->second;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const Vector GetAllImpl() const { return all_; }
|
|
|
|
private:
|
|
Vector::iterator GetImplPos(const CefBrowserContext* impl) {
|
|
Vector::iterator it = all_.begin();
|
|
for (; it != all_.end(); ++it) {
|
|
if (*it == impl) {
|
|
return it;
|
|
}
|
|
}
|
|
return all_.end();
|
|
}
|
|
|
|
using PathMap = std::map<base::FilePath, CefBrowserContext*>;
|
|
PathMap map_;
|
|
|
|
Vector all_;
|
|
};
|
|
|
|
#if DCHECK_IS_ON()
|
|
// Because of DCHECK()s in the object destructor.
|
|
base::LazyInstance<ImplManager>::DestructorAtExit g_manager =
|
|
LAZY_INSTANCE_INITIALIZER;
|
|
#else
|
|
base::LazyInstance<ImplManager>::Leaky g_manager = LAZY_INSTANCE_INITIALIZER;
|
|
#endif
|
|
|
|
CefBrowserContext* GetSelf(base::WeakPtr<CefBrowserContext> self) {
|
|
CEF_REQUIRE_UIT();
|
|
return self.get();
|
|
}
|
|
|
|
CefBrowserContext::CookieableSchemes MakeSupportedSchemes(
|
|
const CefString& schemes_list,
|
|
bool include_defaults) {
|
|
if (schemes_list.empty() && include_defaults) {
|
|
// No explicit registration of schemes.
|
|
return absl::nullopt;
|
|
}
|
|
|
|
std::vector<std::string> all_schemes;
|
|
if (!schemes_list.empty()) {
|
|
all_schemes =
|
|
base::SplitString(schemes_list.ToString(), std::string(","),
|
|
base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
|
|
}
|
|
|
|
if (include_defaults) {
|
|
// Add default schemes that should always support cookies.
|
|
// This list should match CookieMonster::kDefaultCookieableSchemes.
|
|
all_schemes.push_back("http");
|
|
all_schemes.push_back("https");
|
|
all_schemes.push_back("ws");
|
|
all_schemes.push_back("wss");
|
|
}
|
|
|
|
return absl::make_optional(all_schemes);
|
|
}
|
|
|
|
template <typename T>
|
|
CefBrowserContext::CookieableSchemes MakeSupportedSchemes(const T& settings) {
|
|
return MakeSupportedSchemes(CefString(&settings.cookieable_schemes_list),
|
|
!settings.cookieable_schemes_exclude_defaults);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
CefBrowserContext::CefBrowserContext(const CefRequestContextSettings& settings)
|
|
: settings_(settings), weak_ptr_factory_(this) {
|
|
g_manager.Get().AddImpl(this);
|
|
getter_ = base::BindRepeating(GetSelf, weak_ptr_factory_.GetWeakPtr());
|
|
}
|
|
|
|
CefBrowserContext::~CefBrowserContext() {
|
|
CEF_REQUIRE_UIT();
|
|
#if DCHECK_IS_ON()
|
|
DCHECK(is_shutdown_);
|
|
#endif
|
|
}
|
|
|
|
void CefBrowserContext::Initialize() {
|
|
cache_path_ = base::FilePath(CefString(&settings_.cache_path));
|
|
|
|
if (!cache_path_.empty()) {
|
|
g_manager.Get().SetImplPath(this, cache_path_);
|
|
}
|
|
|
|
iothread_state_ = base::MakeRefCounted<CefIOThreadState>();
|
|
cookieable_schemes_ = MakeSupportedSchemes(settings_);
|
|
}
|
|
|
|
void CefBrowserContext::Shutdown() {
|
|
CEF_REQUIRE_UIT();
|
|
|
|
#if DCHECK_IS_ON()
|
|
is_shutdown_ = true;
|
|
#endif
|
|
|
|
// No CefRequestContext should be referencing this object any longer.
|
|
DCHECK(request_context_set_.empty());
|
|
|
|
// Unregister the context first to avoid re-entrancy during shutdown.
|
|
g_manager.Get().RemoveImpl(this, cache_path_);
|
|
|
|
// Destroy objects that may hold references to the MediaRouter.
|
|
media_router_manager_.reset();
|
|
|
|
// Invalidate any Getter references to this object.
|
|
weak_ptr_factory_.InvalidateWeakPtrs();
|
|
}
|
|
|
|
void CefBrowserContext::AddCefRequestContext(CefRequestContextImpl* context) {
|
|
CEF_REQUIRE_UIT();
|
|
request_context_set_.insert(context);
|
|
}
|
|
|
|
void CefBrowserContext::RemoveCefRequestContext(
|
|
CefRequestContextImpl* context) {
|
|
CEF_REQUIRE_UIT();
|
|
|
|
request_context_set_.erase(context);
|
|
|
|
// Delete ourselves when the reference count reaches zero.
|
|
if (request_context_set_.empty()) {
|
|
Shutdown();
|
|
|
|
// Allow the current call stack to unwind before deleting |this|.
|
|
content::BrowserThread::DeleteSoon(CEF_UIT, FROM_HERE, this);
|
|
}
|
|
}
|
|
|
|
// static
|
|
CefBrowserContext* CefBrowserContext::FromCachePath(
|
|
const base::FilePath& cache_path) {
|
|
return g_manager.Get().GetImplFromPath(cache_path);
|
|
}
|
|
|
|
// static
|
|
CefBrowserContext* CefBrowserContext::FromGlobalId(
|
|
const content::GlobalRenderFrameHostId& global_id,
|
|
bool require_frame_match) {
|
|
return g_manager.Get().GetImplFromGlobalId(global_id, require_frame_match);
|
|
}
|
|
|
|
// static
|
|
CefBrowserContext* CefBrowserContext::FromBrowserContext(
|
|
const content::BrowserContext* context) {
|
|
return g_manager.Get().GetImplFromBrowserContext(context);
|
|
}
|
|
|
|
// static
|
|
CefBrowserContext* CefBrowserContext::FromProfile(const Profile* profile) {
|
|
auto* cef_context = FromBrowserContext(profile);
|
|
if (cef_context) {
|
|
return cef_context;
|
|
}
|
|
|
|
if (cef::IsChromeRuntimeEnabled()) {
|
|
auto* original_profile = profile->GetOriginalProfile();
|
|
if (original_profile != profile) {
|
|
// With the Chrome runtime if the user launches an incognito window via
|
|
// the UI we might be associated with the original Profile instead of the
|
|
// (current) incognito profile.
|
|
return FromBrowserContext(original_profile);
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
// static
|
|
std::vector<CefBrowserContext*> CefBrowserContext::GetAll() {
|
|
return g_manager.Get().GetAllImpl();
|
|
}
|
|
|
|
void CefBrowserContext::OnRenderFrameCreated(
|
|
CefRequestContextImpl* request_context,
|
|
const content::GlobalRenderFrameHostId& global_id,
|
|
bool is_main_frame,
|
|
bool is_guest_view) {
|
|
CEF_REQUIRE_UIT();
|
|
DCHECK(frame_util::IsValidGlobalId(global_id));
|
|
|
|
render_id_set_.insert(global_id);
|
|
|
|
CefRefPtr<CefRequestContextHandler> handler = request_context->GetHandler();
|
|
if (handler) {
|
|
handler_map_.AddHandler(global_id, handler);
|
|
|
|
CEF_POST_TASK(CEF_IOT, base::BindOnce(&CefIOThreadState::AddHandler,
|
|
iothread_state_, global_id, handler));
|
|
}
|
|
}
|
|
|
|
void CefBrowserContext::OnRenderFrameDeleted(
|
|
CefRequestContextImpl* request_context,
|
|
const content::GlobalRenderFrameHostId& global_id,
|
|
bool is_main_frame,
|
|
bool is_guest_view) {
|
|
CEF_REQUIRE_UIT();
|
|
DCHECK(frame_util::IsValidGlobalId(global_id));
|
|
|
|
auto it1 = render_id_set_.find(global_id);
|
|
if (it1 != render_id_set_.end()) {
|
|
render_id_set_.erase(it1);
|
|
}
|
|
|
|
CefRefPtr<CefRequestContextHandler> handler = request_context->GetHandler();
|
|
if (handler) {
|
|
handler_map_.RemoveHandler(global_id);
|
|
|
|
CEF_POST_TASK(CEF_IOT, base::BindOnce(&CefIOThreadState::RemoveHandler,
|
|
iothread_state_, global_id));
|
|
}
|
|
}
|
|
|
|
CefRefPtr<CefRequestContextHandler> CefBrowserContext::GetHandler(
|
|
const content::GlobalRenderFrameHostId& global_id,
|
|
bool require_frame_match) const {
|
|
CEF_REQUIRE_UIT();
|
|
return handler_map_.GetHandler(global_id, require_frame_match);
|
|
}
|
|
|
|
bool CefBrowserContext::IsAssociatedContext(
|
|
const content::GlobalRenderFrameHostId& global_id,
|
|
bool require_frame_match) const {
|
|
CEF_REQUIRE_UIT();
|
|
|
|
if (frame_util::IsValidGlobalId(global_id)) {
|
|
const auto it1 = render_id_set_.find(global_id);
|
|
if (it1 != render_id_set_.end()) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (frame_util::IsValidChildId(global_id.child_id) && !require_frame_match) {
|
|
// Choose an arbitrary handler for the same process.
|
|
for (const auto& render_ids : render_id_set_) {
|
|
if (render_ids.child_id == global_id.child_id) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CefBrowserContext::RegisterSchemeHandlerFactory(
|
|
const CefString& scheme_name,
|
|
const CefString& domain_name,
|
|
CefRefPtr<CefSchemeHandlerFactory> factory) {
|
|
CEF_POST_TASK(
|
|
CEF_IOT,
|
|
base::BindOnce(&CefIOThreadState::RegisterSchemeHandlerFactory,
|
|
iothread_state_, scheme_name, domain_name, factory));
|
|
}
|
|
|
|
void CefBrowserContext::ClearSchemeHandlerFactories() {
|
|
CEF_POST_TASK(CEF_IOT,
|
|
base::BindOnce(&CefIOThreadState::ClearSchemeHandlerFactories,
|
|
iothread_state_));
|
|
}
|
|
|
|
void CefBrowserContext::LoadExtension(
|
|
const CefString& root_directory,
|
|
CefRefPtr<CefDictionaryValue> manifest,
|
|
CefRefPtr<CefExtensionHandler> handler,
|
|
CefRefPtr<CefRequestContext> loader_context) {
|
|
NOTIMPLEMENTED();
|
|
if (handler) {
|
|
handler->OnExtensionLoadFailed(ERR_ABORTED);
|
|
}
|
|
}
|
|
|
|
bool CefBrowserContext::GetExtensions(std::vector<CefString>& extension_ids) {
|
|
NOTIMPLEMENTED();
|
|
return false;
|
|
}
|
|
|
|
CefRefPtr<CefExtension> CefBrowserContext::GetExtension(
|
|
const CefString& extension_id) {
|
|
NOTIMPLEMENTED();
|
|
return nullptr;
|
|
}
|
|
|
|
bool CefBrowserContext::UnloadExtension(const CefString& extension_id) {
|
|
NOTIMPLEMENTED();
|
|
return false;
|
|
}
|
|
|
|
bool CefBrowserContext::IsPrintPreviewSupported() const {
|
|
return true;
|
|
}
|
|
|
|
network::mojom::NetworkContext* CefBrowserContext::GetNetworkContext() {
|
|
CEF_REQUIRE_UIT();
|
|
auto browser_context = AsBrowserContext();
|
|
return browser_context->GetDefaultStoragePartition()->GetNetworkContext();
|
|
}
|
|
|
|
CefMediaRouterManager* CefBrowserContext::GetMediaRouterManager() {
|
|
CEF_REQUIRE_UIT();
|
|
if (!media_router_manager_) {
|
|
media_router_manager_.reset(new CefMediaRouterManager(AsBrowserContext()));
|
|
}
|
|
return media_router_manager_.get();
|
|
}
|
|
|
|
CefBrowserContext::CookieableSchemes CefBrowserContext::GetCookieableSchemes()
|
|
const {
|
|
CEF_REQUIRE_UIT();
|
|
return cookieable_schemes_;
|
|
}
|
|
|
|
// static
|
|
CefBrowserContext::CookieableSchemes
|
|
CefBrowserContext::GetGlobalCookieableSchemes() {
|
|
CEF_REQUIRE_UIT();
|
|
|
|
static base::NoDestructor<CookieableSchemes> schemes(
|
|
[]() { return MakeSupportedSchemes(CefContext::Get()->settings()); }());
|
|
return *schemes;
|
|
}
|