blob: 0ff903d5fe327f492536c371f13b29d1f108b57b [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>
dcheng36b6aec92015-12-26 06:16:3613#include <utility>
rockot963ad3e82016-04-13 16:33:2314#include <vector>
avib7348942015-12-25 20:57:1015
mmenkec0b2b8b12017-04-21 16:27:5216#include "base/base64.h"
rockot963ad3e82016-04-13 16:33:2317#include "base/command_line.h"
Chris Cunninghama5b38012017-10-28 07:27:1818#include "base/files/file_path.h"
bencccfe2a2016-03-05 16:54:1419#include "base/guid.h"
erge69130f52016-03-02 00:13:2820#include "base/lazy_instance.h"
mmenkec0b2b8b12017-04-21 16:27:5221#include "base/logging.h"
rockot963ad3e82016-04-13 16:33:2322#include "base/macros.h"
avi1ed4a4372017-04-25 05:39:4123#include "base/memory/ptr_util.h"
erge69130f52016-03-02 00:13:2824#include "base/rand_util.h"
mek17399e672017-05-09 03:51:2025#include "base/task_scheduler/post_task.h"
Ken Rockot84f58fd2018-06-22 21:54:1426#include "base/threading/sequenced_task_runner_handle.h"
ben21a34c252016-06-29 22:24:3727#include "base/threading/thread_task_runner_handle.h"
Andrey Lushnikovd39d9062018-04-24 17:33:3528#include "base/unguessable_token.h"
avib7348942015-12-25 20:57:1029#include "build/build_config.h"
dmurph7ac019a2016-05-13 00:13:1730#include "content/browser/blob_storage/chrome_blob_storage_context.h"
msrameke169ccb2017-04-26 05:21:4131#include "content/browser/browsing_data/browsing_data_remover_impl.h"
Ken Rockot84f58fd2018-06-22 21:54:1432#include "content/browser/content_service_delegate_impl.h"
[email protected]b441a8492012-06-06 14:55:5733#include "content/browser/download/download_manager_impl.h"
[email protected]c4d281662013-03-31 00:35:0834#include "content/browser/indexed_db/indexed_db_context_impl.h"
[email protected]678c0362012-12-05 08:02:4435#include "content/browser/loader/resource_dispatcher_host_impl.h"
Andrey Lushnikovebff0442018-07-12 20:02:5836#include "content/browser/permissions/permission_controller_impl.h"
mvanouwerkerk17205ea2014-11-07 17:30:1537#include "content/browser/push_messaging/push_messaging_router.h"
Ken Rockotc7a279c2017-05-04 23:51:4538#include "content/browser/service_manager/common_browser_interfaces.h"
[email protected]4c3a23582012-08-18 08:54:3439#include "content/browser/storage_partition_impl_map.h"
[email protected]d7c7c98a2012-07-12 21:27:4440#include "content/common/child_process_host_impl.h"
[email protected]393b6cb2014-05-15 00:55:1241#include "content/public/browser/blob_handle.h"
[email protected]55eb70e762012-02-20 17:38:3942#include "content/public/browser/browser_thread.h"
[email protected]b441a8492012-06-06 14:55:5743#include "content/public/browser/content_browser_client.h"
falken04a6912a2016-09-23 21:06:2944#include "content/public/browser/render_process_host.h"
[email protected]536fd0b2013-03-14 17:41:5745#include "content/public/browser/site_instance.h"
Elad Alon12ecdf02018-03-14 12:07:3146#include "content/public/browser/webrtc_event_logger.h"
rockot963ad3e82016-04-13 16:33:2347#include "content/public/common/content_switches.h"
bend32292b2016-10-07 00:21:5848#include "content/public/common/service_manager_connection.h"
ben51bb6c62016-11-17 20:15:5749#include "content/public/common/service_names.mojom.h"
Chris Cunningham9e669472017-11-15 21:03:1150#include "media/capabilities/video_decode_stats_db_impl.h"
Chris Cunninghama5b38012017-10-28 07:27:1851#include "media/mojo/services/video_decode_perf_history.h"
[email protected]4d7c4ef2012-03-16 01:47:1252#include "net/cookies/cookie_store.h"
[email protected]6b8a3c742014-07-25 00:25:3553#include "net/ssl/channel_id_service.h"
54#include "net/ssl/channel_id_store.h"
[email protected]6e2d3d22012-02-24 18:10:3655#include "net/url_request/url_request_context.h"
[email protected]6939075a2012-08-28 08:35:5356#include "net/url_request/url_request_context_getter.h"
Ken Rockot84f58fd2018-06-22 21:54:1457#include "services/content/public/mojom/constants.mojom.h"
58#include "services/content/service.h"
ben768c8dc2016-08-12 00:26:5059#include "services/file/file_service.h"
Ken Rockot21142de2018-02-10 01:45:3060#include "services/file/public/mojom/constants.mojom.h"
ben768c8dc2016-08-12 00:26:5061#include "services/file/user_id_map.h"
rockot734fb662016-10-15 16:41:3062#include "services/service_manager/public/cpp/connector.h"
Ken Rockot543f5e32018-02-04 02:13:5063#include "services/service_manager/public/mojom/service.mojom.h"
Xing Liu89860472018-02-09 20:07:0264#include "storage/browser/blob/blob_storage_context.h"
pilgrime92c5fcd2014-09-10 23:31:2365#include "storage/browser/database/database_tracker.h"
66#include "storage/browser/fileapi/external_mount_points.h"
[email protected]55eb70e762012-02-20 17:38:3967
Elad Alon03ad23b2018-02-07 16:54:3168
[email protected]314c3e22012-02-21 03:57:4269using base::UserDataAdapter;
[email protected]55eb70e762012-02-20 17:38:3970
[email protected]55eb70e762012-02-20 17:38:3971namespace content {
72
[email protected]735e20c2012-03-20 01:16:5973namespace {
74
scottmg5e65e3a2017-03-08 08:48:4675base::LazyInstance<std::map<std::string, BrowserContext*>>::DestructorAtExit
ben6c85c4492016-06-16 20:40:5176 g_user_id_to_context = LAZY_INSTANCE_INITIALIZER;
77
bend32292b2016-10-07 00:21:5878class ServiceUserIdHolder : public base::SupportsUserData::Data {
ben6c85c4492016-06-16 20:40:5179 public:
bend32292b2016-10-07 00:21:5880 explicit ServiceUserIdHolder(const std::string& user_id)
81 : user_id_(user_id) {}
82 ~ServiceUserIdHolder() override {}
ben6c85c4492016-06-16 20:40:5183
84 const std::string& user_id() const { return user_id_; }
85
86 private:
87 std::string user_id_;
88
bend32292b2016-10-07 00:21:5889 DISALLOW_COPY_AND_ASSIGN(ServiceUserIdHolder);
ben6c85c4492016-06-16 20:40:5190};
erge69130f52016-03-02 00:13:2891
Ken Rockot84f58fd2018-06-22 21:54:1492class ContentServiceDelegateHolder : public base::SupportsUserData::Data {
93 public:
94 explicit ContentServiceDelegateHolder(BrowserContext* browser_context)
95 : delegate_(browser_context) {}
96 ~ContentServiceDelegateHolder() override = default;
97
98 ContentServiceDelegateImpl* delegate() { return &delegate_; }
99
100 private:
101 ContentServiceDelegateImpl delegate_;
102
103 DISALLOW_COPY_AND_ASSIGN(ContentServiceDelegateHolder);
104};
105
[email protected]e0ce8a1e2012-09-18 10:26:36106// Key names on BrowserContext.
msrameke169ccb2017-04-26 05:21:41107const char kBrowsingDataRemoverKey[] = "browsing-data-remover";
Ken Rockot84f58fd2018-06-22 21:54:14108const char kContentServiceDelegateKey[] = "content-service-delegate";
Andrey Lushnikovebff0442018-07-12 20:02:58109const char kPermissionControllerKey[] = "permission-controller";
[email protected]6ef0c3912013-01-25 22:46:34110const char kDownloadManagerKeyName[] = "download_manager";
erge69130f52016-03-02 00:13:28111const char kMojoWasInitialized[] = "mojo-was-initialized";
bend32292b2016-10-07 00:21:58112const char kServiceManagerConnection[] = "service-manager-connection";
113const char kServiceUserId[] = "service-user-id";
rockot963ad3e82016-04-13 16:33:23114const char kStoragePartitionMapKeyName[] = "content_storage_partition_map";
Chris Cunninghama5b38012017-10-28 07:27:18115const char kVideoDecodePerfHistoryId[] = "video-decode-perf-history";
erge69130f52016-03-02 00:13:28116
[email protected]9afc14e22013-09-25 22:34:14117#if defined(OS_CHROMEOS)
118const char kMountPointsKey[] = "mount_points";
119#endif // defined(OS_CHROMEOS)
120
ben6c85c4492016-06-16 20:40:51121void RemoveBrowserContextFromUserIdMap(BrowserContext* browser_context) {
bend32292b2016-10-07 00:21:58122 ServiceUserIdHolder* holder = static_cast<ServiceUserIdHolder*>(
123 browser_context->GetUserData(kServiceUserId));
ben6c85c4492016-06-16 20:40:51124 if (holder) {
125 auto it = g_user_id_to_context.Get().find(holder->user_id());
126 if (it != g_user_id_to_context.Get().end())
127 g_user_id_to_context.Get().erase(it);
128 }
129}
130
[email protected]14acc642012-11-17 12:20:10131StoragePartitionImplMap* GetStoragePartitionMap(
132 BrowserContext* browser_context) {
[email protected]4c3a23582012-08-18 08:54:34133 StoragePartitionImplMap* partition_map =
134 static_cast<StoragePartitionImplMap*>(
a.cavalcantiffab73762015-08-15 02:55:48135 browser_context->GetUserData(kStoragePartitionMapKeyName));
[email protected]d7c7c98a2012-07-12 21:27:44136 if (!partition_map) {
avi1ed4a4372017-04-25 05:39:41137 auto partition_map_owned =
Jeremy Roman04f27c372017-10-27 15:20:55138 std::make_unique<StoragePartitionImplMap>(browser_context);
avi1ed4a4372017-04-25 05:39:41139 partition_map = partition_map_owned.get();
140 browser_context->SetUserData(kStoragePartitionMapKeyName,
141 std::move(partition_map_owned));
[email protected]d7c7c98a2012-07-12 21:27:44142 }
[email protected]14acc642012-11-17 12:20:10143 return partition_map;
144}
145
146StoragePartition* GetStoragePartitionFromConfig(
147 BrowserContext* browser_context,
148 const std::string& partition_domain,
149 const std::string& partition_name,
Dan Elphick6c0d8492017-09-12 09:35:38150 bool in_memory,
151 bool can_create) {
[email protected]14acc642012-11-17 12:20:10152 StoragePartitionImplMap* partition_map =
153 GetStoragePartitionMap(browser_context);
[email protected]d7c7c98a2012-07-12 21:27:44154
[email protected]1bc28312012-11-08 08:31:53155 if (browser_context->IsOffTheRecord())
156 in_memory = true;
157
Dan Elphick6c0d8492017-09-12 09:35:38158 return partition_map->Get(partition_domain, partition_name, in_memory,
159 can_create);
[email protected]d1198fd2012-08-13 22:50:19160}
161
[email protected]6939075a2012-08-28 08:35:53162void SaveSessionStateOnIOThread(
163 const scoped_refptr<net::URLRequestContextGetter>& context_getter,
[email protected]98d6d4562014-06-25 20:57:55164 AppCacheServiceImpl* appcache_service) {
[email protected]6939075a2012-08-28 08:35:53165 net::URLRequestContext* context = context_getter->GetURLRequestContext();
mmenkeded79da2016-02-06 08:28:51166 context->cookie_store()->SetForceKeepSessionState();
Reid Klecknerc1148882018-05-11 00:04:07167 context->channel_id_service()->GetChannelIDStore()->
168 SetForceKeepSessionState();
[email protected]6939075a2012-08-28 08:35:53169 appcache_service->set_force_keep_session_state();
[email protected]6e2d3d22012-02-24 18:10:36170}
171
[email protected]89acda82013-06-25 20:52:50172void SaveSessionStateOnIndexedDBThread(
[email protected]6e2d3d22012-02-24 18:10:36173 scoped_refptr<IndexedDBContextImpl> indexed_db_context) {
[email protected]bf510ed2012-06-05 08:31:43174 indexed_db_context->SetForceKeepSessionState();
[email protected]6e2d3d22012-02-24 18:10:36175}
176
falken41f4175162014-10-29 07:03:41177void ShutdownServiceWorkerContext(StoragePartition* partition) {
178 ServiceWorkerContextWrapper* wrapper =
179 static_cast<ServiceWorkerContextWrapper*>(
180 partition->GetServiceWorkerContext());
181 wrapper->process_manager()->Shutdown();
182}
183
avi1ed4a4372017-04-25 05:39:41184void SetDownloadManager(
185 BrowserContext* context,
186 std::unique_ptr<content::DownloadManager> download_manager) {
ttr31481dc54b2015-08-06 20:11:26187 DCHECK_CURRENTLY_ON(BrowserThread::UI);
188 DCHECK(download_manager);
avi1ed4a4372017-04-25 05:39:41189 context->SetUserData(kDownloadManagerKeyName, std::move(download_manager));
ttr31481dc54b2015-08-06 20:11:26190}
191
bend32292b2016-10-07 00:21:58192class BrowserContextServiceManagerConnectionHolder
rockot963ad3e82016-04-13 16:33:23193 : public base::SupportsUserData::Data {
194 public:
benaad37ecd2017-04-12 22:08:20195 explicit BrowserContextServiceManagerConnectionHolder(
rockot400ea35b2016-10-15 19:15:32196 service_manager::mojom::ServiceRequest request)
benaad37ecd2017-04-12 22:08:20197 : service_manager_connection_(ServiceManagerConnection::Create(
rockotcef38272016-07-15 22:47:47198 std::move(request),
199 BrowserThread::GetTaskRunnerForThread(BrowserThread::IO))) {}
bend32292b2016-10-07 00:21:58200 ~BrowserContextServiceManagerConnectionHolder() override {}
rockot963ad3e82016-04-13 16:33:23201
bend32292b2016-10-07 00:21:58202 ServiceManagerConnection* service_manager_connection() {
203 return service_manager_connection_.get();
204 }
rockot963ad3e82016-04-13 16:33:23205
206 private:
bend32292b2016-10-07 00:21:58207 std::unique_ptr<ServiceManagerConnection> service_manager_connection_;
rockot963ad3e82016-04-13 16:33:23208
bend32292b2016-10-07 00:21:58209 DISALLOW_COPY_AND_ASSIGN(BrowserContextServiceManagerConnectionHolder);
rockot963ad3e82016-04-13 16:33:23210};
211
Jens Widell7ca8fb42018-02-21 14:11:54212base::WeakPtr<storage::BlobStorageContext> BlobStorageContextGetterForBrowser(
Xing Liu89860472018-02-09 20:07:02213 scoped_refptr<ChromeBlobStorageContext> blob_context) {
214 DCHECK_CURRENTLY_ON(BrowserThread::IO);
215 return blob_context->context()->AsWeakPtr();
216}
217
[email protected]735e20c2012-03-20 01:16:59218} // namespace
219
[email protected]14acc642012-11-17 12:20:10220// static
221void BrowserContext::AsyncObliterateStoragePartition(
222 BrowserContext* browser_context,
[email protected]399583b2012-12-11 09:33:42223 const GURL& site,
224 const base::Closure& on_gc_required) {
225 GetStoragePartitionMap(browser_context)->AsyncObliterate(site,
226 on_gc_required);
227}
228
229// static
230void BrowserContext::GarbageCollectStoragePartitions(
dcheng59716272016-04-09 05:19:08231 BrowserContext* browser_context,
232 std::unique_ptr<base::hash_set<base::FilePath>> active_paths,
233 const base::Closure& done) {
dcheng36b6aec92015-12-26 06:16:36234 GetStoragePartitionMap(browser_context)
235 ->GarbageCollect(std::move(active_paths), done);
[email protected]14acc642012-11-17 12:20:10236}
237
[email protected]b441a8492012-06-06 14:55:57238DownloadManager* BrowserContext::GetDownloadManager(
239 BrowserContext* context) {
mostynbfbcdc27a2015-03-13 17:58:52240 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]b441a8492012-06-06 14:55:57241 if (!context->GetUserData(kDownloadManagerKeyName)) {
Min Qinddb40ce2017-10-28 03:38:26242 DownloadManager* download_manager = new DownloadManagerImpl(context);
[email protected]d25fda12012-06-12 17:05:03243
avi1ed4a4372017-04-25 05:39:41244 SetDownloadManager(context, base::WrapUnique(download_manager));
[email protected]b441a8492012-06-06 14:55:57245 download_manager->SetDelegate(context->GetDownloadManagerDelegate());
[email protected]b441a8492012-06-06 14:55:57246 }
247
[email protected]eba4a4d2013-05-29 02:18:06248 return static_cast<DownloadManager*>(
249 context->GetUserData(kDownloadManagerKeyName));
[email protected]b441a8492012-06-06 14:55:57250}
251
[email protected]6ef0c3912013-01-25 22:46:34252// static
[email protected]cd501a72014-08-22 19:58:31253storage::ExternalMountPoints* BrowserContext::GetMountPoints(
[email protected]6ef0c3912013-01-25 22:46:34254 BrowserContext* context) {
255 // Ensure that these methods are called on the UI thread, except for
256 // unittests where a UI thread might not have been created.
257 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
Gabriel Charette2983181c2018-03-28 17:01:09258 !BrowserThread::IsThreadInitialized(BrowserThread::UI));
[email protected]6ef0c3912013-01-25 22:46:34259
260#if defined(OS_CHROMEOS)
261 if (!context->GetUserData(kMountPointsKey)) {
[email protected]cd501a72014-08-22 19:58:31262 scoped_refptr<storage::ExternalMountPoints> mount_points =
263 storage::ExternalMountPoints::CreateRefCounted();
[email protected]6ef0c3912013-01-25 22:46:34264 context->SetUserData(
265 kMountPointsKey,
Jeremy Roman04f27c372017-10-27 15:20:55266 std::make_unique<UserDataAdapter<storage::ExternalMountPoints>>(
avicb129c02017-05-03 06:49:29267 mount_points.get()));
[email protected]6ef0c3912013-01-25 22:46:34268 }
269
[email protected]cd501a72014-08-22 19:58:31270 return UserDataAdapter<storage::ExternalMountPoints>::Get(context,
271 kMountPointsKey);
[email protected]6ef0c3912013-01-25 22:46:34272#else
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28273 return nullptr;
[email protected]6ef0c3912013-01-25 22:46:34274#endif
275}
276
msrameke169ccb2017-04-26 05:21:41277// static
278content::BrowsingDataRemover* content::BrowserContext::GetBrowsingDataRemover(
279 BrowserContext* context) {
280 DCHECK_CURRENTLY_ON(BrowserThread::UI);
281
282 if (!context->GetUserData(kBrowsingDataRemoverKey)) {
283 std::unique_ptr<BrowsingDataRemoverImpl> remover =
Jeremy Roman04f27c372017-10-27 15:20:55284 std::make_unique<BrowsingDataRemoverImpl>(context);
msrameke169ccb2017-04-26 05:21:41285 remover->SetEmbedderDelegate(context->GetBrowsingDataRemoverDelegate());
286 context->SetUserData(kBrowsingDataRemoverKey, std::move(remover));
287 }
288
289 return static_cast<BrowsingDataRemoverImpl*>(
290 context->GetUserData(kBrowsingDataRemoverKey));
291}
292
Andrey Lushnikovebff0442018-07-12 20:02:58293// static
294content::PermissionController* content::BrowserContext::GetPermissionController(
295 BrowserContext* context) {
296 DCHECK_CURRENTLY_ON(BrowserThread::UI);
297
298 if (!context->GetUserData(kPermissionControllerKey)) {
299 context->SetUserData(kPermissionControllerKey,
300 std::make_unique<PermissionControllerImpl>(context));
301 }
302
303 return static_cast<PermissionControllerImpl*>(
304 context->GetUserData(kPermissionControllerKey));
305}
306
[email protected]4c3a23582012-08-18 08:54:34307StoragePartition* BrowserContext::GetStoragePartition(
308 BrowserContext* browser_context,
Dan Elphick6c0d8492017-09-12 09:35:38309 SiteInstance* site_instance,
310 bool can_create) {
[email protected]1bc28312012-11-08 08:31:53311 std::string partition_domain;
312 std::string partition_name;
313 bool in_memory = false;
[email protected]4c3a23582012-08-18 08:54:34314
[email protected]4c3a23582012-08-18 08:54:34315 if (site_instance) {
[email protected]1bc28312012-11-08 08:31:53316 GetContentClient()->browser()->GetStoragePartitionConfigForSite(
[email protected]14acc642012-11-17 12:20:10317 browser_context, site_instance->GetSiteURL(), true,
[email protected]1bc28312012-11-08 08:31:53318 &partition_domain, &partition_name, &in_memory);
[email protected]4c3a23582012-08-18 08:54:34319 }
320
Dan Elphick6c0d8492017-09-12 09:35:38321 return GetStoragePartitionFromConfig(browser_context, partition_domain,
322 partition_name, in_memory, can_create);
[email protected]4c3a23582012-08-18 08:54:34323}
324
[email protected]e94bbcb2012-09-07 05:33:57325StoragePartition* BrowserContext::GetStoragePartitionForSite(
326 BrowserContext* browser_context,
Dan Elphick6c0d8492017-09-12 09:35:38327 const GURL& site,
328 bool can_create) {
[email protected]1bc28312012-11-08 08:31:53329 std::string partition_domain;
330 std::string partition_name;
331 bool in_memory;
[email protected]e94bbcb2012-09-07 05:33:57332
[email protected]1bc28312012-11-08 08:31:53333 GetContentClient()->browser()->GetStoragePartitionConfigForSite(
[email protected]14acc642012-11-17 12:20:10334 browser_context, site, true, &partition_domain, &partition_name,
335 &in_memory);
[email protected]1bc28312012-11-08 08:31:53336
Dan Elphick6c0d8492017-09-12 09:35:38337 return GetStoragePartitionFromConfig(browser_context, partition_domain,
338 partition_name, in_memory, can_create);
[email protected]e94bbcb2012-09-07 05:33:57339}
340
[email protected]4c3a23582012-08-18 08:54:34341void BrowserContext::ForEachStoragePartition(
342 BrowserContext* browser_context,
343 const StoragePartitionCallback& callback) {
344 StoragePartitionImplMap* partition_map =
345 static_cast<StoragePartitionImplMap*>(
a.cavalcantiffab73762015-08-15 02:55:48346 browser_context->GetUserData(kStoragePartitionMapKeyName));
[email protected]4c3a23582012-08-18 08:54:34347 if (!partition_map)
348 return;
349
350 partition_map->ForEach(callback);
351}
352
353StoragePartition* BrowserContext::GetDefaultStoragePartition(
354 BrowserContext* browser_context) {
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28355 return GetStoragePartition(browser_context, nullptr);
[email protected]55eb70e762012-02-20 17:38:39356}
357
tbarzicdb712682015-03-06 06:05:41358// static
[email protected]393b6cb2014-05-15 00:55:12359void BrowserContext::CreateMemoryBackedBlob(BrowserContext* browser_context,
Marijn Kruisselbrink604fd7e72017-10-26 16:31:05360 const char* data,
361 size_t length,
362 const std::string& content_type,
363 BlobCallback callback) {
mostynbfbcdc27a2015-03-13 17:58:52364 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]393b6cb2014-05-15 00:55:12365
366 ChromeBlobStorageContext* blob_context =
367 ChromeBlobStorageContext::GetFor(browser_context);
368 BrowserThread::PostTaskAndReplyWithResult(
369 BrowserThread::IO, FROM_HERE,
Marijn Kruisselbrink604fd7e72017-10-26 16:31:05370 base::BindOnce(&ChromeBlobStorageContext::CreateMemoryBackedBlob,
371 base::WrapRefCounted(blob_context), data, length,
372 content_type),
373 std::move(callback));
[email protected]393b6cb2014-05-15 00:55:12374}
375
[email protected]66e53d0282014-08-07 10:04:35376// static
Xing Liu89860472018-02-09 20:07:02377BrowserContext::BlobContextGetter BrowserContext::GetBlobStorageContext(
378 BrowserContext* browser_context) {
379 DCHECK_CURRENTLY_ON(BrowserThread::UI);
380 scoped_refptr<ChromeBlobStorageContext> chrome_blob_context =
381 ChromeBlobStorageContext::GetFor(browser_context);
Jens Widell7ca8fb42018-02-21 14:11:54382 return base::BindRepeating(&BlobStorageContextGetterForBrowser,
383 chrome_blob_context);
Xing Liu89860472018-02-09 20:07:02384}
385
386// static
Marijn Kruisselbrink9e073a82018-06-18 17:48:58387blink::mojom::BlobPtr BrowserContext::GetBlobPtr(
388 BrowserContext* browser_context,
389 const std::string& uuid) {
390 DCHECK_CURRENTLY_ON(BrowserThread::UI);
391 return ChromeBlobStorageContext::GetBlobPtr(browser_context, uuid);
392}
393
394// static
[email protected]66e53d0282014-08-07 10:04:35395void BrowserContext::DeliverPushMessage(
396 BrowserContext* browser_context,
397 const GURL& origin,
avib7348942015-12-25 20:57:10398 int64_t service_worker_registration_id,
harknessdd4d2b22016-01-27 19:26:43399 const PushEventPayload& payload,
Peter Beverloo7815db1e02017-07-12 19:03:21400 const base::Callback<void(mojom::PushDeliveryStatus)>& callback) {
mostynbfbcdc27a2015-03-13 17:58:52401 DCHECK_CURRENTLY_ON(BrowserThread::UI);
harknessdd4d2b22016-01-27 19:26:43402 PushMessagingRouter::DeliverMessage(browser_context, origin,
403 service_worker_registration_id, payload,
404 callback);
[email protected]66e53d0282014-08-07 10:04:35405}
406
falken41f4175162014-10-29 07:03:41407// static
408void BrowserContext::NotifyWillBeDestroyed(BrowserContext* browser_context) {
Lukasz Anforowicz58d0dac2018-03-23 15:48:10409 // Make sure NotifyWillBeDestroyed is idempotent. This helps facilitate the
410 // pattern where NotifyWillBeDestroyed is called from *both*
411 // ShellBrowserContext and its derived classes (e.g.
412 // LayoutTestBrowserContext).
413 if (browser_context->was_notify_will_be_destroyed_called_)
414 return;
415 browser_context->was_notify_will_be_destroyed_called_ = true;
416
Ken Rockot99c5bc742018-07-12 15:36:56417 // Subclasses of BrowserContext may expect there to be no more
418 // RenderProcessHosts using them by the time this function returns. We
419 // therefore explicitly tear down embedded Content Service instances now to
420 // ensure that all their WebContents (and therefore RPHs) are torn down too.
421 browser_context->RemoveUserData(kContentServiceDelegateKey);
422
falken41f4175162014-10-29 07:03:41423 // Service Workers must shutdown before the browser context is destroyed,
424 // since they keep render process hosts alive and the codebase assumes that
425 // render process hosts die before their profile (browser context) dies.
426 ForEachStoragePartition(browser_context,
427 base::Bind(ShutdownServiceWorkerContext));
falken04a6912a2016-09-23 21:06:29428
429 // Shared workers also keep render process hosts alive, and are expected to
Darin Fisherd3768b2f62017-10-07 01:00:16430 // return ref counts to 0 after documents close. However, to ensure that
431 // hosts are destructed now, forcibly release their ref counts here.
falken04a6912a2016-09-23 21:06:29432 for (RenderProcessHost::iterator host_iterator =
433 RenderProcessHost::AllHostsIterator();
434 !host_iterator.IsAtEnd(); host_iterator.Advance()) {
435 RenderProcessHost* host = host_iterator.GetCurrentValue();
Benoit Lizeab08362c2017-07-19 14:50:54436 if (host->GetBrowserContext() == browser_context) {
437 // This will also clean up spare RPH references.
Yutaka Hirano09a9afb92017-08-16 09:11:45438 host->DisableKeepAliveRefCount();
Benoit Lizeab08362c2017-07-19 14:50:54439 }
falken04a6912a2016-09-23 21:06:29440 }
falken41f4175162014-10-29 07:03:41441}
442
[email protected]314c3e22012-02-21 03:57:42443void BrowserContext::EnsureResourceContextInitialized(BrowserContext* context) {
[email protected]7e26ac92012-02-27 20:15:05444 // This will be enough to tickle initialization of BrowserContext if
445 // necessary, which initializes ResourceContext. The reason we don't call
[email protected]4c3a23582012-08-18 08:54:34446 // ResourceContext::InitializeResourceContext() directly here is that
447 // ResourceContext initialization may call back into BrowserContext
448 // and when that call returns it'll end rewriting its UserData map. It will
449 // end up rewriting the same value but this still causes a race condition.
450 //
451 // See http://crbug.com/115678.
452 GetDefaultStoragePartition(context);
[email protected]55eb70e762012-02-20 17:38:39453}
454
[email protected]6e2d3d22012-02-24 18:10:36455void BrowserContext::SaveSessionState(BrowserContext* browser_context) {
[email protected]b1b502e2012-09-16 07:31:43456 StoragePartition* storage_partition =
457 BrowserContext::GetDefaultStoragePartition(browser_context);
[email protected]6e2d3d22012-02-24 18:10:36458
Joshua Bell607cb142017-07-24 19:17:16459 storage::DatabaseTracker* database_tracker =
460 storage_partition->GetDatabaseTracker();
461 database_tracker->task_runner()->PostTask(
462 FROM_HERE,
463 base::BindOnce(&storage::DatabaseTracker::SetForceKeepSessionState,
kylecharda69d882017-10-04 05:49:52464 base::WrapRefCounted(database_tracker)));
Joshua Bell607cb142017-07-24 19:17:16465
Gabriel Charette2983181c2018-03-28 17:01:09466 if (BrowserThread::IsThreadInitialized(BrowserThread::IO)) {
[email protected]6e2d3d22012-02-24 18:10:36467 BrowserThread::PostTask(
468 BrowserThread::IO, FROM_HERE,
tzik4fea24af2017-08-23 11:41:47469 base::BindOnce(
[email protected]6939075a2012-08-28 08:35:53470 &SaveSessionStateOnIOThread,
Clark DuVall385b5a52018-06-14 21:33:32471 base::WrapRefCounted(storage_partition->GetURLRequestContext()),
[email protected]98d6d4562014-06-25 20:57:55472 static_cast<AppCacheServiceImpl*>(
[email protected]63ef85512014-06-05 14:21:26473 storage_partition->GetAppCacheService())));
[email protected]6e2d3d22012-02-24 18:10:36474 }
475
Clark DuVall385b5a52018-06-14 21:33:32476 storage_partition->GetCookieManagerForBrowserProcess()
477 ->SetForceKeepSessionState();
478
[email protected]5f2aa722013-08-07 16:59:41479 DOMStorageContextWrapper* dom_storage_context_proxy =
480 static_cast<DOMStorageContextWrapper*>(
[email protected]b1b502e2012-09-16 07:31:43481 storage_partition->GetDOMStorageContext());
[email protected]5f2aa722013-08-07 16:59:41482 dom_storage_context_proxy->SetForceKeepSessionState();
[email protected]735e20c2012-03-20 01:16:59483
[email protected]89acda82013-06-25 20:52:50484 IndexedDBContextImpl* indexed_db_context_impl =
485 static_cast<IndexedDBContextImpl*>(
[email protected]b1b502e2012-09-16 07:31:43486 storage_partition->GetIndexedDBContext());
[email protected]89acda82013-06-25 20:52:50487 // No task runner in unit tests.
488 if (indexed_db_context_impl->TaskRunner()) {
489 indexed_db_context_impl->TaskRunner()->PostTask(
kylecharda69d882017-10-04 05:49:52490 FROM_HERE,
491 base::BindOnce(&SaveSessionStateOnIndexedDBThread,
492 base::WrapRefCounted(indexed_db_context_impl)));
[email protected]6e2d3d22012-02-24 18:10:36493 }
494}
495
ttr31481dc54b2015-08-06 20:11:26496void BrowserContext::SetDownloadManagerForTesting(
497 BrowserContext* browser_context,
avi1ed4a4372017-04-25 05:39:41498 std::unique_ptr<content::DownloadManager> download_manager) {
499 SetDownloadManager(browser_context, std::move(download_manager));
ttr31481dc54b2015-08-06 20:11:26500}
501
rockot963ad3e82016-04-13 16:33:23502// static
erge69130f52016-03-02 00:13:28503void BrowserContext::Initialize(
504 BrowserContext* browser_context,
505 const base::FilePath& path) {
ben6c85c4492016-06-16 20:40:51506 std::string new_id;
507 if (GetContentClient() && GetContentClient()->browser()) {
bend32292b2016-10-07 00:21:58508 new_id = GetContentClient()->browser()->GetServiceUserIdForBrowserContext(
ben6c85c4492016-06-16 20:40:51509 browser_context);
510 } else {
511 // Some test scenarios initialize a BrowserContext without a content client.
bencccfe2a2016-03-05 16:54:14512 new_id = base::GenerateGUID();
ben6c85c4492016-06-16 20:40:51513 }
erge69130f52016-03-02 00:13:28514
bend32292b2016-10-07 00:21:58515 ServiceUserIdHolder* holder = static_cast<ServiceUserIdHolder*>(
516 browser_context->GetUserData(kServiceUserId));
ben6c85c4492016-06-16 20:40:51517 if (holder)
bend32292b2016-10-07 00:21:58518 file::ForgetServiceUserIdUserDirAssociation(holder->user_id());
519 file::AssociateServiceUserIdWithUserDir(new_id, path);
ben6c85c4492016-06-16 20:40:51520 RemoveBrowserContextFromUserIdMap(browser_context);
521 g_user_id_to_context.Get()[new_id] = browser_context;
bend32292b2016-10-07 00:21:58522 browser_context->SetUserData(kServiceUserId,
Jeremy Roman04f27c372017-10-27 15:20:55523 std::make_unique<ServiceUserIdHolder>(new_id));
erge69130f52016-03-02 00:13:28524
avi1ed4a4372017-04-25 05:39:41525 browser_context->SetUserData(
Jeremy Roman04f27c372017-10-27 15:20:55526 kMojoWasInitialized, std::make_unique<base::SupportsUserData::Data>());
rockot963ad3e82016-04-13 16:33:23527
bend32292b2016-10-07 00:21:58528 ServiceManagerConnection* service_manager_connection =
529 ServiceManagerConnection::GetForProcess();
fdoray4f155f02016-10-12 11:28:50530 if (service_manager_connection && base::ThreadTaskRunnerHandle::IsSet()) {
rockot963ad3e82016-04-13 16:33:23531 // NOTE: Many unit tests create a TestBrowserContext without initializing
bend32292b2016-10-07 00:21:58532 // Mojo or the global service manager connection.
rockot963ad3e82016-04-13 16:33:23533
rockot400ea35b2016-10-15 19:15:32534 service_manager::mojom::ServicePtr service;
Ken Rockotf4d8a942017-05-13 00:10:37535 auto service_request = mojo::MakeRequest(&service);
rockot963ad3e82016-04-13 16:33:23536
rockot400ea35b2016-10-15 19:15:32537 service_manager::mojom::PIDReceiverPtr pid_receiver;
bene6a9f012017-01-07 00:43:43538 service_manager::Identity identity(mojom::kBrowserServiceName, new_id);
benbd3c2482017-01-07 05:48:21539 service_manager_connection->GetConnector()->StartService(
bene6a9f012017-01-07 00:43:43540 identity, std::move(service), mojo::MakeRequest(&pid_receiver));
rockot963ad3e82016-04-13 16:33:23541 pid_receiver->SetPID(base::GetCurrentProcId());
542
benaad37ecd2017-04-12 22:08:20543 service_manager_connection->GetConnector()->StartService(identity);
bend32292b2016-10-07 00:21:58544 BrowserContextServiceManagerConnectionHolder* connection_holder =
545 new BrowserContextServiceManagerConnectionHolder(
bend32292b2016-10-07 00:21:58546 std::move(service_request));
avi1ed4a4372017-04-25 05:39:41547 browser_context->SetUserData(kServiceManagerConnection,
548 base::WrapUnique(connection_holder));
rockot963ad3e82016-04-13 16:33:23549
bend32292b2016-10-07 00:21:58550 ServiceManagerConnection* connection =
551 connection_holder->service_manager_connection();
rockot963ad3e82016-04-13 16:33:23552
ben146248de2016-06-14 15:24:59553 // New embedded service factories should be added to |connection| here.
rockot963ad3e82016-04-13 16:33:23554
Ken Rockot84f58fd2018-06-22 21:54:14555 {
556 service_manager::EmbeddedServiceInfo info;
557 info.factory = base::BindRepeating(&file::CreateFileService);
558 connection->AddEmbeddedService(file::mojom::kServiceName, info);
559 }
560
561 browser_context->SetUserData(
562 kContentServiceDelegateKey,
563 std::make_unique<ContentServiceDelegateHolder>(browser_context));
564
565 {
566 service_manager::EmbeddedServiceInfo info;
567 info.task_runner = base::SequencedTaskRunnerHandle::Get();
568 info.factory = base::BindRepeating(
569 [](BrowserContext* context)
570 -> std::unique_ptr<service_manager::Service> {
571 auto* holder = static_cast<ContentServiceDelegateHolder*>(
572 context->GetUserData(kContentServiceDelegateKey));
573 auto* delegate = holder->delegate();
574 auto service = std::make_unique<content::Service>(delegate);
575 delegate->AddService(service.get());
576 return service;
577 },
578 browser_context);
579 connection->AddEmbeddedService(content::mojom::kServiceName, info);
580 }
tibellab3d36b2017-03-10 02:57:25581
582 ContentBrowserClient::StaticServiceMap services;
583 browser_context->RegisterInProcessServices(&services);
584 for (const auto& entry : services) {
585 connection->AddEmbeddedService(entry.first, entry.second);
586 }
Ken Rockotc7a279c2017-05-04 23:51:45587
588 RegisterCommonBrowserInterfaces(connection);
sammc030f5012017-03-13 02:28:45589 connection->Start();
rockot963ad3e82016-04-13 16:33:23590 }
Elad Alon03ad23b2018-02-07 16:54:31591
Elad Alon03ad23b2018-02-07 16:54:31592 if (!browser_context->IsOffTheRecord()) {
Elad Alon12ecdf02018-03-14 12:07:31593 WebRtcEventLogger* const logger = WebRtcEventLogger::Get();
594 if (logger) {
Elad Alon01e024f2018-06-28 17:29:38595 logger->EnableForBrowserContext(browser_context, base::OnceClosure());
Elad Alon03ad23b2018-02-07 16:54:31596 }
597 }
erge69130f52016-03-02 00:13:28598}
599
rockot963ad3e82016-04-13 16:33:23600// static
bend32292b2016-10-07 00:21:58601const std::string& BrowserContext::GetServiceUserIdFor(
bencccfe2a2016-03-05 16:54:14602 BrowserContext* browser_context) {
erge69130f52016-03-02 00:13:28603 CHECK(browser_context->GetUserData(kMojoWasInitialized))
604 << "Attempting to get the mojo user id for a BrowserContext that was "
605 << "never Initialize()ed.";
606
bend32292b2016-10-07 00:21:58607 ServiceUserIdHolder* holder = static_cast<ServiceUserIdHolder*>(
608 browser_context->GetUserData(kServiceUserId));
ben6c85c4492016-06-16 20:40:51609 return holder->user_id();
erge69130f52016-03-02 00:13:28610}
611
rockot963ad3e82016-04-13 16:33:23612// static
bend32292b2016-10-07 00:21:58613BrowserContext* BrowserContext::GetBrowserContextForServiceUserId(
ben6c85c4492016-06-16 20:40:51614 const std::string& user_id) {
615 auto it = g_user_id_to_context.Get().find(user_id);
616 return it != g_user_id_to_context.Get().end() ? it->second : nullptr;
617}
618
619// static
rockot400ea35b2016-10-15 19:15:32620service_manager::Connector* BrowserContext::GetConnectorFor(
rockot963ad3e82016-04-13 16:33:23621 BrowserContext* browser_context) {
bend32292b2016-10-07 00:21:58622 ServiceManagerConnection* connection =
623 GetServiceManagerConnectionFor(browser_context);
ben5be0b9132016-08-03 00:17:18624 return connection ? connection->GetConnector() : nullptr;
625}
626
627// static
bend32292b2016-10-07 00:21:58628ServiceManagerConnection* BrowserContext::GetServiceManagerConnectionFor(
ben5be0b9132016-08-03 00:17:18629 BrowserContext* browser_context) {
bend32292b2016-10-07 00:21:58630 BrowserContextServiceManagerConnectionHolder* connection_holder =
631 static_cast<BrowserContextServiceManagerConnectionHolder*>(
632 browser_context->GetUserData(kServiceManagerConnection));
633 return connection_holder ? connection_holder->service_manager_connection()
634 : nullptr;
rockot963ad3e82016-04-13 16:33:23635}
636
mmenkec0b2b8b12017-04-21 16:27:52637BrowserContext::BrowserContext()
Andrey Lushnikovd39d9062018-04-24 17:33:35638 : unique_id_(base::UnguessableToken::Create().ToString()) {}
mmenkec0b2b8b12017-04-21 16:27:52639
[email protected]55eb70e762012-02-20 17:38:39640BrowserContext::~BrowserContext() {
erge69130f52016-03-02 00:13:28641 CHECK(GetUserData(kMojoWasInitialized))
642 << "Attempting to destroy a BrowserContext that never called "
643 << "Initialize()";
644
kinukof6ed359c2016-07-26 13:27:21645 DCHECK(!GetUserData(kStoragePartitionMapKeyName))
646 << "StoragePartitionMap is not shut down properly";
647
Lukasz Anforowicz58d0dac2018-03-23 15:48:10648 DCHECK(was_notify_will_be_destroyed_called_);
649
Elad Alon12ecdf02018-03-14 12:07:31650 WebRtcEventLogger* const logger = WebRtcEventLogger::Get();
651 if (logger) {
Elad Alon01e024f2018-06-28 17:29:38652 logger->DisableForBrowserContext(this, base::OnceClosure());
Elad Alon03ad23b2018-02-07 16:54:31653 }
Elad Alon03ad23b2018-02-07 16:54:31654
ben6c85c4492016-06-16 20:40:51655 RemoveBrowserContextFromUserIdMap(this);
656
[email protected]b441a8492012-06-06 14:55:57657 if (GetUserData(kDownloadManagerKeyName))
658 GetDownloadManager(this)->Shutdown();
[email protected]55eb70e762012-02-20 17:38:39659}
660
kinukof6ed359c2016-07-26 13:27:21661void BrowserContext::ShutdownStoragePartitions() {
662 if (GetUserData(kStoragePartitionMapKeyName))
663 RemoveUserData(kStoragePartitionMapKeyName);
664}
665
mmenkec0b2b8b12017-04-21 16:27:52666std::string BrowserContext::GetMediaDeviceIDSalt() {
Andrey Lushnikovd39d9062018-04-24 17:33:35667 return unique_id_;
mmenkec0b2b8b12017-04-21 16:27:52668}
669
670// static
671std::string BrowserContext::CreateRandomMediaDeviceIDSalt() {
Andrey Lushnikovd39d9062018-04-24 17:33:35672 return base::UnguessableToken::Create().ToString();
673}
674
675const std::string& BrowserContext::UniqueId() const {
676 return unique_id_;
mmenkec0b2b8b12017-04-21 16:27:52677}
678
Chris Cunninghama5b38012017-10-28 07:27:18679media::VideoDecodePerfHistory* BrowserContext::GetVideoDecodePerfHistory() {
680 media::VideoDecodePerfHistory* decode_history =
681 static_cast<media::VideoDecodePerfHistory*>(
682 GetUserData(kVideoDecodePerfHistoryId));
683
684 // Lazily created. Note, this does not trigger loading the DB from disk. That
685 // occurs later upon first VideoDecodePerfHistory API request that requires DB
686 // access. DB operations will not block the UI thread.
687 if (!decode_history) {
688 auto db_factory = std::make_unique<media::VideoDecodeStatsDBImplFactory>(
689 GetPath().Append(FILE_PATH_LITERAL("VideoDecodeStats")));
690 decode_history = new media::VideoDecodePerfHistory(std::move(db_factory));
691 SetUserData(kVideoDecodePerfHistoryId, base::WrapUnique(decode_history));
692 }
693
694 return decode_history;
695}
696
Min Qind3ff2ed62018-07-21 06:46:59697download::InProgressDownloadManager*
698BrowserContext::RetriveInProgressDownloadManager() {
699 return nullptr;
700}
701
[email protected]55eb70e762012-02-20 17:38:39702} // namespace content