blob: 41bdc5305a30181774aca957af628e76bf3ee73f [file] [log] [blame]
[email protected]55eb70e762012-02-20 17:38:391// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "content/public/browser/browser_context.h"
6
avib7348942015-12-25 20:57:107#include <stddef.h>
8#include <stdint.h>
avi1ed4a4372017-04-25 05:39:419
erge69130f52016-03-02 00:13:2810#include <algorithm>
11#include <limits>
rockot963ad3e82016-04-13 16:33:2312#include <memory>
Takuto Ikuta8332bf9d2019-01-05 03:58:0013#include <unordered_set>
dcheng36b6aec92015-12-26 06:16:3614#include <utility>
rockot963ad3e82016-04-13 16:33:2315#include <vector>
avib7348942015-12-25 20:57:1016
mmenkec0b2b8b12017-04-21 16:27:5217#include "base/base64.h"
Takashi Toyoshimaa12ecf42018-09-25 07:46:0118#include "base/bind.h"
rockot963ad3e82016-04-13 16:33:2319#include "base/command_line.h"
Takashi Toyoshimaa12ecf42018-09-25 07:46:0120#include "base/feature_list.h"
Chris Cunninghama5b38012017-10-28 07:27:1821#include "base/files/file_path.h"
bencccfe2a2016-03-05 16:54:1422#include "base/guid.h"
erge69130f52016-03-02 00:13:2823#include "base/lazy_instance.h"
mmenkec0b2b8b12017-04-21 16:27:5224#include "base/logging.h"
rockot963ad3e82016-04-13 16:33:2325#include "base/macros.h"
avi1ed4a4372017-04-25 05:39:4126#include "base/memory/ptr_util.h"
Ken Rockot435132692018-11-20 21:46:1027#include "base/memory/weak_ptr.h"
Ken Rockotda7edc62018-11-10 01:01:4528#include "base/no_destructor.h"
erge69130f52016-03-02 00:13:2829#include "base/rand_util.h"
Takashi Toyoshima621e2bf2018-09-18 08:05:1630#include "base/supports_user_data.h"
Gabriel Charette44db1422018-08-06 11:19:3331#include "base/task/post_task.h"
Ken Rockot84f58fd2018-06-22 21:54:1432#include "base/threading/sequenced_task_runner_handle.h"
ben21a34c252016-06-29 22:24:3733#include "base/threading/thread_task_runner_handle.h"
Andrey Lushnikovd39d9062018-04-24 17:33:3534#include "base/unguessable_token.h"
avib7348942015-12-25 20:57:1035#include "build/build_config.h"
dmurph7ac019a2016-05-13 00:13:1736#include "content/browser/blob_storage/chrome_blob_storage_context.h"
msrameke169ccb2017-04-26 05:21:4137#include "content/browser/browsing_data/browsing_data_remover_impl.h"
Alex Moshchuk99b795422019-03-07 00:27:3238#include "content/browser/child_process_security_policy_impl.h"
Ken Rockot84f58fd2018-06-22 21:54:1439#include "content/browser/content_service_delegate_impl.h"
[email protected]b441a8492012-06-06 14:55:5740#include "content/browser/download/download_manager_impl.h"
[email protected]c4d281662013-03-31 00:35:0841#include "content/browser/indexed_db/indexed_db_context_impl.h"
[email protected]678c0362012-12-05 08:02:4442#include "content/browser/loader/resource_dispatcher_host_impl.h"
[email protected]3dcea37a2019-02-11 19:46:5143#include "content/browser/media/browser_feature_provider.h"
Andrey Lushnikovebff0442018-07-12 20:02:5844#include "content/browser/permissions/permission_controller_impl.h"
mvanouwerkerk17205ea2014-11-07 17:30:1545#include "content/browser/push_messaging/push_messaging_router.h"
Ken Rockotc7a279c2017-05-04 23:51:4546#include "content/browser/service_manager/common_browser_interfaces.h"
[email protected]4c3a23582012-08-18 08:54:3447#include "content/browser/storage_partition_impl_map.h"
[email protected]d7c7c98a2012-07-12 21:27:4448#include "content/common/child_process_host_impl.h"
[email protected]393b6cb2014-05-15 00:55:1249#include "content/public/browser/blob_handle.h"
Eric Seckler8652dcd52018-09-20 10:42:2850#include "content/public/browser/browser_task_traits.h"
[email protected]55eb70e762012-02-20 17:38:3951#include "content/public/browser/browser_thread.h"
[email protected]b441a8492012-06-06 14:55:5752#include "content/public/browser/content_browser_client.h"
falken04a6912a2016-09-23 21:06:2953#include "content/public/browser/render_process_host.h"
Takashi Toyoshima0190a3b2019-01-21 07:39:0654#include "content/public/browser/shared_cors_origin_access_list.h"
[email protected]536fd0b2013-03-14 17:41:5755#include "content/public/browser/site_instance.h"
rockot963ad3e82016-04-13 16:33:2356#include "content/public/common/content_switches.h"
bend32292b2016-10-07 00:21:5857#include "content/public/common/service_manager_connection.h"
ben51bb6c62016-11-17 20:15:5758#include "content/public/common/service_names.mojom.h"
Chris Cunningham9e669472017-11-15 21:03:1159#include "media/capabilities/video_decode_stats_db_impl.h"
Chris Cunninghama5b38012017-10-28 07:27:1860#include "media/mojo/services/video_decode_perf_history.h"
Ken Rockot40a1df792019-05-08 22:15:5261#include "mojo/public/cpp/bindings/remote.h"
[email protected]4d7c4ef2012-03-16 01:47:1262#include "net/cookies/cookie_store.h"
[email protected]6b8a3c742014-07-25 00:25:3563#include "net/ssl/channel_id_service.h"
64#include "net/ssl/channel_id_store.h"
[email protected]6e2d3d22012-02-24 18:10:3665#include "net/url_request/url_request_context.h"
[email protected]6939075a2012-08-28 08:35:5366#include "net/url_request/url_request_context_getter.h"
Ken Rockot84f58fd2018-06-22 21:54:1467#include "services/content/public/mojom/constants.mojom.h"
68#include "services/content/service.h"
ben768c8dc2016-08-12 00:26:5069#include "services/file/file_service.h"
Ken Rockot21142de2018-02-10 01:45:3070#include "services/file/public/mojom/constants.mojom.h"
ben768c8dc2016-08-12 00:26:5071#include "services/file/user_id_map.h"
Takashi Toyoshimaa12ecf42018-09-25 07:46:0172#include "services/network/public/cpp/features.h"
rockot734fb662016-10-15 16:41:3073#include "services/service_manager/public/cpp/connector.h"
Ken Rockot435132692018-11-20 21:46:1074#include "services/service_manager/public/cpp/service.h"
Ken Rockot543f5e32018-02-04 02:13:5075#include "services/service_manager/public/mojom/service.mojom.h"
Xing Liu89860472018-02-09 20:07:0276#include "storage/browser/blob/blob_storage_context.h"
pilgrime92c5fcd2014-09-10 23:31:2377#include "storage/browser/database/database_tracker.h"
78#include "storage/browser/fileapi/external_mount_points.h"
[email protected]55eb70e762012-02-20 17:38:3979
[email protected]314c3e22012-02-21 03:57:4280using base::UserDataAdapter;
[email protected]55eb70e762012-02-20 17:38:3981
[email protected]55eb70e762012-02-20 17:38:3982namespace content {
83
[email protected]735e20c2012-03-20 01:16:5984namespace {
85
Ken Rockotda7edc62018-11-10 01:01:4586using TokenToContextMap = std::map<base::Token, BrowserContext*>;
87TokenToContextMap& GetTokenToContextMap() {
88 static base::NoDestructor<TokenToContextMap> map;
89 return *map;
90}
ben6c85c4492016-06-16 20:40:5191
Ken Rockotda7edc62018-11-10 01:01:4592class ServiceInstanceGroupHolder : public base::SupportsUserData::Data {
ben6c85c4492016-06-16 20:40:5193 public:
Ken Rockotda7edc62018-11-10 01:01:4594 explicit ServiceInstanceGroupHolder(const base::Token& instance_group)
95 : instance_group_(instance_group) {}
96 ~ServiceInstanceGroupHolder() override {}
ben6c85c4492016-06-16 20:40:5197
Ken Rockotda7edc62018-11-10 01:01:4598 const base::Token& instance_group() const { return instance_group_; }
ben6c85c4492016-06-16 20:40:5199
100 private:
Ken Rockotda7edc62018-11-10 01:01:45101 base::Token instance_group_;
ben6c85c4492016-06-16 20:40:51102
Ken Rockotda7edc62018-11-10 01:01:45103 DISALLOW_COPY_AND_ASSIGN(ServiceInstanceGroupHolder);
ben6c85c4492016-06-16 20:40:51104};
erge69130f52016-03-02 00:13:28105
Ken Rockot499519e2018-12-04 06:57:44106// The file service runs on the IO thread but we want to limit its lifetime to
107// that of the BrowserContext which creates it. This provides thread-safe access
108// to the relevant state on the IO thread.
109class FileServiceIOThreadState
110 : public base::RefCountedThreadSafe<FileServiceIOThreadState> {
111 public:
112 explicit FileServiceIOThreadState(
113 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
114 : io_task_runner_(std::move(io_task_runner)) {}
115
116 void StartOnIOThread(service_manager::mojom::ServiceRequest request) {
117 DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
118 file_service_ = std::make_unique<file::FileService>(std::move(request));
119 }
120
121 void ShutDown() {
122 io_task_runner_->PostTask(
123 FROM_HERE,
124 base::BindOnce(&FileServiceIOThreadState::ShutDownOnIOThread, this));
125 }
126
127 private:
128 friend class base::RefCountedThreadSafe<FileServiceIOThreadState>;
129
130 ~FileServiceIOThreadState() { DCHECK(!file_service_); }
131
132 void ShutDownOnIOThread() { file_service_.reset(); }
133
134 const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
135 std::unique_ptr<file::FileService> file_service_;
136
137 DISALLOW_COPY_AND_ASSIGN(FileServiceIOThreadState);
138};
139
140class FileServiceHolder : public base::SupportsUserData::Data {
141 public:
142 explicit FileServiceHolder(scoped_refptr<FileServiceIOThreadState> state)
143 : state_(std::move(state)) {}
144 ~FileServiceHolder() override { state_->ShutDown(); }
145
146 private:
147 const scoped_refptr<FileServiceIOThreadState> state_;
148
149 DISALLOW_COPY_AND_ASSIGN(FileServiceHolder);
150};
151
Ken Rockot84f58fd2018-06-22 21:54:14152class ContentServiceDelegateHolder : public base::SupportsUserData::Data {
153 public:
154 explicit ContentServiceDelegateHolder(BrowserContext* browser_context)
155 : delegate_(browser_context) {}
156 ~ContentServiceDelegateHolder() override = default;
157
158 ContentServiceDelegateImpl* delegate() { return &delegate_; }
159
160 private:
161 ContentServiceDelegateImpl delegate_;
162
163 DISALLOW_COPY_AND_ASSIGN(ContentServiceDelegateHolder);
164};
165
[email protected]e0ce8a1e2012-09-18 10:26:36166// Key names on BrowserContext.
msrameke169ccb2017-04-26 05:21:41167const char kBrowsingDataRemoverKey[] = "browsing-data-remover";
Ken Rockot84f58fd2018-06-22 21:54:14168const char kContentServiceDelegateKey[] = "content-service-delegate";
Ken Rockot499519e2018-12-04 06:57:44169const char kFileServiceKey[] = "file-service";
[email protected]6ef0c3912013-01-25 22:46:34170const char kDownloadManagerKeyName[] = "download_manager";
Takashi Toyoshima621e2bf2018-09-18 08:05:16171const char kPermissionControllerKey[] = "permission-controller";
bend32292b2016-10-07 00:21:58172const char kServiceManagerConnection[] = "service-manager-connection";
Ken Rockotda7edc62018-11-10 01:01:45173const char kServiceInstanceGroup[] = "service-instance-group";
rockot963ad3e82016-04-13 16:33:23174const char kStoragePartitionMapKeyName[] = "content_storage_partition_map";
Chris Cunninghama5b38012017-10-28 07:27:18175const char kVideoDecodePerfHistoryId[] = "video-decode-perf-history";
erge69130f52016-03-02 00:13:28176
[email protected]9afc14e22013-09-25 22:34:14177#if defined(OS_CHROMEOS)
178const char kMountPointsKey[] = "mount_points";
179#endif // defined(OS_CHROMEOS)
180
Ken Rockotda7edc62018-11-10 01:01:45181void RemoveBrowserContextFromInstanceGroupMap(BrowserContext* browser_context) {
182 ServiceInstanceGroupHolder* holder = static_cast<ServiceInstanceGroupHolder*>(
183 browser_context->GetUserData(kServiceInstanceGroup));
ben6c85c4492016-06-16 20:40:51184 if (holder) {
Ken Rockotda7edc62018-11-10 01:01:45185 auto it = GetTokenToContextMap().find(holder->instance_group());
186 if (it != GetTokenToContextMap().end())
187 GetTokenToContextMap().erase(it);
ben6c85c4492016-06-16 20:40:51188 }
189}
190
[email protected]14acc642012-11-17 12:20:10191StoragePartitionImplMap* GetStoragePartitionMap(
192 BrowserContext* browser_context) {
[email protected]4c3a23582012-08-18 08:54:34193 StoragePartitionImplMap* partition_map =
194 static_cast<StoragePartitionImplMap*>(
a.cavalcantiffab73762015-08-15 02:55:48195 browser_context->GetUserData(kStoragePartitionMapKeyName));
[email protected]d7c7c98a2012-07-12 21:27:44196 if (!partition_map) {
avi1ed4a4372017-04-25 05:39:41197 auto partition_map_owned =
Jeremy Roman04f27c372017-10-27 15:20:55198 std::make_unique<StoragePartitionImplMap>(browser_context);
avi1ed4a4372017-04-25 05:39:41199 partition_map = partition_map_owned.get();
200 browser_context->SetUserData(kStoragePartitionMapKeyName,
201 std::move(partition_map_owned));
[email protected]d7c7c98a2012-07-12 21:27:44202 }
[email protected]14acc642012-11-17 12:20:10203 return partition_map;
204}
205
206StoragePartition* GetStoragePartitionFromConfig(
207 BrowserContext* browser_context,
208 const std::string& partition_domain,
209 const std::string& partition_name,
Dan Elphick6c0d8492017-09-12 09:35:38210 bool in_memory,
211 bool can_create) {
[email protected]14acc642012-11-17 12:20:10212 StoragePartitionImplMap* partition_map =
213 GetStoragePartitionMap(browser_context);
[email protected]d7c7c98a2012-07-12 21:27:44214
[email protected]1bc28312012-11-08 08:31:53215 if (browser_context->IsOffTheRecord())
216 in_memory = true;
217
Dan Elphick6c0d8492017-09-12 09:35:38218 return partition_map->Get(partition_domain, partition_name, in_memory,
219 can_create);
[email protected]d1198fd2012-08-13 22:50:19220}
221
[email protected]6939075a2012-08-28 08:35:53222void SaveSessionStateOnIOThread(
223 const scoped_refptr<net::URLRequestContextGetter>& context_getter,
[email protected]98d6d4562014-06-25 20:57:55224 AppCacheServiceImpl* appcache_service) {
[email protected]6939075a2012-08-28 08:35:53225 appcache_service->set_force_keep_session_state();
[email protected]6e2d3d22012-02-24 18:10:36226}
227
[email protected]89acda82013-06-25 20:52:50228void SaveSessionStateOnIndexedDBThread(
[email protected]6e2d3d22012-02-24 18:10:36229 scoped_refptr<IndexedDBContextImpl> indexed_db_context) {
[email protected]bf510ed2012-06-05 08:31:43230 indexed_db_context->SetForceKeepSessionState();
[email protected]6e2d3d22012-02-24 18:10:36231}
232
falken41f4175162014-10-29 07:03:41233void ShutdownServiceWorkerContext(StoragePartition* partition) {
234 ServiceWorkerContextWrapper* wrapper =
235 static_cast<ServiceWorkerContextWrapper*>(
236 partition->GetServiceWorkerContext());
237 wrapper->process_manager()->Shutdown();
238}
239
avi1ed4a4372017-04-25 05:39:41240void SetDownloadManager(
241 BrowserContext* context,
242 std::unique_ptr<content::DownloadManager> download_manager) {
ttr31481dc54b2015-08-06 20:11:26243 DCHECK_CURRENTLY_ON(BrowserThread::UI);
244 DCHECK(download_manager);
avi1ed4a4372017-04-25 05:39:41245 context->SetUserData(kDownloadManagerKeyName, std::move(download_manager));
ttr31481dc54b2015-08-06 20:11:26246}
247
Ken Rockot499519e2018-12-04 06:57:44248std::unique_ptr<service_manager::Service>
249CreateMainThreadServiceForBrowserContext(
250 BrowserContext* browser_context,
251 const std::string& service_name,
252 service_manager::mojom::ServiceRequest request) {
253 if (service_name == content::mojom::kServiceName) {
254 auto* delegate_holder = static_cast<ContentServiceDelegateHolder*>(
255 browser_context->GetUserData(kContentServiceDelegateKey));
256 auto* delegate = delegate_holder->delegate();
257 auto service =
258 std::make_unique<content::Service>(delegate, std::move(request));
259 delegate->AddService(service.get());
260 return service;
261 }
262
263 return browser_context->HandleServiceRequest(service_name,
264 std::move(request));
265}
266
bend32292b2016-10-07 00:21:58267class BrowserContextServiceManagerConnectionHolder
rockot963ad3e82016-04-13 16:33:23268 : public base::SupportsUserData::Data {
269 public:
benaad37ecd2017-04-12 22:08:20270 explicit BrowserContextServiceManagerConnectionHolder(
Ken Rockot435132692018-11-20 21:46:10271 BrowserContext* browser_context,
Ken Rockot499519e2018-12-04 06:57:44272 service_manager::mojom::ServiceRequest request,
273 scoped_refptr<base::SequencedTaskRunner> main_thread_task_runner)
Ken Rockot435132692018-11-20 21:46:10274 : browser_context_(browser_context),
Ken Rockot499519e2018-12-04 06:57:44275 main_thread_task_runner_(std::move(main_thread_task_runner)),
Ken Rockot435132692018-11-20 21:46:10276 service_manager_connection_(ServiceManagerConnection::Create(
rockotcef38272016-07-15 22:47:47277 std::move(request),
Eric Seckler8652dcd52018-09-20 10:42:28278 base::CreateSingleThreadTaskRunnerWithTraits(
Ken Rockot435132692018-11-20 21:46:10279 {BrowserThread::IO}))) {
280 service_manager_connection_->SetDefaultServiceRequestHandler(
281 base::BindRepeating(
282 &BrowserContextServiceManagerConnectionHolder::OnServiceRequest,
283 weak_ptr_factory_.GetWeakPtr()));
284 }
bend32292b2016-10-07 00:21:58285 ~BrowserContextServiceManagerConnectionHolder() override {}
rockot963ad3e82016-04-13 16:33:23286
bend32292b2016-10-07 00:21:58287 ServiceManagerConnection* service_manager_connection() {
288 return service_manager_connection_.get();
289 }
rockot963ad3e82016-04-13 16:33:23290
Ken Rockotad3c7582018-12-12 17:04:14291 void DestroyRunningServices() { running_services_.clear(); }
292
rockot963ad3e82016-04-13 16:33:23293 private:
Ken Rockot435132692018-11-20 21:46:10294 void OnServiceRequest(const std::string& service_name,
295 service_manager::mojom::ServiceRequest request) {
296 std::unique_ptr<service_manager::Service> service =
Ken Rockot499519e2018-12-04 06:57:44297 CreateMainThreadServiceForBrowserContext(browser_context_, service_name,
298 std::move(request));
Ken Rockot435132692018-11-20 21:46:10299 if (!service) {
300 LOG(ERROR) << "Ignoring request for unknown per-browser-context service:"
301 << service_name;
302 return;
303 }
304
305 auto* raw_service = service.get();
306 service->set_termination_closure(base::BindOnce(
307 &BrowserContextServiceManagerConnectionHolder::OnServiceQuit,
308 base::Unretained(this), raw_service));
309 running_services_.emplace(raw_service, std::move(service));
310 }
311
312 void OnServiceQuit(service_manager::Service* service) {
313 running_services_.erase(service);
314 }
315
316 BrowserContext* const browser_context_;
Ken Rockot499519e2018-12-04 06:57:44317 const scoped_refptr<base::SequencedTaskRunner> main_thread_task_runner_;
bend32292b2016-10-07 00:21:58318 std::unique_ptr<ServiceManagerConnection> service_manager_connection_;
Ken Rockot435132692018-11-20 21:46:10319 std::map<service_manager::Service*, std::unique_ptr<service_manager::Service>>
320 running_services_;
321
322 base::WeakPtrFactory<BrowserContextServiceManagerConnectionHolder>
323 weak_ptr_factory_{this};
rockot963ad3e82016-04-13 16:33:23324
bend32292b2016-10-07 00:21:58325 DISALLOW_COPY_AND_ASSIGN(BrowserContextServiceManagerConnectionHolder);
rockot963ad3e82016-04-13 16:33:23326};
327
Jens Widell7ca8fb42018-02-21 14:11:54328base::WeakPtr<storage::BlobStorageContext> BlobStorageContextGetterForBrowser(
Xing Liu89860472018-02-09 20:07:02329 scoped_refptr<ChromeBlobStorageContext> blob_context) {
330 DCHECK_CURRENTLY_ON(BrowserThread::IO);
331 return blob_context->context()->AsWeakPtr();
332}
333
[email protected]735e20c2012-03-20 01:16:59334} // namespace
335
[email protected]14acc642012-11-17 12:20:10336// static
337void BrowserContext::AsyncObliterateStoragePartition(
338 BrowserContext* browser_context,
[email protected]399583b2012-12-11 09:33:42339 const GURL& site,
340 const base::Closure& on_gc_required) {
341 GetStoragePartitionMap(browser_context)->AsyncObliterate(site,
342 on_gc_required);
343}
344
345// static
346void BrowserContext::GarbageCollectStoragePartitions(
dcheng59716272016-04-09 05:19:08347 BrowserContext* browser_context,
Takuto Ikuta8332bf9d2019-01-05 03:58:00348 std::unique_ptr<std::unordered_set<base::FilePath>> active_paths,
dcheng59716272016-04-09 05:19:08349 const base::Closure& done) {
dcheng36b6aec92015-12-26 06:16:36350 GetStoragePartitionMap(browser_context)
351 ->GarbageCollect(std::move(active_paths), done);
[email protected]14acc642012-11-17 12:20:10352}
353
[email protected]b441a8492012-06-06 14:55:57354DownloadManager* BrowserContext::GetDownloadManager(
355 BrowserContext* context) {
mostynbfbcdc27a2015-03-13 17:58:52356 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]b441a8492012-06-06 14:55:57357 if (!context->GetUserData(kDownloadManagerKeyName)) {
Min Qinddb40ce2017-10-28 03:38:26358 DownloadManager* download_manager = new DownloadManagerImpl(context);
[email protected]d25fda12012-06-12 17:05:03359
avi1ed4a4372017-04-25 05:39:41360 SetDownloadManager(context, base::WrapUnique(download_manager));
[email protected]b441a8492012-06-06 14:55:57361 download_manager->SetDelegate(context->GetDownloadManagerDelegate());
[email protected]b441a8492012-06-06 14:55:57362 }
363
[email protected]eba4a4d2013-05-29 02:18:06364 return static_cast<DownloadManager*>(
365 context->GetUserData(kDownloadManagerKeyName));
[email protected]b441a8492012-06-06 14:55:57366}
367
[email protected]6ef0c3912013-01-25 22:46:34368// static
[email protected]cd501a72014-08-22 19:58:31369storage::ExternalMountPoints* BrowserContext::GetMountPoints(
[email protected]6ef0c3912013-01-25 22:46:34370 BrowserContext* context) {
371 // Ensure that these methods are called on the UI thread, except for
372 // unittests where a UI thread might not have been created.
373 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
Gabriel Charette2983181c2018-03-28 17:01:09374 !BrowserThread::IsThreadInitialized(BrowserThread::UI));
[email protected]6ef0c3912013-01-25 22:46:34375
376#if defined(OS_CHROMEOS)
377 if (!context->GetUserData(kMountPointsKey)) {
[email protected]cd501a72014-08-22 19:58:31378 scoped_refptr<storage::ExternalMountPoints> mount_points =
379 storage::ExternalMountPoints::CreateRefCounted();
[email protected]6ef0c3912013-01-25 22:46:34380 context->SetUserData(
381 kMountPointsKey,
Jeremy Roman04f27c372017-10-27 15:20:55382 std::make_unique<UserDataAdapter<storage::ExternalMountPoints>>(
avicb129c02017-05-03 06:49:29383 mount_points.get()));
[email protected]6ef0c3912013-01-25 22:46:34384 }
385
[email protected]cd501a72014-08-22 19:58:31386 return UserDataAdapter<storage::ExternalMountPoints>::Get(context,
387 kMountPointsKey);
[email protected]6ef0c3912013-01-25 22:46:34388#else
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28389 return nullptr;
[email protected]6ef0c3912013-01-25 22:46:34390#endif
391}
392
msrameke169ccb2017-04-26 05:21:41393// static
394content::BrowsingDataRemover* content::BrowserContext::GetBrowsingDataRemover(
395 BrowserContext* context) {
396 DCHECK_CURRENTLY_ON(BrowserThread::UI);
397
398 if (!context->GetUserData(kBrowsingDataRemoverKey)) {
399 std::unique_ptr<BrowsingDataRemoverImpl> remover =
Jeremy Roman04f27c372017-10-27 15:20:55400 std::make_unique<BrowsingDataRemoverImpl>(context);
msrameke169ccb2017-04-26 05:21:41401 remover->SetEmbedderDelegate(context->GetBrowsingDataRemoverDelegate());
402 context->SetUserData(kBrowsingDataRemoverKey, std::move(remover));
403 }
404
405 return static_cast<BrowsingDataRemoverImpl*>(
406 context->GetUserData(kBrowsingDataRemoverKey));
407}
408
Andrey Lushnikovebff0442018-07-12 20:02:58409// static
410content::PermissionController* content::BrowserContext::GetPermissionController(
411 BrowserContext* context) {
412 DCHECK_CURRENTLY_ON(BrowserThread::UI);
413
414 if (!context->GetUserData(kPermissionControllerKey)) {
415 context->SetUserData(kPermissionControllerKey,
416 std::make_unique<PermissionControllerImpl>(context));
417 }
418
419 return static_cast<PermissionControllerImpl*>(
420 context->GetUserData(kPermissionControllerKey));
421}
422
[email protected]4c3a23582012-08-18 08:54:34423StoragePartition* BrowserContext::GetStoragePartition(
424 BrowserContext* browser_context,
Dan Elphick6c0d8492017-09-12 09:35:38425 SiteInstance* site_instance,
426 bool can_create) {
[email protected]1bc28312012-11-08 08:31:53427 std::string partition_domain;
428 std::string partition_name;
429 bool in_memory = false;
[email protected]4c3a23582012-08-18 08:54:34430
[email protected]4c3a23582012-08-18 08:54:34431 if (site_instance) {
[email protected]1bc28312012-11-08 08:31:53432 GetContentClient()->browser()->GetStoragePartitionConfigForSite(
[email protected]14acc642012-11-17 12:20:10433 browser_context, site_instance->GetSiteURL(), true,
[email protected]1bc28312012-11-08 08:31:53434 &partition_domain, &partition_name, &in_memory);
[email protected]4c3a23582012-08-18 08:54:34435 }
436
Dan Elphick6c0d8492017-09-12 09:35:38437 return GetStoragePartitionFromConfig(browser_context, partition_domain,
438 partition_name, in_memory, can_create);
[email protected]4c3a23582012-08-18 08:54:34439}
440
[email protected]e94bbcb2012-09-07 05:33:57441StoragePartition* BrowserContext::GetStoragePartitionForSite(
442 BrowserContext* browser_context,
Dan Elphick6c0d8492017-09-12 09:35:38443 const GURL& site,
444 bool can_create) {
[email protected]1bc28312012-11-08 08:31:53445 std::string partition_domain;
446 std::string partition_name;
447 bool in_memory;
[email protected]e94bbcb2012-09-07 05:33:57448
[email protected]1bc28312012-11-08 08:31:53449 GetContentClient()->browser()->GetStoragePartitionConfigForSite(
[email protected]14acc642012-11-17 12:20:10450 browser_context, site, true, &partition_domain, &partition_name,
451 &in_memory);
[email protected]1bc28312012-11-08 08:31:53452
Dan Elphick6c0d8492017-09-12 09:35:38453 return GetStoragePartitionFromConfig(browser_context, partition_domain,
454 partition_name, in_memory, can_create);
[email protected]e94bbcb2012-09-07 05:33:57455}
456
[email protected]4c3a23582012-08-18 08:54:34457void BrowserContext::ForEachStoragePartition(
458 BrowserContext* browser_context,
459 const StoragePartitionCallback& callback) {
460 StoragePartitionImplMap* partition_map =
461 static_cast<StoragePartitionImplMap*>(
a.cavalcantiffab73762015-08-15 02:55:48462 browser_context->GetUserData(kStoragePartitionMapKeyName));
[email protected]4c3a23582012-08-18 08:54:34463 if (!partition_map)
464 return;
465
466 partition_map->ForEach(callback);
467}
468
469StoragePartition* BrowserContext::GetDefaultStoragePartition(
470 BrowserContext* browser_context) {
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28471 return GetStoragePartition(browser_context, nullptr);
[email protected]55eb70e762012-02-20 17:38:39472}
473
tbarzicdb712682015-03-06 06:05:41474// static
[email protected]393b6cb2014-05-15 00:55:12475void BrowserContext::CreateMemoryBackedBlob(BrowserContext* browser_context,
Marijn Kruisselbrink604fd7e72017-10-26 16:31:05476 const char* data,
477 size_t length,
478 const std::string& content_type,
479 BlobCallback callback) {
mostynbfbcdc27a2015-03-13 17:58:52480 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]393b6cb2014-05-15 00:55:12481
482 ChromeBlobStorageContext* blob_context =
483 ChromeBlobStorageContext::GetFor(browser_context);
Eric Seckler8652dcd52018-09-20 10:42:28484 base::PostTaskWithTraitsAndReplyWithResult(
485 FROM_HERE, {BrowserThread::IO},
Marijn Kruisselbrink604fd7e72017-10-26 16:31:05486 base::BindOnce(&ChromeBlobStorageContext::CreateMemoryBackedBlob,
487 base::WrapRefCounted(blob_context), data, length,
488 content_type),
489 std::move(callback));
[email protected]393b6cb2014-05-15 00:55:12490}
491
[email protected]66e53d0282014-08-07 10:04:35492// static
Xing Liu89860472018-02-09 20:07:02493BrowserContext::BlobContextGetter BrowserContext::GetBlobStorageContext(
494 BrowserContext* browser_context) {
495 DCHECK_CURRENTLY_ON(BrowserThread::UI);
496 scoped_refptr<ChromeBlobStorageContext> chrome_blob_context =
497 ChromeBlobStorageContext::GetFor(browser_context);
Jens Widell7ca8fb42018-02-21 14:11:54498 return base::BindRepeating(&BlobStorageContextGetterForBrowser,
499 chrome_blob_context);
Xing Liu89860472018-02-09 20:07:02500}
501
502// static
Marijn Kruisselbrink9e073a82018-06-18 17:48:58503blink::mojom::BlobPtr BrowserContext::GetBlobPtr(
504 BrowserContext* browser_context,
505 const std::string& uuid) {
506 DCHECK_CURRENTLY_ON(BrowserThread::UI);
507 return ChromeBlobStorageContext::GetBlobPtr(browser_context, uuid);
508}
509
510// static
[email protected]66e53d0282014-08-07 10:04:35511void BrowserContext::DeliverPushMessage(
512 BrowserContext* browser_context,
513 const GURL& origin,
avib7348942015-12-25 20:57:10514 int64_t service_worker_registration_id,
Han Leonc1deace2018-08-03 03:52:53515 base::Optional<std::string> payload,
Mario Sanchez Pradad2990112019-05-07 08:13:49516 const base::Callback<void(blink::mojom::PushDeliveryStatus)>& callback) {
mostynbfbcdc27a2015-03-13 17:58:52517 DCHECK_CURRENTLY_ON(BrowserThread::UI);
harknessdd4d2b22016-01-27 19:26:43518 PushMessagingRouter::DeliverMessage(browser_context, origin,
Han Leonc1deace2018-08-03 03:52:53519 service_worker_registration_id,
520 std::move(payload), callback);
[email protected]66e53d0282014-08-07 10:04:35521}
522
falken41f4175162014-10-29 07:03:41523// static
524void BrowserContext::NotifyWillBeDestroyed(BrowserContext* browser_context) {
Lukasz Anforowicz58d0dac2018-03-23 15:48:10525 // Make sure NotifyWillBeDestroyed is idempotent. This helps facilitate the
526 // pattern where NotifyWillBeDestroyed is called from *both*
Kent Tamura21d1de62018-12-10 04:45:20527 // ShellBrowserContext and its derived classes (e.g. WebTestBrowserContext).
Lukasz Anforowicz58d0dac2018-03-23 15:48:10528 if (browser_context->was_notify_will_be_destroyed_called_)
529 return;
530 browser_context->was_notify_will_be_destroyed_called_ = true;
531
Ken Rockot99c5bc742018-07-12 15:36:56532 // Subclasses of BrowserContext may expect there to be no more
533 // RenderProcessHosts using them by the time this function returns. We
534 // therefore explicitly tear down embedded Content Service instances now to
535 // ensure that all their WebContents (and therefore RPHs) are torn down too.
536 browser_context->RemoveUserData(kContentServiceDelegateKey);
537
Ken Rockotad3c7582018-12-12 17:04:14538 // Tear down all running service instances which were started on behalf of
539 // this BrowserContext. Note that we leave the UserData itself in place
540 // because it's possible for someone to call
541 // |GetServiceManagerConnectionFor()| between now and actual BrowserContext
542 // destruction.
543 BrowserContextServiceManagerConnectionHolder* connection_holder =
544 static_cast<BrowserContextServiceManagerConnectionHolder*>(
545 browser_context->GetUserData(kServiceManagerConnection));
546 if (connection_holder)
547 connection_holder->DestroyRunningServices();
548
falken41f4175162014-10-29 07:03:41549 // Service Workers must shutdown before the browser context is destroyed,
550 // since they keep render process hosts alive and the codebase assumes that
551 // render process hosts die before their profile (browser context) dies.
552 ForEachStoragePartition(browser_context,
553 base::Bind(ShutdownServiceWorkerContext));
falken04a6912a2016-09-23 21:06:29554
555 // Shared workers also keep render process hosts alive, and are expected to
Darin Fisherd3768b2f62017-10-07 01:00:16556 // return ref counts to 0 after documents close. However, to ensure that
557 // hosts are destructed now, forcibly release their ref counts here.
falken04a6912a2016-09-23 21:06:29558 for (RenderProcessHost::iterator host_iterator =
559 RenderProcessHost::AllHostsIterator();
560 !host_iterator.IsAtEnd(); host_iterator.Advance()) {
561 RenderProcessHost* host = host_iterator.GetCurrentValue();
Benoit Lizeab08362c2017-07-19 14:50:54562 if (host->GetBrowserContext() == browser_context) {
563 // This will also clean up spare RPH references.
Yutaka Hirano09a9afb92017-08-16 09:11:45564 host->DisableKeepAliveRefCount();
Benoit Lizeab08362c2017-07-19 14:50:54565 }
falken04a6912a2016-09-23 21:06:29566 }
Alex Moshchuk99b795422019-03-07 00:27:32567
Aaron Colwell67f93006c2019-04-01 22:45:28568 // Clean up any isolated origins associated with this BrowserContext. This
Alex Moshchuk99b795422019-03-07 00:27:32569 // should be safe now that all RenderProcessHosts are destroyed, since future
570 // navigations or security decisions shouldn't ever need to consult these
Aaron Colwell67f93006c2019-04-01 22:45:28571 // isolated origins.
Alex Moshchuk99b795422019-03-07 00:27:32572 ChildProcessSecurityPolicyImpl* policy =
573 ChildProcessSecurityPolicyImpl::GetInstance();
Aaron Colwell67f93006c2019-04-01 22:45:28574 policy->RemoveIsolatedOriginsForBrowserContext(*browser_context);
falken41f4175162014-10-29 07:03:41575}
576
[email protected]314c3e22012-02-21 03:57:42577void BrowserContext::EnsureResourceContextInitialized(BrowserContext* context) {
[email protected]7e26ac92012-02-27 20:15:05578 // This will be enough to tickle initialization of BrowserContext if
579 // necessary, which initializes ResourceContext. The reason we don't call
[email protected]4c3a23582012-08-18 08:54:34580 // ResourceContext::InitializeResourceContext() directly here is that
581 // ResourceContext initialization may call back into BrowserContext
582 // and when that call returns it'll end rewriting its UserData map. It will
583 // end up rewriting the same value but this still causes a race condition.
584 //
585 // See http://crbug.com/115678.
586 GetDefaultStoragePartition(context);
[email protected]55eb70e762012-02-20 17:38:39587}
588
[email protected]6e2d3d22012-02-24 18:10:36589void BrowserContext::SaveSessionState(BrowserContext* browser_context) {
[email protected]b1b502e2012-09-16 07:31:43590 StoragePartition* storage_partition =
591 BrowserContext::GetDefaultStoragePartition(browser_context);
[email protected]6e2d3d22012-02-24 18:10:36592
Joshua Bell607cb142017-07-24 19:17:16593 storage::DatabaseTracker* database_tracker =
594 storage_partition->GetDatabaseTracker();
595 database_tracker->task_runner()->PostTask(
596 FROM_HERE,
597 base::BindOnce(&storage::DatabaseTracker::SetForceKeepSessionState,
kylecharda69d882017-10-04 05:49:52598 base::WrapRefCounted(database_tracker)));
Joshua Bell607cb142017-07-24 19:17:16599
Gabriel Charette2983181c2018-03-28 17:01:09600 if (BrowserThread::IsThreadInitialized(BrowserThread::IO)) {
John Abd-El-Malekb175a612018-12-03 20:11:58601 scoped_refptr<net::URLRequestContextGetter> context_getter;
602 // Channel ID isn't supported with network service.
603 if (!base::FeatureList::IsEnabled(network::features::kNetworkService))
604 context_getter = storage_partition->GetURLRequestContext();
Eric Seckler8652dcd52018-09-20 10:42:28605 base::PostTaskWithTraits(
606 FROM_HERE, {BrowserThread::IO},
John Abd-El-Malekb175a612018-12-03 20:11:58607 base::BindOnce(&SaveSessionStateOnIOThread, context_getter,
608 static_cast<AppCacheServiceImpl*>(
609 storage_partition->GetAppCacheService())));
[email protected]6e2d3d22012-02-24 18:10:36610 }
611
Clark DuVall385b5a52018-06-14 21:33:32612 storage_partition->GetCookieManagerForBrowserProcess()
613 ->SetForceKeepSessionState();
614
[email protected]5f2aa722013-08-07 16:59:41615 DOMStorageContextWrapper* dom_storage_context_proxy =
616 static_cast<DOMStorageContextWrapper*>(
[email protected]b1b502e2012-09-16 07:31:43617 storage_partition->GetDOMStorageContext());
[email protected]5f2aa722013-08-07 16:59:41618 dom_storage_context_proxy->SetForceKeepSessionState();
[email protected]735e20c2012-03-20 01:16:59619
[email protected]89acda82013-06-25 20:52:50620 IndexedDBContextImpl* indexed_db_context_impl =
621 static_cast<IndexedDBContextImpl*>(
[email protected]b1b502e2012-09-16 07:31:43622 storage_partition->GetIndexedDBContext());
[email protected]89acda82013-06-25 20:52:50623 // No task runner in unit tests.
624 if (indexed_db_context_impl->TaskRunner()) {
625 indexed_db_context_impl->TaskRunner()->PostTask(
kylecharda69d882017-10-04 05:49:52626 FROM_HERE,
627 base::BindOnce(&SaveSessionStateOnIndexedDBThread,
628 base::WrapRefCounted(indexed_db_context_impl)));
[email protected]6e2d3d22012-02-24 18:10:36629 }
630}
631
ttr31481dc54b2015-08-06 20:11:26632void BrowserContext::SetDownloadManagerForTesting(
633 BrowserContext* browser_context,
avi1ed4a4372017-04-25 05:39:41634 std::unique_ptr<content::DownloadManager> download_manager) {
635 SetDownloadManager(browser_context, std::move(download_manager));
ttr31481dc54b2015-08-06 20:11:26636}
637
rockot963ad3e82016-04-13 16:33:23638// static
erge69130f52016-03-02 00:13:28639void BrowserContext::Initialize(
640 BrowserContext* browser_context,
641 const base::FilePath& path) {
Ken Rockotda7edc62018-11-10 01:01:45642 const base::Token new_group = base::Token::CreateRandom();
643 ServiceInstanceGroupHolder* holder = static_cast<ServiceInstanceGroupHolder*>(
644 browser_context->GetUserData(kServiceInstanceGroup));
645 if (holder) {
646 file::ForgetServiceInstanceGroupUserDirAssociation(
647 holder->instance_group());
ben6c85c4492016-06-16 20:40:51648 }
Ken Rockotda7edc62018-11-10 01:01:45649 file::AssociateServiceInstanceGroupWithUserDir(new_group, path);
650 RemoveBrowserContextFromInstanceGroupMap(browser_context);
651 GetTokenToContextMap()[new_group] = browser_context;
avi1ed4a4372017-04-25 05:39:41652 browser_context->SetUserData(
Ken Rockotda7edc62018-11-10 01:01:45653 kServiceInstanceGroup,
654 std::make_unique<ServiceInstanceGroupHolder>(new_group));
rockot963ad3e82016-04-13 16:33:23655
bend32292b2016-10-07 00:21:58656 ServiceManagerConnection* service_manager_connection =
657 ServiceManagerConnection::GetForProcess();
fdoray4f155f02016-10-12 11:28:50658 if (service_manager_connection && base::ThreadTaskRunnerHandle::IsSet()) {
rockot963ad3e82016-04-13 16:33:23659 // NOTE: Many unit tests create a TestBrowserContext without initializing
bend32292b2016-10-07 00:21:58660 // Mojo or the global service manager connection.
rockot963ad3e82016-04-13 16:33:23661
Ken Rockot40a1df792019-05-08 22:15:52662 mojo::PendingRemote<service_manager::mojom::Service> service;
663 auto service_receiver = service.InitWithNewPipeAndPassReceiver();
rockot963ad3e82016-04-13 16:33:23664
Ken Rockot40a1df792019-05-08 22:15:52665 mojo::Remote<service_manager::mojom::ProcessMetadata> metadata;
Ken Rockota86fa542018-11-13 21:47:13666 service_manager::Identity identity(mojom::kBrowserServiceName, new_group,
667 base::Token{},
668 base::Token::CreateRandom());
669 service_manager_connection->GetConnector()->RegisterServiceInstance(
Ken Rockot40a1df792019-05-08 22:15:52670 identity, std::move(service), metadata.BindNewPipeAndPassReceiver());
671 metadata->SetPID(base::GetCurrentProcId());
rockot963ad3e82016-04-13 16:33:23672
bend32292b2016-10-07 00:21:58673 BrowserContextServiceManagerConnectionHolder* connection_holder =
674 new BrowserContextServiceManagerConnectionHolder(
Ken Rockot40a1df792019-05-08 22:15:52675 browser_context, std::move(service_receiver),
Ken Rockot499519e2018-12-04 06:57:44676 base::SequencedTaskRunnerHandle::Get());
avi1ed4a4372017-04-25 05:39:41677 browser_context->SetUserData(kServiceManagerConnection,
678 base::WrapUnique(connection_holder));
bend32292b2016-10-07 00:21:58679 ServiceManagerConnection* connection =
680 connection_holder->service_manager_connection();
rockot963ad3e82016-04-13 16:33:23681
Ken Rockot84f58fd2018-06-22 21:54:14682 browser_context->SetUserData(
683 kContentServiceDelegateKey,
684 std::make_unique<ContentServiceDelegateHolder>(browser_context));
685
Ken Rockot499519e2018-12-04 06:57:44686 scoped_refptr<FileServiceIOThreadState> file_service_io_thread_state =
687 base::MakeRefCounted<FileServiceIOThreadState>(
688 base::CreateSingleThreadTaskRunnerWithTraits({BrowserThread::IO}));
689 connection->AddServiceRequestHandler(
690 file::mojom::kServiceName,
691 base::BindRepeating(
692 [](scoped_refptr<FileServiceIOThreadState> io_thread_state,
693 service_manager::mojom::ServiceRequest request) {
694 io_thread_state->StartOnIOThread(std::move(request));
695 },
696 file_service_io_thread_state));
697
698 browser_context->SetUserData(kFileServiceKey,
699 std::make_unique<FileServiceHolder>(
700 std::move(file_service_io_thread_state)));
tibellab3d36b2017-03-10 02:57:25701
Ken Rockotc7a279c2017-05-04 23:51:45702 RegisterCommonBrowserInterfaces(connection);
sammc030f5012017-03-13 02:28:45703 connection->Start();
rockot963ad3e82016-04-13 16:33:23704 }
erge69130f52016-03-02 00:13:28705}
706
rockot963ad3e82016-04-13 16:33:23707// static
Ken Rockotda7edc62018-11-10 01:01:45708const base::Token& BrowserContext::GetServiceInstanceGroupFor(
bencccfe2a2016-03-05 16:54:14709 BrowserContext* browser_context) {
Ken Rockotda7edc62018-11-10 01:01:45710 ServiceInstanceGroupHolder* holder = static_cast<ServiceInstanceGroupHolder*>(
711 browser_context->GetUserData(kServiceInstanceGroup));
712 CHECK(holder) << "Attempting to get the instance group for a BrowserContext "
713 << "that was never Initialized().";
714 return holder->instance_group();
erge69130f52016-03-02 00:13:28715}
716
rockot963ad3e82016-04-13 16:33:23717// static
Ken Rockotda7edc62018-11-10 01:01:45718BrowserContext* BrowserContext::GetBrowserContextForServiceInstanceGroup(
719 const base::Token& instance_group) {
720 auto it = GetTokenToContextMap().find(instance_group);
721 return it != GetTokenToContextMap().end() ? it->second : nullptr;
ben6c85c4492016-06-16 20:40:51722}
723
724// static
rockot400ea35b2016-10-15 19:15:32725service_manager::Connector* BrowserContext::GetConnectorFor(
rockot963ad3e82016-04-13 16:33:23726 BrowserContext* browser_context) {
bend32292b2016-10-07 00:21:58727 ServiceManagerConnection* connection =
728 GetServiceManagerConnectionFor(browser_context);
ben5be0b9132016-08-03 00:17:18729 return connection ? connection->GetConnector() : nullptr;
730}
731
732// static
bend32292b2016-10-07 00:21:58733ServiceManagerConnection* BrowserContext::GetServiceManagerConnectionFor(
ben5be0b9132016-08-03 00:17:18734 BrowserContext* browser_context) {
bend32292b2016-10-07 00:21:58735 BrowserContextServiceManagerConnectionHolder* connection_holder =
736 static_cast<BrowserContextServiceManagerConnectionHolder*>(
737 browser_context->GetUserData(kServiceManagerConnection));
738 return connection_holder ? connection_holder->service_manager_connection()
739 : nullptr;
rockot963ad3e82016-04-13 16:33:23740}
741
mmenkec0b2b8b12017-04-21 16:27:52742BrowserContext::BrowserContext()
Takashi Toyoshima0190a3b2019-01-21 07:39:06743 : unique_id_(base::UnguessableToken::Create().ToString()) {}
mmenkec0b2b8b12017-04-21 16:27:52744
[email protected]55eb70e762012-02-20 17:38:39745BrowserContext::~BrowserContext() {
Ken Rockotda7edc62018-11-10 01:01:45746 CHECK(GetUserData(kServiceInstanceGroup))
erge69130f52016-03-02 00:13:28747 << "Attempting to destroy a BrowserContext that never called "
748 << "Initialize()";
749
kinukof6ed359c2016-07-26 13:27:21750 DCHECK(!GetUserData(kStoragePartitionMapKeyName))
751 << "StoragePartitionMap is not shut down properly";
752
Lukasz Anforowicz58d0dac2018-03-23 15:48:10753 DCHECK(was_notify_will_be_destroyed_called_);
754
Ken Rockotda7edc62018-11-10 01:01:45755 RemoveBrowserContextFromInstanceGroupMap(this);
ben6c85c4492016-06-16 20:40:51756
[email protected]b441a8492012-06-06 14:55:57757 if (GetUserData(kDownloadManagerKeyName))
758 GetDownloadManager(this)->Shutdown();
[email protected]55eb70e762012-02-20 17:38:39759}
760
kinukof6ed359c2016-07-26 13:27:21761void BrowserContext::ShutdownStoragePartitions() {
762 if (GetUserData(kStoragePartitionMapKeyName))
763 RemoveUserData(kStoragePartitionMapKeyName);
764}
765
mmenkec0b2b8b12017-04-21 16:27:52766std::string BrowserContext::GetMediaDeviceIDSalt() {
Andrey Lushnikovd39d9062018-04-24 17:33:35767 return unique_id_;
mmenkec0b2b8b12017-04-21 16:27:52768}
769
770// static
771std::string BrowserContext::CreateRandomMediaDeviceIDSalt() {
Andrey Lushnikovd39d9062018-04-24 17:33:35772 return base::UnguessableToken::Create().ToString();
773}
774
Ken Rockot435132692018-11-20 21:46:10775std::unique_ptr<service_manager::Service> BrowserContext::HandleServiceRequest(
776 const std::string& service_name,
777 service_manager::mojom::ServiceRequest request) {
778 return nullptr;
779}
780
Andrey Lushnikovd39d9062018-04-24 17:33:35781const std::string& BrowserContext::UniqueId() const {
782 return unique_id_;
mmenkec0b2b8b12017-04-21 16:27:52783}
784
Chris Cunninghama5b38012017-10-28 07:27:18785media::VideoDecodePerfHistory* BrowserContext::GetVideoDecodePerfHistory() {
786 media::VideoDecodePerfHistory* decode_history =
787 static_cast<media::VideoDecodePerfHistory*>(
788 GetUserData(kVideoDecodePerfHistoryId));
789
790 // Lazily created. Note, this does not trigger loading the DB from disk. That
791 // occurs later upon first VideoDecodePerfHistory API request that requires DB
792 // access. DB operations will not block the UI thread.
793 if (!decode_history) {
chcunningham06b81092018-09-24 20:20:51794 std::unique_ptr<media::VideoDecodeStatsDBImpl> stats_db =
795 media::VideoDecodeStatsDBImpl::Create(
796 GetPath().Append(FILE_PATH_LITERAL("VideoDecodeStats")));
[email protected]3dcea37a2019-02-11 19:46:51797 auto new_decode_history = std::make_unique<media::VideoDecodePerfHistory>(
798 std::move(stats_db), BrowserFeatureProvider::GetFactoryCB());
chcunningham06b81092018-09-24 20:20:51799 decode_history = new_decode_history.get();
800
801 SetUserData(kVideoDecodePerfHistoryId, std::move(new_decode_history));
Chris Cunninghama5b38012017-10-28 07:27:18802 }
803
804 return decode_history;
805}
806
Min Qind3ff2ed62018-07-21 06:46:59807download::InProgressDownloadManager*
808BrowserContext::RetriveInProgressDownloadManager() {
809 return nullptr;
810}
811
Takashi Toyoshima0190a3b2019-01-21 07:39:06812void BrowserContext::SetCorsOriginAccessListForOrigin(
813 const url::Origin& source_origin,
814 std::vector<network::mojom::CorsOriginPatternPtr> allow_patterns,
815 std::vector<network::mojom::CorsOriginPatternPtr> block_patterns,
816 base::OnceClosure closure) {
817 NOTREACHED() << "Sub-classes should implement this method to communicate "
818 "with NetworkService to bypass CORS checks.";
819}
820
821const SharedCorsOriginAccessList*
822BrowserContext::GetSharedCorsOriginAccessList() const {
823 // Need to return a valid instance regardless of CORS bypass supports.
824 static const base::NoDestructor<scoped_refptr<SharedCorsOriginAccessList>>
825 empty_list(SharedCorsOriginAccessList::Create());
826 return empty_list->get();
827}
828
[email protected]55eb70e762012-02-20 17:38:39829} // namespace content