1 // 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/browser/storage_partition_impl.h"
6
7 #include <stdint.h>
8
9 #include <functional>
10 #include <memory>
11 #include <set>
12 #include <utility>
13 #include <vector>
14
15 #include "base/barrier_closure.h"
16 #include "base/bind.h"
17 #include "base/callback_helpers.h"
18 #include "base/command_line.h"
19 #include "base/containers/flat_set.h"
20 #include "base/feature_list.h"
21 #include "base/location.h"
22 #include "base/memory/ptr_util.h"
23 #include "base/memory/weak_ptr.h"
24 #include "base/metrics/histogram_functions.h"
25 #include "base/optional.h"
26 #include "base/run_loop.h"
27 #include "base/sequenced_task_runner.h"
28 #include "base/single_thread_task_runner.h"
29 #include "base/strings/utf_string_conversions.h"
30 #include "base/syslog_logging.h"
31 #include "base/task/thread_pool.h"
32 #include "base/threading/sequence_local_storage_slot.h"
33 #include "base/time/default_clock.h"
34 #include "build/build_config.h"
35 #include "components/leveldb_proto/public/proto_database_provider.h"
36 #include "components/services/storage/public/cpp/filesystem/filesystem_impl.h"
37 #include "components/services/storage/public/mojom/filesystem/directory.mojom.h"
38 #include "components/services/storage/public/mojom/indexed_db_control.mojom.h"
39 #include "components/services/storage/public/mojom/storage_service.mojom.h"
40 #include "components/services/storage/storage_service_impl.h"
41 #include "components/variations/net/variations_http_headers.h"
42 #include "content/browser/background_fetch/background_fetch_context.h"
43 #include "content/browser/blob_storage/blob_registry_wrapper.h"
44 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
45 #include "content/browser/browser_main_loop.h"
46 #include "content/browser/browsing_data/clear_site_data_handler.h"
47 #include "content/browser/browsing_data/storage_partition_code_cache_data_remover.h"
48 #include "content/browser/code_cache/generated_code_cache.h"
49 #include "content/browser/code_cache/generated_code_cache_context.h"
50 #include "content/browser/conversions/conversion_manager_impl.h"
51 #include "content/browser/cookie_store/cookie_store_context.h"
52 #include "content/browser/devtools/devtools_instrumentation.h"
53 #include "content/browser/devtools/devtools_url_loader_interceptor.h"
54 #include "content/browser/file_system/browser_file_system_helper.h"
55 #include "content/browser/file_system_access/native_file_system_manager_impl.h"
56 #include "content/browser/gpu/shader_cache_factory.h"
57 #include "content/browser/loader/prefetch_url_loader_service.h"
58 #include "content/browser/native_io/native_io_context.h"
59 #include "content/browser/network_context_client_base_impl.h"
60 #include "content/browser/notifications/platform_notification_context_impl.h"
61 #include "content/browser/quota/quota_context.h"
62 #include "content/browser/renderer_host/frame_tree_node.h"
63 #include "content/browser/service_sandbox_type.h"
64 #include "content/browser/service_worker/service_worker_container_host.h"
65 #include "content/browser/service_worker/service_worker_context_wrapper.h"
66 #include "content/browser/ssl/ssl_client_auth_handler.h"
67 #include "content/browser/ssl/ssl_error_handler.h"
68 #include "content/browser/ssl_private_key_impl.h"
69 #include "content/browser/web_contents/web_contents_impl.h"
70 #include "content/common/navigation_params.mojom.h"
71 #include "content/common/service_worker/service_worker_utils.h"
72 #include "content/public/browser/browser_context.h"
73 #include "content/public/browser/browser_task_traits.h"
74 #include "content/public/browser/browser_thread.h"
75 #include "content/public/browser/content_browser_client.h"
76 #include "content/public/browser/dom_storage_context.h"
77 #include "content/public/browser/login_delegate.h"
78 #include "content/public/browser/native_file_system_entry_factory.h"
79 #include "content/public/browser/network_service_instance.h"
80 #include "content/public/browser/permission_controller.h"
81 #include "content/public/browser/service_process_host.h"
82 #include "content/public/browser/session_storage_usage_info.h"
83 #include "content/public/browser/storage_notification_service.h"
84 #include "content/public/browser/storage_usage_info.h"
85 #include "content/public/common/content_client.h"
86 #include "content/public/common/content_constants.h"
87 #include "content/public/common/content_features.h"
88 #include "content/public/common/content_switches.h"
89 #include "mojo/public/cpp/bindings/callback_helpers.h"
90 #include "mojo/public/cpp/bindings/pending_receiver.h"
91 #include "mojo/public/cpp/bindings/remote.h"
92 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
93 #include "net/base/net_errors.h"
94 #include "net/cookies/canonical_cookie.h"
95 #include "net/cookies/cookie_util.h"
96 #include "net/http/http_auth_preferences.h"
97 #include "net/ssl/client_cert_store.h"
98 #include "ppapi/buildflags/buildflags.h"
99 #include "services/cert_verifier/public/mojom/cert_verifier_service_factory.mojom.h"
100 #include "services/metrics/public/cpp/ukm_builders.h"
101 #include "services/network/public/cpp/cross_thread_pending_shared_url_loader_factory.h"
102 #include "services/network/public/cpp/features.h"
103 #include "services/network/public/mojom/cookie_access_observer.mojom.h"
104 #include "services/network/public/mojom/cookie_manager.mojom.h"
105 #include "services/network/public/mojom/network_context.mojom.h"
106 #include "services/network/public/mojom/trust_tokens.mojom.h"
107 #include "storage/browser/blob/blob_registry_impl.h"
108 #include "storage/browser/blob/blob_storage_context.h"
109 #include "storage/browser/database/database_tracker.h"
110 #include "storage/browser/quota/quota_client_type.h"
111 #include "storage/browser/quota/quota_manager.h"
112 #include "storage/browser/quota/quota_settings.h"
113 #include "third_party/blink/public/common/features.h"
114 #include "third_party/blink/public/mojom/devtools/inspector_issue.mojom-shared.h"
115 #include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
116
117 #if defined(OS_ANDROID)
118 #include "net/android/http_auth_negotiate_android.h"
119 #else
120 #include "content/browser/host_zoom_map_impl.h"
121 #endif // defined(OS_ANDROID)
122
123 #if BUILDFLAG(ENABLE_PLUGINS)
124 #include "content/browser/plugin_private_storage_helper.h"
125 #endif // BUILDFLAG(ENABLE_PLUGINS)
126
127 using CookieDeletionFilter = network::mojom::CookieDeletionFilter;
128 using CookieDeletionFilterPtr = network::mojom::CookieDeletionFilterPtr;
129
130 namespace content {
131
132 namespace {
133
134 const storage::QuotaSettings* g_test_quota_settings;
135
136 // Timeout after which the
137 // History.ClearBrowsingData.Duration.SlowTasks180sStoragePartition histogram is
138 // recorded.
139 const base::TimeDelta kSlowTaskTimeout = base::TimeDelta::FromSeconds(180);
140
141 // If true, Storage Service instances will always be started in-process.
142 bool g_force_in_process_storage_service = false;
143
GetStorageServiceRemoteStorage()144 mojo::Remote<storage::mojom::StorageService>& GetStorageServiceRemoteStorage() {
145 // NOTE: This use of sequence-local storage is only to ensure that the Remote
146 // only lives as long as the UI-thread sequence, since the UI-thread sequence
147 // may be torn down and reinitialized e.g. between unit tests.
148 static base::NoDestructor<base::SequenceLocalStorageSlot<
149 mojo::Remote<storage::mojom::StorageService>>>
150 remote_slot;
151 return remote_slot->GetOrCreateValue();
152 }
153
RunInProcessStorageService(mojo::PendingReceiver<storage::mojom::StorageService> receiver)154 void RunInProcessStorageService(
155 mojo::PendingReceiver<storage::mojom::StorageService> receiver) {
156 DCHECK_CURRENTLY_ON(BrowserThread::IO);
157 static base::NoDestructor<base::SequenceLocalStorageSlot<
158 std::unique_ptr<storage::StorageServiceImpl>>>
159 service_storage_slot;
160 service_storage_slot->GetOrCreateValue() =
161 std::make_unique<storage::StorageServiceImpl>(std::move(receiver),
162 /*io_task_runner=*/nullptr);
163 }
164
165 #if !defined(OS_ANDROID)
BindStorageServiceFilesystemImpl(const base::FilePath & directory_path,mojo::PendingReceiver<storage::mojom::Directory> receiver)166 void BindStorageServiceFilesystemImpl(
167 const base::FilePath& directory_path,
168 mojo::PendingReceiver<storage::mojom::Directory> receiver) {
169 mojo::MakeSelfOwnedReceiver(
170 std::make_unique<storage::FilesystemImpl>(directory_path),
171 std::move(receiver));
172 }
173 #endif
174
GetStorageServiceRemote()175 mojo::Remote<storage::mojom::StorageService>& GetStorageServiceRemote() {
176 mojo::Remote<storage::mojom::StorageService>& remote =
177 GetStorageServiceRemoteStorage();
178 if (!remote) {
179 #if !defined(OS_ANDROID)
180 const base::FilePath sandboxed_data_dir =
181 GetContentClient()
182 ->browser()
183 ->GetSandboxedStorageServiceDataDirectory();
184 const bool single_process_mode =
185 base::CommandLine::ForCurrentProcess()->HasSwitch(
186 switches::kSingleProcess);
187 const bool oop_storage_enabled =
188 base::FeatureList::IsEnabled(features::kStorageServiceOutOfProcess) &&
189 !sandboxed_data_dir.empty() && !single_process_mode &&
190 !g_force_in_process_storage_service;
191 if (oop_storage_enabled) {
192 DCHECK(sandboxed_data_dir.IsAbsolute())
193 << "Storage Service data directory must be an absolute path, but \""
194 << sandboxed_data_dir << "\" is not an absolute path.";
195 remote = ServiceProcessHost::Launch<storage::mojom::StorageService>(
196 ServiceProcessHost::Options()
197 .WithDisplayName("Storage Service")
198 .Pass());
199 remote.reset_on_disconnect();
200
201 // Provide the service with an API it can use to access filesystem
202 // contents *only* within the embedder's specified data directory.
203 mojo::PendingRemote<storage::mojom::Directory> directory;
204 base::ThreadPool::CreateSequencedTaskRunner(
205 {base::MayBlock(), base::TaskPriority::USER_VISIBLE})
206 ->PostTask(FROM_HERE,
207 base::BindOnce(
208 &BindStorageServiceFilesystemImpl, sandboxed_data_dir,
209 directory.InitWithNewPipeAndPassReceiver()));
210 remote->SetDataDirectory(sandboxed_data_dir, std::move(directory));
211 } else
212 #endif // !defined(OS_ANDROID)
213 {
214 GetIOThreadTaskRunner({})->PostTask(
215 FROM_HERE, base::BindOnce(&RunInProcessStorageService,
216 remote.BindNewPipeAndPassReceiver()));
217 }
218
219 if (base::CommandLine::ForCurrentProcess()->HasSwitch(
220 switches::kEnableAggressiveDOMStorageFlushing)) {
221 remote->EnableAggressiveDomStorageFlushing();
222 }
223 }
224 return remote;
225 }
226
227 // A callback to create a URLLoaderFactory that is used in tests.
228 StoragePartitionImpl::CreateNetworkFactoryCallback&
GetCreateURLLoaderFactoryCallback()229 GetCreateURLLoaderFactoryCallback() {
230 static base::NoDestructor<StoragePartitionImpl::CreateNetworkFactoryCallback>
231 create_factory_callback;
232 return *create_factory_callback;
233 }
234
OnClearedCookies(base::OnceClosure callback,uint32_t num_deleted)235 void OnClearedCookies(base::OnceClosure callback, uint32_t num_deleted) {
236 // The final callback needs to happen from UI thread.
237 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
238 GetUIThreadTaskRunner({})->PostTask(
239 FROM_HERE,
240 base::BindOnce(&OnClearedCookies, std::move(callback), num_deleted));
241 return;
242 }
243
244 std::move(callback).Run();
245 }
246
CheckQuotaManagedDataDeletionStatus(size_t * deletion_task_count,base::OnceClosure callback)247 void CheckQuotaManagedDataDeletionStatus(size_t* deletion_task_count,
248 base::OnceClosure callback) {
249 DCHECK_CURRENTLY_ON(BrowserThread::IO);
250 if (*deletion_task_count == 0) {
251 delete deletion_task_count;
252 std::move(callback).Run();
253 }
254 }
255
OnQuotaManagedOriginDeleted(const url::Origin & origin,blink::mojom::StorageType type,size_t * deletion_task_count,base::OnceClosure callback,blink::mojom::QuotaStatusCode status)256 void OnQuotaManagedOriginDeleted(const url::Origin& origin,
257 blink::mojom::StorageType type,
258 size_t* deletion_task_count,
259 base::OnceClosure callback,
260 blink::mojom::QuotaStatusCode status) {
261 DCHECK_CURRENTLY_ON(BrowserThread::IO);
262 DCHECK_GT(*deletion_task_count, 0u);
263 if (status != blink::mojom::QuotaStatusCode::kOk) {
264 DLOG(ERROR) << "Couldn't remove data of type " << static_cast<int>(type)
265 << " for origin " << origin
266 << ". Status: " << static_cast<int>(status);
267 }
268
269 (*deletion_task_count)--;
270 CheckQuotaManagedDataDeletionStatus(deletion_task_count, std::move(callback));
271 }
272
PerformQuotaManagerStorageCleanup(const scoped_refptr<storage::QuotaManager> & quota_manager,blink::mojom::StorageType quota_storage_type,storage::QuotaClientTypes quota_client_types,base::OnceClosure callback)273 void PerformQuotaManagerStorageCleanup(
274 const scoped_refptr<storage::QuotaManager>& quota_manager,
275 blink::mojom::StorageType quota_storage_type,
276 storage::QuotaClientTypes quota_client_types,
277 base::OnceClosure callback) {
278 quota_manager->PerformStorageCleanup(
279 quota_storage_type, std::move(quota_client_types), std::move(callback));
280 }
281
ClearedShaderCache(base::OnceClosure callback)282 void ClearedShaderCache(base::OnceClosure callback) {
283 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
284 GetUIThreadTaskRunner({})->PostTask(
285 FROM_HERE, base::BindOnce(&ClearedShaderCache, std::move(callback)));
286 return;
287 }
288 std::move(callback).Run();
289 }
290
ClearShaderCacheOnIOThread(const base::FilePath & path,const base::Time begin,const base::Time end,base::OnceClosure callback)291 void ClearShaderCacheOnIOThread(const base::FilePath& path,
292 const base::Time begin,
293 const base::Time end,
294 base::OnceClosure callback) {
295 DCHECK_CURRENTLY_ON(BrowserThread::IO);
296 gpu::ShaderCacheFactory* shader_cache_factory =
297 GetShaderCacheFactorySingleton();
298
299 // May be null in tests where it is difficult to plumb through a test storage
300 // partition.
301 if (!shader_cache_factory) {
302 std::move(callback).Run();
303 return;
304 }
305
306 shader_cache_factory->ClearByPath(
307 path, begin, end,
308 base::BindOnce(&ClearedShaderCache, std::move(callback)));
309 }
310
OnLocalStorageUsageInfo(const scoped_refptr<DOMStorageContextWrapper> & dom_storage_context,const scoped_refptr<storage::SpecialStoragePolicy> & special_storage_policy,StoragePartition::OriginMatcherFunction origin_matcher,bool perform_storage_cleanup,const base::Time delete_begin,const base::Time delete_end,base::OnceClosure callback,const std::vector<StorageUsageInfo> & infos)311 void OnLocalStorageUsageInfo(
312 const scoped_refptr<DOMStorageContextWrapper>& dom_storage_context,
313 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy,
314 StoragePartition::OriginMatcherFunction origin_matcher,
315 bool perform_storage_cleanup,
316 const base::Time delete_begin,
317 const base::Time delete_end,
318 base::OnceClosure callback,
319 const std::vector<StorageUsageInfo>& infos) {
320 DCHECK_CURRENTLY_ON(BrowserThread::UI);
321
322 base::OnceClosure done_callback =
323 perform_storage_cleanup
324 ? base::BindOnce(
325 &DOMStorageContextWrapper::PerformLocalStorageCleanup,
326 dom_storage_context, std::move(callback))
327 : std::move(callback);
328
329 base::RepeatingClosure barrier =
330 base::BarrierClosure(infos.size(), std::move(done_callback));
331 for (const StorageUsageInfo& info : infos) {
332 if (origin_matcher &&
333 !origin_matcher.Run(info.origin, special_storage_policy.get())) {
334 barrier.Run();
335 continue;
336 }
337
338 if (info.last_modified >= delete_begin &&
339 info.last_modified <= delete_end) {
340 dom_storage_context->DeleteLocalStorage(info.origin, barrier);
341 } else {
342 barrier.Run();
343 }
344 }
345 }
346
OnSessionStorageUsageInfo(const scoped_refptr<DOMStorageContextWrapper> & dom_storage_context,const scoped_refptr<storage::SpecialStoragePolicy> & special_storage_policy,StoragePartition::OriginMatcherFunction origin_matcher,bool perform_storage_cleanup,base::OnceClosure callback,const std::vector<SessionStorageUsageInfo> & infos)347 void OnSessionStorageUsageInfo(
348 const scoped_refptr<DOMStorageContextWrapper>& dom_storage_context,
349 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy,
350 StoragePartition::OriginMatcherFunction origin_matcher,
351 bool perform_storage_cleanup,
352 base::OnceClosure callback,
353 const std::vector<SessionStorageUsageInfo>& infos) {
354 DCHECK_CURRENTLY_ON(BrowserThread::UI);
355
356 base::OnceClosure done_callback =
357 perform_storage_cleanup
358 ? base::BindOnce(
359 &DOMStorageContextWrapper::PerformSessionStorageCleanup,
360 dom_storage_context, std::move(callback))
361 : std::move(callback);
362
363 base::RepeatingClosure barrier =
364 base::BarrierClosure(infos.size(), std::move(done_callback));
365
366 for (const SessionStorageUsageInfo& info : infos) {
367 if (origin_matcher && !origin_matcher.Run(url::Origin::Create(info.origin),
368 special_storage_policy.get())) {
369 barrier.Run();
370 continue;
371 }
372 dom_storage_context->DeleteSessionStorage(info, barrier);
373 }
374 }
375
ClearLocalStorageOnUIThread(const scoped_refptr<DOMStorageContextWrapper> & dom_storage_context,const scoped_refptr<storage::SpecialStoragePolicy> & special_storage_policy,StoragePartition::OriginMatcherFunction origin_matcher,const GURL & storage_origin,bool perform_storage_cleanup,const base::Time begin,const base::Time end,base::OnceClosure callback)376 void ClearLocalStorageOnUIThread(
377 const scoped_refptr<DOMStorageContextWrapper>& dom_storage_context,
378 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy,
379 StoragePartition::OriginMatcherFunction origin_matcher,
380 const GURL& storage_origin,
381 bool perform_storage_cleanup,
382 const base::Time begin,
383 const base::Time end,
384 base::OnceClosure callback) {
385 DCHECK_CURRENTLY_ON(BrowserThread::UI);
386
387 if (!storage_origin.is_empty()) {
388 bool can_delete = !origin_matcher ||
389 origin_matcher.Run(url::Origin::Create(storage_origin),
390 special_storage_policy.get());
391 if (can_delete) {
392 dom_storage_context->DeleteLocalStorage(
393 url::Origin::Create(storage_origin), std::move(callback));
394 } else {
395 std::move(callback).Run();
396 }
397 return;
398 }
399
400 dom_storage_context->GetLocalStorageUsage(
401 base::BindOnce(&OnLocalStorageUsageInfo, dom_storage_context,
402 special_storage_policy, std::move(origin_matcher),
403 perform_storage_cleanup, begin, end, std::move(callback)));
404 }
405
ClearSessionStorageOnUIThread(const scoped_refptr<DOMStorageContextWrapper> & dom_storage_context,const scoped_refptr<storage::SpecialStoragePolicy> & special_storage_policy,StoragePartition::OriginMatcherFunction origin_matcher,bool perform_storage_cleanup,base::OnceClosure callback)406 void ClearSessionStorageOnUIThread(
407 const scoped_refptr<DOMStorageContextWrapper>& dom_storage_context,
408 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy,
409 StoragePartition::OriginMatcherFunction origin_matcher,
410 bool perform_storage_cleanup,
411 base::OnceClosure callback) {
412 DCHECK_CURRENTLY_ON(BrowserThread::UI);
413
414 dom_storage_context->GetSessionStorageUsage(base::BindOnce(
415 &OnSessionStorageUsageInfo, dom_storage_context, special_storage_policy,
416 std::move(origin_matcher), perform_storage_cleanup, std::move(callback)));
417 }
418
GetWebContentsForStoragePartition(uint32_t process_id,uint32_t routing_id)419 WebContents* GetWebContentsForStoragePartition(uint32_t process_id,
420 uint32_t routing_id) {
421 if (process_id != network::mojom::kBrowserProcessId) {
422 return WebContentsImpl::FromRenderFrameHostID(process_id, routing_id);
423 }
424 return WebContents::FromFrameTreeNodeId(routing_id);
425 }
426
GetBrowserContextFromStoragePartition(base::WeakPtr<StoragePartitionImpl> weak_partition_ptr)427 BrowserContext* GetBrowserContextFromStoragePartition(
428 base::WeakPtr<StoragePartitionImpl> weak_partition_ptr) {
429 return weak_partition_ptr ? weak_partition_ptr->browser_context() : nullptr;
430 }
431
GetWebContents(int process_id,int routing_id)432 WebContents* GetWebContents(int process_id, int routing_id) {
433 if (process_id != network::mojom::kBrowserProcessId) {
434 return WebContentsImpl::FromRenderFrameHostID(process_id, routing_id);
435 }
436 return WebContents::FromFrameTreeNodeId(routing_id);
437 }
438
439 // LoginHandlerDelegate manages HTTP auth. It is self-owning and deletes itself
440 // when the credentials are resolved or the AuthChallengeResponder is cancelled.
441 class LoginHandlerDelegate {
442 public:
LoginHandlerDelegate(mojo::PendingRemote<network::mojom::AuthChallengeResponder> auth_challenge_responder,WebContents::Getter web_contents_getter,const net::AuthChallengeInfo & auth_info,bool is_request_for_main_frame,uint32_t process_id,uint32_t routing_id,uint32_t request_id,const GURL & url,scoped_refptr<net::HttpResponseHeaders> response_headers,bool first_auth_attempt)443 LoginHandlerDelegate(
444 mojo::PendingRemote<network::mojom::AuthChallengeResponder>
445 auth_challenge_responder,
446 WebContents::Getter web_contents_getter,
447 const net::AuthChallengeInfo& auth_info,
448 bool is_request_for_main_frame,
449 uint32_t process_id,
450 uint32_t routing_id,
451 uint32_t request_id,
452 const GURL& url,
453 scoped_refptr<net::HttpResponseHeaders> response_headers,
454 bool first_auth_attempt)
455 : auth_challenge_responder_(std::move(auth_challenge_responder)),
456 auth_info_(auth_info),
457 request_id_(process_id, request_id),
458 routing_id_(routing_id),
459 is_request_for_main_frame_(is_request_for_main_frame),
460 creating_login_delegate_(false),
461 url_(url),
462 response_headers_(std::move(response_headers)),
463 first_auth_attempt_(first_auth_attempt),
464 web_contents_getter_(web_contents_getter) {
465 DCHECK_CURRENTLY_ON(BrowserThread::UI);
466 auth_challenge_responder_.set_disconnect_handler(base::BindOnce(
467 &LoginHandlerDelegate::OnRequestCancelled, base::Unretained(this)));
468
469 DevToolsURLLoaderInterceptor::HandleAuthRequest(
470 request_id_.child_id, routing_id_, request_id_.request_id, auth_info_,
471 base::BindOnce(&LoginHandlerDelegate::ContinueAfterInterceptor,
472 weak_factory_.GetWeakPtr()));
473 }
474
475 private:
OnRequestCancelled()476 void OnRequestCancelled() {
477 DCHECK_CURRENTLY_ON(BrowserThread::UI);
478 // This will destroy |login_handler_io_| on the IO thread and, if needed,
479 // inform the delegate.
480 delete this;
481 }
482
ContinueAfterInterceptor(bool use_fallback,const base::Optional<net::AuthCredentials> & auth_credentials)483 void ContinueAfterInterceptor(
484 bool use_fallback,
485 const base::Optional<net::AuthCredentials>& auth_credentials) {
486 DCHECK_CURRENTLY_ON(BrowserThread::UI);
487 DCHECK(!(use_fallback && auth_credentials.has_value()));
488 if (!use_fallback) {
489 OnAuthCredentials(auth_credentials);
490 return;
491 }
492
493 WebContents* web_contents = web_contents_getter_.Run();
494 if (!web_contents) {
495 OnAuthCredentials(base::nullopt);
496 return;
497 }
498
499 // WeakPtr is not strictly necessary here due to OnRequestCancelled.
500 creating_login_delegate_ = true;
501 login_delegate_ = GetContentClient()->browser()->CreateLoginDelegate(
502 auth_info_, web_contents, request_id_, is_request_for_main_frame_, url_,
503 response_headers_, first_auth_attempt_,
504 base::BindOnce(&LoginHandlerDelegate::OnAuthCredentials,
505 weak_factory_.GetWeakPtr()));
506 creating_login_delegate_ = false;
507 if (!login_delegate_) {
508 OnAuthCredentials(base::nullopt);
509 return;
510 }
511 }
512
OnAuthCredentials(const base::Optional<net::AuthCredentials> & auth_credentials)513 void OnAuthCredentials(
514 const base::Optional<net::AuthCredentials>& auth_credentials) {
515 DCHECK_CURRENTLY_ON(BrowserThread::UI);
516 // CreateLoginDelegate must not call the callback reentrantly. For
517 // robustness, detect this mistake.
518 CHECK(!creating_login_delegate_);
519 auth_challenge_responder_->OnAuthCredentials(auth_credentials);
520 delete this;
521 }
522
523 mojo::Remote<network::mojom::AuthChallengeResponder>
524 auth_challenge_responder_;
525 net::AuthChallengeInfo auth_info_;
526 const content::GlobalRequestID request_id_;
527 const uint32_t routing_id_;
528 bool is_request_for_main_frame_;
529 bool creating_login_delegate_;
530 GURL url_;
531 const scoped_refptr<net::HttpResponseHeaders> response_headers_;
532 bool first_auth_attempt_;
533 WebContents::Getter web_contents_getter_;
534 std::unique_ptr<LoginDelegate> login_delegate_;
535 base::WeakPtrFactory<LoginHandlerDelegate> weak_factory_{this};
536 };
537
OnAuthRequiredContinuation(uint32_t process_id,uint32_t routing_id,uint32_t request_id,const GURL & url,bool is_request_for_main_frame,bool first_auth_attempt,const net::AuthChallengeInfo & auth_info,network::mojom::URLResponseHeadPtr head,mojo::PendingRemote<network::mojom::AuthChallengeResponder> auth_challenge_responder,base::RepeatingCallback<WebContents * (void)> web_contents_getter)538 void OnAuthRequiredContinuation(
539 uint32_t process_id,
540 uint32_t routing_id,
541 uint32_t request_id,
542 const GURL& url,
543 bool is_request_for_main_frame,
544 bool first_auth_attempt,
545 const net::AuthChallengeInfo& auth_info,
546 network::mojom::URLResponseHeadPtr head,
547 mojo::PendingRemote<network::mojom::AuthChallengeResponder>
548 auth_challenge_responder,
549 base::RepeatingCallback<WebContents*(void)> web_contents_getter) {
550 if (!web_contents_getter || !web_contents_getter.Run()) {
551 mojo::Remote<network::mojom::AuthChallengeResponder>
552 auth_challenge_responder_remote(std::move(auth_challenge_responder));
553 auth_challenge_responder_remote->OnAuthCredentials(base::nullopt);
554 return;
555 }
556 new LoginHandlerDelegate(std::move(auth_challenge_responder),
557 std::move(web_contents_getter), auth_info,
558 is_request_for_main_frame, process_id, routing_id,
559 request_id, url, head ? head->headers : nullptr,
560 first_auth_attempt); // deletes self
561 }
562
IsMainFrameRequest(int process_id,int routing_id)563 bool IsMainFrameRequest(int process_id, int routing_id) {
564 if (process_id != network::mojom::kBrowserProcessId)
565 return false;
566
567 auto* frame_tree_node = FrameTreeNode::GloballyFindByID(routing_id);
568 return frame_tree_node && frame_tree_node->IsMainFrame();
569 }
570
571 // This class lives on the UI thread. It is self-owned and will delete itself
572 // after any of the SSLClientAuthHandler::Delegate methods are invoked (or when
573 // a mojo connection error occurs).
574 class SSLClientAuthDelegate : public SSLClientAuthHandler::Delegate {
575 public:
SSLClientAuthDelegate(mojo::PendingRemote<network::mojom::ClientCertificateResponder> client_cert_responder_remote,content::BrowserContext * browser_context,WebContents::Getter web_contents_getter,const scoped_refptr<net::SSLCertRequestInfo> & cert_info)576 SSLClientAuthDelegate(
577 mojo::PendingRemote<network::mojom::ClientCertificateResponder>
578 client_cert_responder_remote,
579 content::BrowserContext* browser_context,
580 WebContents::Getter web_contents_getter,
581 const scoped_refptr<net::SSLCertRequestInfo>& cert_info)
582 : client_cert_responder_(std::move(client_cert_responder_remote)),
583 ssl_client_auth_handler_(std::make_unique<SSLClientAuthHandler>(
584 GetContentClient()->browser()->CreateClientCertStore(
585 browser_context),
586 std::move(web_contents_getter),
587 std::move(cert_info.get()),
588 this)) {
589 DCHECK_CURRENTLY_ON(BrowserThread::UI);
590 DCHECK(client_cert_responder_);
591 client_cert_responder_.set_disconnect_handler(base::BindOnce(
592 &SSLClientAuthDelegate::DeleteSelf, base::Unretained(this)));
593 ssl_client_auth_handler_->SelectCertificate();
594 }
595
~SSLClientAuthDelegate()596 ~SSLClientAuthDelegate() override { DCHECK_CURRENTLY_ON(BrowserThread::UI); }
597
DeleteSelf()598 void DeleteSelf() { delete this; }
599
600 // SSLClientAuthHandler::Delegate:
CancelCertificateSelection()601 void CancelCertificateSelection() override {
602 DCHECK_CURRENTLY_ON(BrowserThread::UI);
603 client_cert_responder_->CancelRequest();
604 DeleteSelf();
605 }
606
607 // SSLClientAuthHandler::Delegate:
ContinueWithCertificate(scoped_refptr<net::X509Certificate> cert,scoped_refptr<net::SSLPrivateKey> private_key)608 void ContinueWithCertificate(
609 scoped_refptr<net::X509Certificate> cert,
610 scoped_refptr<net::SSLPrivateKey> private_key) override {
611 DCHECK_CURRENTLY_ON(BrowserThread::UI);
612 DCHECK((cert && private_key) || (!cert && !private_key));
613
614 if (cert && private_key) {
615 mojo::PendingRemote<network::mojom::SSLPrivateKey> ssl_private_key;
616
617 mojo::MakeSelfOwnedReceiver(
618 std::make_unique<SSLPrivateKeyImpl>(private_key),
619 ssl_private_key.InitWithNewPipeAndPassReceiver());
620
621 client_cert_responder_->ContinueWithCertificate(
622 cert, private_key->GetProviderName(),
623 private_key->GetAlgorithmPreferences(), std::move(ssl_private_key));
624 } else {
625 client_cert_responder_->ContinueWithoutCertificate();
626 }
627
628 DeleteSelf();
629 }
630
631 private:
632 mojo::Remote<network::mojom::ClientCertificateResponder>
633 client_cert_responder_;
634 std::unique_ptr<SSLClientAuthHandler> ssl_client_auth_handler_;
635 };
636
OnCertificateRequestedContinuation(uint32_t process_id,uint32_t routing_id,uint32_t request_id,const scoped_refptr<net::SSLCertRequestInfo> & cert_info,mojo::PendingRemote<network::mojom::ClientCertificateResponder> client_cert_responder_remote,base::RepeatingCallback<WebContents * (void)> web_contents_getter)637 void OnCertificateRequestedContinuation(
638 uint32_t process_id,
639 uint32_t routing_id,
640 uint32_t request_id,
641 const scoped_refptr<net::SSLCertRequestInfo>& cert_info,
642 mojo::PendingRemote<network::mojom::ClientCertificateResponder>
643 client_cert_responder_remote,
644 base::RepeatingCallback<WebContents*(void)> web_contents_getter) {
645 WebContents* web_contents = nullptr;
646 if (web_contents_getter)
647 web_contents = web_contents_getter.Run();
648
649 if (!web_contents) {
650 DCHECK(client_cert_responder_remote);
651 mojo::Remote<network::mojom::ClientCertificateResponder>
652 client_cert_responder(std::move(client_cert_responder_remote));
653 client_cert_responder->CancelRequest();
654 return;
655 }
656
657 new SSLClientAuthDelegate(std::move(client_cert_responder_remote),
658 web_contents->GetBrowserContext(),
659 std::move(web_contents_getter),
660 cert_info); // deletes self
661 }
662
663 class SSLErrorDelegate : public SSLErrorHandler::Delegate {
664 public:
SSLErrorDelegate(network::mojom::NetworkContextClient::OnSSLCertificateErrorCallback response)665 explicit SSLErrorDelegate(
666 network::mojom::NetworkContextClient::OnSSLCertificateErrorCallback
667 response)
668 : response_(std::move(response)) {}
669 ~SSLErrorDelegate() override = default;
CancelSSLRequest(int error,const net::SSLInfo * ssl_info)670 void CancelSSLRequest(int error, const net::SSLInfo* ssl_info) override {
671 std::move(response_).Run(error);
672 delete this;
673 }
ContinueSSLRequest()674 void ContinueSSLRequest() override {
675 std::move(response_).Run(net::OK);
676 delete this;
677 }
GetWeakPtr()678 base::WeakPtr<SSLErrorDelegate> GetWeakPtr() {
679 return weak_factory_.GetWeakPtr();
680 }
681
682 private:
683 network::mojom::NetworkContextClient::OnSSLCertificateErrorCallback response_;
684 base::WeakPtrFactory<SSLErrorDelegate> weak_factory_{this};
685 };
686
687 #if defined(OS_ANDROID)
FinishGenerateNegotiateAuthToken(std::unique_ptr<net::android::HttpAuthNegotiateAndroid> auth_negotiate,std::unique_ptr<std::string> auth_token,std::unique_ptr<net::HttpAuthPreferences> prefs,network::mojom::NetworkContextClient::OnGenerateHttpNegotiateAuthTokenCallback callback,int result)688 void FinishGenerateNegotiateAuthToken(
689 std::unique_ptr<net::android::HttpAuthNegotiateAndroid> auth_negotiate,
690 std::unique_ptr<std::string> auth_token,
691 std::unique_ptr<net::HttpAuthPreferences> prefs,
692 network::mojom::NetworkContextClient::
693 OnGenerateHttpNegotiateAuthTokenCallback callback,
694 int result) {
695 std::move(callback).Run(result, *auth_token);
696 }
697 #endif
698
699 // Conceptually, many downstream interfaces don't need to know about the
700 // complexity of callers into StoragePartition, so this function reduces the API
701 // surface to something simple and generic. It is designed to be used by
702 // callsites in ClearDataImpl.
703 //
704 // Precondition: |matcher_func| and |storage_origin| cannot both be set.
705 // If both |matcher_func| and |storage_origin| are null/empty, should return a
706 // null callback that indicates all origins should match. This is an
707 // optimization for backends to efficiently clear all data.
708 //
709 // TODO(csharrison, mek): Right now, the only storage backend that uses this is
710 // is for conversion measurement. We should consider moving some of the
711 // backends to use this if they can, and additionally we should consider
712 // rethinking this approach if / when storage backends move out of process
713 // (see crbug.com/1016065 for initial work here).
CreateGenericOriginMatcher(const GURL & storage_origin,StoragePartition::OriginMatcherFunction matcher_func,scoped_refptr<storage::SpecialStoragePolicy> policy)714 base::RepeatingCallback<bool(const url::Origin&)> CreateGenericOriginMatcher(
715 const GURL& storage_origin,
716 StoragePartition::OriginMatcherFunction matcher_func,
717 scoped_refptr<storage::SpecialStoragePolicy> policy) {
718 DCHECK(storage_origin.is_empty() || matcher_func.is_null());
719
720 if (storage_origin.is_empty() && matcher_func.is_null())
721 return base::NullCallback();
722
723 if (matcher_func) {
724 return base::BindRepeating(
725 [](StoragePartition::OriginMatcherFunction matcher_func,
726 scoped_refptr<storage::SpecialStoragePolicy> policy,
727 const url::Origin& origin) -> bool {
728 return matcher_func.Run(origin, policy.get());
729 },
730 std::move(matcher_func), std::move(policy));
731 }
732 DCHECK(!storage_origin.is_empty());
733 return base::BindRepeating(std::equal_to<const url::Origin&>(),
734 url::Origin::Create(storage_origin));
735 }
736
737 } // namespace
738
739 class StoragePartitionImpl::URLLoaderFactoryForBrowserProcess
740 : public network::SharedURLLoaderFactory {
741 public:
URLLoaderFactoryForBrowserProcess(StoragePartitionImpl * storage_partition,bool corb_enabled)742 explicit URLLoaderFactoryForBrowserProcess(
743 StoragePartitionImpl* storage_partition,
744 bool corb_enabled)
745 : storage_partition_(storage_partition), corb_enabled_(corb_enabled) {}
746
747 // mojom::URLLoaderFactory implementation:
748
CreateLoaderAndStart(mojo::PendingReceiver<network::mojom::URLLoader> receiver,int32_t routing_id,int32_t request_id,uint32_t options,const network::ResourceRequest & url_request,mojo::PendingRemote<network::mojom::URLLoaderClient> client,const net::MutableNetworkTrafficAnnotationTag & traffic_annotation)749 void CreateLoaderAndStart(
750 mojo::PendingReceiver<network::mojom::URLLoader> receiver,
751 int32_t routing_id,
752 int32_t request_id,
753 uint32_t options,
754 const network::ResourceRequest& url_request,
755 mojo::PendingRemote<network::mojom::URLLoaderClient> client,
756 const net::MutableNetworkTrafficAnnotationTag& traffic_annotation)
757 override {
758 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
759 if (!storage_partition_)
760 return;
761 storage_partition_
762 ->GetURLLoaderFactoryForBrowserProcessInternal(corb_enabled_)
763 ->CreateLoaderAndStart(std::move(receiver), routing_id, request_id,
764 options, url_request, std::move(client),
765 traffic_annotation);
766 }
767
Clone(mojo::PendingReceiver<network::mojom::URLLoaderFactory> receiver)768 void Clone(mojo::PendingReceiver<network::mojom::URLLoaderFactory> receiver)
769 override {
770 if (!storage_partition_)
771 return;
772 storage_partition_
773 ->GetURLLoaderFactoryForBrowserProcessInternal(corb_enabled_)
774 ->Clone(std::move(receiver));
775 }
776
777 // SharedURLLoaderFactory implementation:
Clone()778 std::unique_ptr<network::PendingSharedURLLoaderFactory> Clone() override {
779 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
780 return std::make_unique<network::CrossThreadPendingSharedURLLoaderFactory>(
781 this);
782 }
783
Shutdown()784 void Shutdown() { storage_partition_ = nullptr; }
785
786 private:
787 friend class base::RefCounted<URLLoaderFactoryForBrowserProcess>;
788 ~URLLoaderFactoryForBrowserProcess() override = default;
789
790 StoragePartitionImpl* storage_partition_;
791 const bool corb_enabled_;
792
793 DISALLOW_COPY_AND_ASSIGN(URLLoaderFactoryForBrowserProcess);
794 };
795
796 // Static.
GenerateQuotaClientTypes(uint32_t remove_mask)797 storage::QuotaClientTypes StoragePartitionImpl::GenerateQuotaClientTypes(
798 uint32_t remove_mask) {
799 storage::QuotaClientTypes quota_client_types;
800
801 if (remove_mask & StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS)
802 quota_client_types.insert(storage::QuotaClientType::kFileSystem);
803 if (remove_mask & StoragePartition::REMOVE_DATA_MASK_WEBSQL)
804 quota_client_types.insert(storage::QuotaClientType::kDatabase);
805 if (remove_mask & StoragePartition::REMOVE_DATA_MASK_APPCACHE)
806 quota_client_types.insert(storage::QuotaClientType::kAppcache);
807 if (remove_mask & StoragePartition::REMOVE_DATA_MASK_INDEXEDDB)
808 quota_client_types.insert(storage::QuotaClientType::kIndexedDatabase);
809 if (remove_mask & StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS)
810 quota_client_types.insert(storage::QuotaClientType::kServiceWorker);
811 if (remove_mask & StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE)
812 quota_client_types.insert(storage::QuotaClientType::kServiceWorkerCache);
813 if (remove_mask & StoragePartition::REMOVE_DATA_MASK_BACKGROUND_FETCH)
814 quota_client_types.insert(storage::QuotaClientType::kBackgroundFetch);
815
816 return quota_client_types;
817 }
818
819 // static
820 void StoragePartitionImpl::
SetGetURLLoaderFactoryForBrowserProcessCallbackForTesting(CreateNetworkFactoryCallback url_loader_factory_callback)821 SetGetURLLoaderFactoryForBrowserProcessCallbackForTesting(
822 CreateNetworkFactoryCallback url_loader_factory_callback) {
823 DCHECK(!BrowserThread::IsThreadInitialized(BrowserThread::UI) ||
824 BrowserThread::CurrentlyOn(BrowserThread::UI));
825 DCHECK(!url_loader_factory_callback || !GetCreateURLLoaderFactoryCallback())
826 << "It is not expected that this is called with non-null callback when "
827 << "another overriding callback is already set.";
828 GetCreateURLLoaderFactoryCallback() = std::move(url_loader_factory_callback);
829 }
830
831 // static
ForceInProcessStorageServiceForTesting()832 void StoragePartitionImpl::ForceInProcessStorageServiceForTesting() {
833 g_force_in_process_storage_service = true;
834 }
835
836 // Helper for deleting quota managed data from a partition.
837 //
838 // Most of the operations in this class are done on IO thread.
839 class StoragePartitionImpl::QuotaManagedDataDeletionHelper {
840 public:
QuotaManagedDataDeletionHelper(uint32_t remove_mask,uint32_t quota_storage_remove_mask,const base::Optional<url::Origin> & storage_origin,base::OnceClosure callback)841 QuotaManagedDataDeletionHelper(
842 uint32_t remove_mask,
843 uint32_t quota_storage_remove_mask,
844 const base::Optional<url::Origin>& storage_origin,
845 base::OnceClosure callback)
846 : remove_mask_(remove_mask),
847 quota_storage_remove_mask_(quota_storage_remove_mask),
848 storage_origin_(storage_origin),
849 callback_(std::move(callback)),
850 task_count_(0) {
851 DCHECK(!storage_origin_.has_value() ||
852 !storage_origin_->GetURL().is_empty());
853 }
854
855 void IncrementTaskCountOnIO();
856 void DecrementTaskCountOnIO();
857
858 void ClearDataOnIOThread(
859 const scoped_refptr<storage::QuotaManager>& quota_manager,
860 const base::Time begin,
861 const base::Time end,
862 const scoped_refptr<storage::SpecialStoragePolicy>&
863 special_storage_policy,
864 StoragePartition::OriginMatcherFunction origin_matcher,
865 bool perform_storage_cleanup);
866
867 void ClearOriginsOnIOThread(
868 storage::QuotaManager* quota_manager,
869 const scoped_refptr<storage::SpecialStoragePolicy>&
870 special_storage_policy,
871 StoragePartition::OriginMatcherFunction origin_matcher,
872 bool perform_storage_cleanup,
873 base::OnceClosure callback,
874 const std::set<url::Origin>& origins,
875 blink::mojom::StorageType quota_storage_type);
876
877 private:
878 // All of these data are accessed on IO thread.
879 uint32_t remove_mask_;
880 uint32_t quota_storage_remove_mask_;
881 base::Optional<url::Origin> storage_origin_;
882 base::OnceClosure callback_;
883 int task_count_;
884
885 DISALLOW_COPY_AND_ASSIGN(QuotaManagedDataDeletionHelper);
886 };
887
888 // Helper for deleting all sorts of data from a partition, keeps track of
889 // deletion status.
890 //
891 // StoragePartitionImpl creates an instance of this class to keep track of
892 // data deletion progress. Deletion requires deleting multiple bits of data
893 // (e.g. cookies, local storage, session storage etc.) and hopping between UI
894 // and IO thread. An instance of this class is created in the beginning of
895 // deletion process (StoragePartitionImpl::ClearDataImpl) and the instance is
896 // forwarded and updated on each (sub) deletion's callback. The instance is
897 // finally destroyed when deletion completes (and |callback| is invoked).
898 class StoragePartitionImpl::DataDeletionHelper {
899 public:
DataDeletionHelper(uint32_t remove_mask,uint32_t quota_storage_remove_mask,base::OnceClosure callback)900 DataDeletionHelper(uint32_t remove_mask,
901 uint32_t quota_storage_remove_mask,
902 base::OnceClosure callback)
903 : remove_mask_(remove_mask),
904 quota_storage_remove_mask_(quota_storage_remove_mask),
905 callback_(std::move(callback)) {}
906
907 ~DataDeletionHelper() = default;
908
909 void ClearDataOnUIThread(
910 const GURL& storage_origin,
911 OriginMatcherFunction origin_matcher,
912 CookieDeletionFilterPtr cookie_deletion_filter,
913 const base::FilePath& path,
914 DOMStorageContextWrapper* dom_storage_context,
915 storage::QuotaManager* quota_manager,
916 storage::SpecialStoragePolicy* special_storage_policy,
917 storage::FileSystemContext* filesystem_context,
918 network::mojom::CookieManager* cookie_manager,
919 ConversionManagerImpl* conversion_manager,
920 bool perform_storage_cleanup,
921 const base::Time begin,
922 const base::Time end);
923
924 void ClearQuotaManagedDataOnIOThread(
925 const scoped_refptr<storage::QuotaManager>& quota_manager,
926 const base::Time begin,
927 const base::Time end,
928 const GURL& storage_origin,
929 const scoped_refptr<storage::SpecialStoragePolicy>&
930 special_storage_policy,
931 StoragePartition::OriginMatcherFunction origin_matcher,
932 bool perform_storage_cleanup,
933 base::OnceClosure callback);
934
935 private:
936 // For debugging purposes. Please add new deletion tasks at the end.
937 // This enum is recorded in a histogram, so don't change or reuse ids.
938 // Entries must also be added to StoragePartitionRemoverTasks in enums.xml.
939 enum class TracingDataType {
940 kSynchronous = 1,
941 kCookies = 2,
942 kQuota = 3,
943 kLocalStorage = 4,
944 kSessionStorage = 5,
945 kShaderCache = 6,
946 kPluginPrivate = 7,
947 kConversions = 8,
948 kMaxValue = kConversions,
949 };
950
951 base::OnceClosure CreateTaskCompletionClosure(TracingDataType data_type);
952 void OnTaskComplete(TracingDataType data_type,
953 int tracing_id); // Callable on any thread.
954 void RecordUnfinishedSubTasks();
955
956 uint32_t remove_mask_;
957 uint32_t quota_storage_remove_mask_;
958
959 // Accessed on UI thread.
960 base::OnceClosure callback_;
961 // Accessed on UI thread.
962 std::set<TracingDataType> pending_tasks_;
963
964 base::WeakPtrFactory<StoragePartitionImpl::DataDeletionHelper> weak_factory_{
965 this};
966
967 DISALLOW_COPY_AND_ASSIGN(DataDeletionHelper);
968 };
969
ClearQuotaManagedDataOnIOThread(const scoped_refptr<storage::QuotaManager> & quota_manager,const base::Time begin,const base::Time end,const GURL & storage_origin,const scoped_refptr<storage::SpecialStoragePolicy> & special_storage_policy,StoragePartition::OriginMatcherFunction origin_matcher,bool perform_storage_cleanup,base::OnceClosure callback)970 void StoragePartitionImpl::DataDeletionHelper::ClearQuotaManagedDataOnIOThread(
971 const scoped_refptr<storage::QuotaManager>& quota_manager,
972 const base::Time begin,
973 const base::Time end,
974 const GURL& storage_origin,
975 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy,
976 StoragePartition::OriginMatcherFunction origin_matcher,
977 bool perform_storage_cleanup,
978 base::OnceClosure callback) {
979 DCHECK_CURRENTLY_ON(BrowserThread::IO);
980
981 StoragePartitionImpl::QuotaManagedDataDeletionHelper* helper =
982 new StoragePartitionImpl::QuotaManagedDataDeletionHelper(
983 remove_mask_, quota_storage_remove_mask_,
984 storage_origin.is_empty()
985 ? base::nullopt
986 : base::make_optional(url::Origin::Create(storage_origin)),
987 std::move(callback));
988 helper->ClearDataOnIOThread(quota_manager, begin, end, special_storage_policy,
989 std::move(origin_matcher),
990 perform_storage_cleanup);
991 }
992
993 class StoragePartitionImpl::ServiceWorkerCookieAccessObserver
994 : public network::mojom::CookieAccessObserver {
995 public:
ServiceWorkerCookieAccessObserver(StoragePartitionImpl * storage_partition)996 explicit ServiceWorkerCookieAccessObserver(
997 StoragePartitionImpl* storage_partition)
998 : storage_partition_(storage_partition) {}
999
1000 private:
Clone(mojo::PendingReceiver<network::mojom::CookieAccessObserver> observer)1001 void Clone(mojo::PendingReceiver<network::mojom::CookieAccessObserver>
1002 observer) override {
1003 storage_partition_->service_worker_cookie_observers_.Add(
1004 std::make_unique<ServiceWorkerCookieAccessObserver>(storage_partition_),
1005 std::move(observer));
1006 }
1007
OnCookiesAccessed(network::mojom::CookieAccessDetailsPtr details)1008 void OnCookiesAccessed(
1009 network::mojom::CookieAccessDetailsPtr details) override {
1010 scoped_refptr<ServiceWorkerContextWrapper> service_worker_context =
1011 storage_partition_->GetServiceWorkerContext();
1012 RunOrPostTaskOnThread(
1013 FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
1014 base::BindOnce(&OnServiceWorkerCookiesAccessedOnCoreThread,
1015 service_worker_context, std::move(details)));
1016 }
1017
OnServiceWorkerCookiesAccessedOnCoreThread(scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,network::mojom::CookieAccessDetailsPtr details)1018 static void OnServiceWorkerCookiesAccessedOnCoreThread(
1019 scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,
1020 network::mojom::CookieAccessDetailsPtr details) {
1021 std::vector<GlobalFrameRoutingId> destinations =
1022 *service_worker_context->GetWindowClientFrameRoutingIds(
1023 details->url.GetOrigin());
1024 if (destinations.empty())
1025 return;
1026 RunOrPostTaskOnThread(
1027 FROM_HERE, BrowserThread::UI,
1028 base::BindOnce(&ReportCookiesAccessedOnUI, std::move(destinations),
1029 std::move(details)));
1030 }
1031
ReportCookiesAccessedOnUI(std::vector<GlobalFrameRoutingId> destinations,network::mojom::CookieAccessDetailsPtr details)1032 static void ReportCookiesAccessedOnUI(
1033 std::vector<GlobalFrameRoutingId> destinations,
1034 network::mojom::CookieAccessDetailsPtr details) {
1035 for (GlobalFrameRoutingId frame_id : destinations) {
1036 if (RenderFrameHostImpl* rfh = RenderFrameHostImpl::FromID(frame_id)) {
1037 rfh->OnCookiesAccessed(mojo::Clone(details));
1038 }
1039 }
1040 }
1041
1042 // |storage_partition_| owns this object via UniqueReceiverSet
1043 // (service_worker_cookie_observers_).
1044 StoragePartitionImpl* storage_partition_;
1045 };
1046
StoragePartitionImpl(BrowserContext * browser_context,const base::FilePath & partition_path,bool is_in_memory,const base::FilePath & relative_partition_path,const std::string & partition_domain,storage::SpecialStoragePolicy * special_storage_policy)1047 StoragePartitionImpl::StoragePartitionImpl(
1048 BrowserContext* browser_context,
1049 const base::FilePath& partition_path,
1050 bool is_in_memory,
1051 const base::FilePath& relative_partition_path,
1052 const std::string& partition_domain,
1053 storage::SpecialStoragePolicy* special_storage_policy)
1054 : browser_context_(browser_context),
1055 partition_path_(partition_path),
1056 is_in_memory_(is_in_memory),
1057 relative_partition_path_(relative_partition_path),
1058 partition_domain_(partition_domain),
1059 special_storage_policy_(special_storage_policy),
1060 deletion_helpers_running_(0) {}
1061
~StoragePartitionImpl()1062 StoragePartitionImpl::~StoragePartitionImpl() {
1063 browser_context_ = nullptr;
1064
1065 if (url_loader_factory_getter_)
1066 url_loader_factory_getter_->OnStoragePartitionDestroyed();
1067
1068 if (shared_url_loader_factory_for_browser_process_) {
1069 shared_url_loader_factory_for_browser_process_->Shutdown();
1070 }
1071 if (shared_url_loader_factory_for_browser_process_with_corb_) {
1072 shared_url_loader_factory_for_browser_process_with_corb_->Shutdown();
1073 }
1074
1075 if (GetDatabaseTracker()) {
1076 GetDatabaseTracker()->task_runner()->PostTask(
1077 FROM_HERE, base::BindOnce(&storage::DatabaseTracker::Shutdown,
1078 GetDatabaseTracker()));
1079 }
1080
1081 if (GetFileSystemContext())
1082 GetFileSystemContext()->Shutdown();
1083
1084 if (GetDOMStorageContext())
1085 GetDOMStorageContext()->Shutdown();
1086
1087 if (GetServiceWorkerContext())
1088 GetServiceWorkerContext()->Shutdown();
1089
1090 if (GetIndexedDBContextInternal())
1091 GetIndexedDBContextInternal()->Shutdown();
1092
1093 if (GetCacheStorageContext())
1094 GetCacheStorageContext()->Shutdown();
1095
1096 if (GetPlatformNotificationContext())
1097 GetPlatformNotificationContext()->Shutdown();
1098
1099 if (GetBackgroundSyncContext())
1100 GetBackgroundSyncContext()->Shutdown();
1101
1102 if (GetPaymentAppContext())
1103 GetPaymentAppContext()->Shutdown();
1104
1105 if (GetBackgroundFetchContext())
1106 GetBackgroundFetchContext()->Shutdown();
1107
1108 if (GetContentIndexContext())
1109 GetContentIndexContext()->Shutdown();
1110
1111 if (GetAppCacheService())
1112 GetAppCacheService()->Shutdown();
1113
1114 if (GetGeneratedCodeCacheContext())
1115 GetGeneratedCodeCacheContext()->Shutdown();
1116 }
1117
1118 // static
Create(BrowserContext * context,bool in_memory,const base::FilePath & relative_partition_path,const std::string & partition_domain)1119 std::unique_ptr<StoragePartitionImpl> StoragePartitionImpl::Create(
1120 BrowserContext* context,
1121 bool in_memory,
1122 const base::FilePath& relative_partition_path,
1123 const std::string& partition_domain) {
1124 // Ensure that these methods are called on the UI thread, except for
1125 // unittests where a UI thread might not have been created.
1126 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
1127 !BrowserThread::IsThreadInitialized(BrowserThread::UI));
1128
1129 base::FilePath partition_path =
1130 context->GetPath().Append(relative_partition_path);
1131
1132 return base::WrapUnique(new StoragePartitionImpl(
1133 context, partition_path, in_memory, relative_partition_path,
1134 partition_domain, context->GetSpecialStoragePolicy()));
1135 }
1136
Initialize(StoragePartitionImpl * fallback_for_blob_urls)1137 void StoragePartitionImpl::Initialize(
1138 StoragePartitionImpl* fallback_for_blob_urls) {
1139 // Ensure that these methods are called on the UI thread, except for
1140 // unittests where a UI thread might not have been created.
1141 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
1142 !BrowserThread::IsThreadInitialized(BrowserThread::UI));
1143 DCHECK(!initialized_);
1144 initialized_ = true;
1145
1146 // All of the clients have to be created and registered with the
1147 // QuotaManager prior to the QuotaManager being used. We do them
1148 // all together here prior to handing out a reference to anything
1149 // that utilizes the QuotaManager.
1150 quota_context_ = base::MakeRefCounted<QuotaContext>(
1151 is_in_memory_, partition_path_,
1152 browser_context_->GetSpecialStoragePolicy(),
1153 base::BindRepeating(&StoragePartitionImpl::GetQuotaSettings,
1154 weak_factory_.GetWeakPtr()));
1155 quota_manager_ = quota_context_->quota_manager();
1156 scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy =
1157 quota_manager_->proxy();
1158
1159 StorageNotificationService* storage_notification_service =
1160 browser_context_->GetStorageNotificationService();
1161 if (storage_notification_service) {
1162 // base::Unretained is safe to use because the BrowserContext is guaranteed
1163 // to outlive QuotaManager. This is because BrowserContext outlives this
1164 // StoragePartitionImpl, which destroys the QuotaManager on teardown.
1165 base::RepeatingCallback<void(const url::Origin)>
1166 send_notification_function = base::BindRepeating(
1167 [](StorageNotificationService* service, const url::Origin origin) {
1168 GetUIThreadTaskRunner({})->PostTask(
1169 FROM_HERE,
1170 base::BindOnce(&StorageNotificationService::
1171 MaybeShowStoragePressureNotification,
1172 base::Unretained(service), std::move(origin)));
1173 },
1174 base::Unretained(storage_notification_service));
1175
1176 quota_manager_->SetStoragePressureCallback(send_notification_function);
1177 }
1178
1179 // Each consumer is responsible for registering its QuotaClient during
1180 // its construction.
1181 filesystem_context_ =
1182 CreateFileSystemContext(browser_context_, partition_path_, is_in_memory_,
1183 quota_manager_proxy.get());
1184
1185 database_tracker_ = base::MakeRefCounted<storage::DatabaseTracker>(
1186 partition_path_, is_in_memory_,
1187 browser_context_->GetSpecialStoragePolicy(), quota_manager_proxy.get());
1188
1189 dom_storage_context_ = DOMStorageContextWrapper::Create(
1190 this, browser_context_->GetSpecialStoragePolicy());
1191
1192 lock_manager_ = std::make_unique<LockManager>();
1193
1194 scoped_refptr<ChromeBlobStorageContext> blob_context =
1195 ChromeBlobStorageContext::GetFor(browser_context_);
1196
1197 native_file_system_manager_ =
1198 base::MakeRefCounted<NativeFileSystemManagerImpl>(
1199 filesystem_context_, blob_context,
1200 browser_context_->GetNativeFileSystemPermissionContext(),
1201 browser_context_->IsOffTheRecord());
1202
1203 mojo::PendingRemote<storage::mojom::NativeFileSystemContext>
1204 native_file_system_context;
1205 native_file_system_manager_->BindInternalsReceiver(
1206 native_file_system_context.InitWithNewPipeAndPassReceiver());
1207 base::FilePath path = is_in_memory_ ? base::FilePath() : partition_path_;
1208 indexed_db_control_wrapper_ = std::make_unique<IndexedDBControlWrapper>(
1209 path, browser_context_->GetSpecialStoragePolicy(), quota_manager_proxy,
1210 base::DefaultClock::GetInstance(),
1211 ChromeBlobStorageContext::GetRemoteFor(browser_context_),
1212 std::move(native_file_system_context), GetIOThreadTaskRunner({}),
1213 /*task_runner=*/nullptr);
1214
1215 cache_storage_context_ = new CacheStorageContextImpl();
1216 cache_storage_context_->Init(
1217 path, browser_context_->GetSpecialStoragePolicy(), quota_manager_proxy);
1218
1219 service_worker_context_ = new ServiceWorkerContextWrapper(browser_context_);
1220 service_worker_context_->set_storage_partition(this);
1221
1222 if (StoragePartition::IsAppCacheEnabled()) {
1223 appcache_service_ = base::MakeRefCounted<ChromeAppCacheService>(
1224 quota_manager_proxy, weak_factory_.GetWeakPtr());
1225 }
1226
1227 dedicated_worker_service_ = std::make_unique<DedicatedWorkerServiceImpl>();
1228 native_io_context_ = std::make_unique<NativeIOContext>(path);
1229
1230 shared_worker_service_ = std::make_unique<SharedWorkerServiceImpl>(
1231 this, service_worker_context_, appcache_service_);
1232
1233 push_messaging_context_ = std::make_unique<PushMessagingContext>(
1234 browser_context_, service_worker_context_);
1235
1236 #if !defined(OS_ANDROID)
1237 host_zoom_level_context_.reset(new HostZoomLevelContext(
1238 browser_context_->CreateZoomLevelDelegate(partition_path_)));
1239 #endif // !defined(OS_ANDROID)
1240
1241 platform_notification_context_ = new PlatformNotificationContextImpl(
1242 path, browser_context_, service_worker_context_);
1243 platform_notification_context_->Initialize();
1244
1245 devtools_background_services_context_ =
1246 base::MakeRefCounted<DevToolsBackgroundServicesContextImpl>(
1247 browser_context_, service_worker_context_);
1248
1249 content_index_context_ = base::MakeRefCounted<ContentIndexContextImpl>(
1250 browser_context_, service_worker_context_);
1251
1252 background_fetch_context_ = base::MakeRefCounted<BackgroundFetchContext>(
1253 browser_context_, service_worker_context_, cache_storage_context_,
1254 quota_manager_proxy, devtools_background_services_context_);
1255
1256 background_sync_context_ = base::MakeRefCounted<BackgroundSyncContextImpl>();
1257 background_sync_context_->Init(service_worker_context_,
1258 devtools_background_services_context_);
1259
1260 payment_app_context_ = new PaymentAppContextImpl();
1261 payment_app_context_->Init(service_worker_context_);
1262
1263 broadcast_channel_provider_ = std::make_unique<BroadcastChannelProvider>();
1264
1265 bluetooth_allowed_devices_map_ =
1266 std::make_unique<BluetoothAllowedDevicesMap>();
1267
1268 url_loader_factory_getter_ = new URLLoaderFactoryGetter();
1269 url_loader_factory_getter_->Initialize(this);
1270
1271 service_worker_context_->Init(path, quota_manager_proxy.get(),
1272 browser_context_->GetSpecialStoragePolicy(),
1273 blob_context.get(),
1274 url_loader_factory_getter_.get());
1275
1276 BlobRegistryWrapper* fallback_blob_registry =
1277 fallback_for_blob_urls ? fallback_for_blob_urls->GetBlobRegistry()
1278 : nullptr;
1279 blob_registry_ = BlobRegistryWrapper::Create(
1280 blob_context, filesystem_context_, fallback_blob_registry);
1281
1282 prefetch_url_loader_service_ =
1283 base::MakeRefCounted<PrefetchURLLoaderService>(browser_context_);
1284
1285 cookie_store_context_ = base::MakeRefCounted<CookieStoreContext>();
1286 // Unit tests use the Initialize() callback to crash early if restoring the
1287 // CookieManagerStore's state from ServiceWorkerStorage fails. Production and
1288 // browser tests rely on CookieStoreManager's well-defined behavior when
1289 // restoring the state fails.
1290 cookie_store_context_->Initialize(service_worker_context_, base::DoNothing());
1291
1292 // The Conversion Measurement API is not available in Incognito mode.
1293 if (!is_in_memory_ &&
1294 base::FeatureList::IsEnabled(features::kConversionMeasurement)) {
1295 conversion_manager_ = std::make_unique<ConversionManagerImpl>(this, path);
1296 }
1297
1298 GeneratedCodeCacheSettings settings =
1299 GetContentClient()->browser()->GetGeneratedCodeCacheSettings(
1300 browser_context_);
1301
1302 // For Incognito mode, we should not persist anything on the disk so
1303 // we do not create a code cache. Caching the generated code in memory
1304 // is not useful, since V8 already maintains one copy in memory.
1305 if (!is_in_memory_ && settings.enabled()) {
1306 generated_code_cache_context_ =
1307 base::MakeRefCounted<GeneratedCodeCacheContext>();
1308
1309 base::FilePath code_cache_path;
1310 if (partition_domain_.empty()) {
1311 code_cache_path = settings.path().AppendASCII("Code Cache");
1312 } else {
1313 // For site isolated partitions use the config directory.
1314 code_cache_path = settings.path()
1315 .Append(relative_partition_path_)
1316 .AppendASCII("Code Cache");
1317 }
1318 DCHECK_GE(settings.size_in_bytes(), 0);
1319 GetGeneratedCodeCacheContext()->Initialize(code_cache_path,
1320 settings.size_in_bytes());
1321 }
1322
1323 font_access_manager_ = std::make_unique<FontAccessManagerImpl>();
1324
1325 if (base::FeatureList::IsEnabled(blink::features::kPrerender2))
1326 prerender_host_registry_ = std::make_unique<PrerenderHostRegistry>();
1327 }
1328
OnStorageServiceDisconnected()1329 void StoragePartitionImpl::OnStorageServiceDisconnected() {
1330 // This will be lazily re-bound on next use.
1331 remote_partition_.reset();
1332
1333 dom_storage_context_->RecoverFromStorageServiceCrash();
1334 for (const auto& client : dom_storage_clients_)
1335 client.second->ResetStorageAreaAndNamespaceConnections();
1336 }
1337
GetPath()1338 base::FilePath StoragePartitionImpl::GetPath() {
1339 return partition_path_;
1340 }
1341
GetPartitionDomain()1342 std::string StoragePartitionImpl::GetPartitionDomain() {
1343 return partition_domain_;
1344 }
1345
GetNetworkContext()1346 network::mojom::NetworkContext* StoragePartitionImpl::GetNetworkContext() {
1347 DCHECK(initialized_);
1348 if (!network_context_.is_bound())
1349 InitNetworkContext();
1350 return network_context_.get();
1351 }
1352
1353 scoped_refptr<network::SharedURLLoaderFactory>
GetURLLoaderFactoryForBrowserProcess()1354 StoragePartitionImpl::GetURLLoaderFactoryForBrowserProcess() {
1355 DCHECK(initialized_);
1356 if (!shared_url_loader_factory_for_browser_process_) {
1357 shared_url_loader_factory_for_browser_process_ =
1358 new URLLoaderFactoryForBrowserProcess(this, false /* corb_enabled */);
1359 }
1360 return shared_url_loader_factory_for_browser_process_;
1361 }
1362
1363 scoped_refptr<network::SharedURLLoaderFactory>
GetURLLoaderFactoryForBrowserProcessWithCORBEnabled()1364 StoragePartitionImpl::GetURLLoaderFactoryForBrowserProcessWithCORBEnabled() {
1365 DCHECK(initialized_);
1366 if (!shared_url_loader_factory_for_browser_process_with_corb_) {
1367 shared_url_loader_factory_for_browser_process_with_corb_ =
1368 new URLLoaderFactoryForBrowserProcess(this, true /* corb_enabled */);
1369 }
1370 return shared_url_loader_factory_for_browser_process_with_corb_;
1371 }
1372
1373 std::unique_ptr<network::PendingSharedURLLoaderFactory>
GetURLLoaderFactoryForBrowserProcessIOThread()1374 StoragePartitionImpl::GetURLLoaderFactoryForBrowserProcessIOThread() {
1375 DCHECK(initialized_);
1376 return url_loader_factory_getter_->GetPendingNetworkFactory();
1377 }
1378
1379 network::mojom::CookieManager*
GetCookieManagerForBrowserProcess()1380 StoragePartitionImpl::GetCookieManagerForBrowserProcess() {
1381 DCHECK(initialized_);
1382 // Create the CookieManager as needed.
1383 if (!cookie_manager_for_browser_process_ ||
1384 !cookie_manager_for_browser_process_.is_connected()) {
1385 // Reset |cookie_manager_for_browser_process_| before binding it again.
1386 cookie_manager_for_browser_process_.reset();
1387 GetNetworkContext()->GetCookieManager(
1388 cookie_manager_for_browser_process_.BindNewPipeAndPassReceiver());
1389 }
1390 return cookie_manager_for_browser_process_.get();
1391 }
1392
CreateRestrictedCookieManager(network::mojom::RestrictedCookieManagerRole role,const url::Origin & origin,const net::SiteForCookies & site_for_cookies,const url::Origin & top_frame_origin,bool is_service_worker,int process_id,int routing_id,mojo::PendingReceiver<network::mojom::RestrictedCookieManager> receiver,mojo::PendingRemote<network::mojom::CookieAccessObserver> cookie_observer)1393 void StoragePartitionImpl::CreateRestrictedCookieManager(
1394 network::mojom::RestrictedCookieManagerRole role,
1395 const url::Origin& origin,
1396 const net::SiteForCookies& site_for_cookies,
1397 const url::Origin& top_frame_origin,
1398 bool is_service_worker,
1399 int process_id,
1400 int routing_id,
1401 mojo::PendingReceiver<network::mojom::RestrictedCookieManager> receiver,
1402 mojo::PendingRemote<network::mojom::CookieAccessObserver> cookie_observer) {
1403 DCHECK(initialized_);
1404 if (!GetContentClient()->browser()->WillCreateRestrictedCookieManager(
1405 role, browser_context_, origin, site_for_cookies, top_frame_origin,
1406 is_service_worker, process_id, routing_id, &receiver)) {
1407 GetNetworkContext()->GetRestrictedCookieManager(
1408 std::move(receiver), role, origin, site_for_cookies, top_frame_origin,
1409 std::move(cookie_observer));
1410 }
1411 }
1412
CreateHasTrustTokensAnswerer(mojo::PendingReceiver<network::mojom::HasTrustTokensAnswerer> receiver,const url::Origin & top_frame_origin)1413 void StoragePartitionImpl::CreateHasTrustTokensAnswerer(
1414 mojo::PendingReceiver<network::mojom::HasTrustTokensAnswerer> receiver,
1415 const url::Origin& top_frame_origin) {
1416 DCHECK(initialized_);
1417 GetNetworkContext()->GetHasTrustTokensAnswerer(std::move(receiver),
1418 top_frame_origin);
1419 }
1420
GetQuotaManager()1421 storage::QuotaManager* StoragePartitionImpl::GetQuotaManager() {
1422 DCHECK(initialized_);
1423 return quota_manager_.get();
1424 }
1425
GetAppCacheService()1426 ChromeAppCacheService* StoragePartitionImpl::GetAppCacheService() {
1427 DCHECK(initialized_);
1428 return appcache_service_.get();
1429 }
1430
GetBackgroundSyncContext()1431 BackgroundSyncContextImpl* StoragePartitionImpl::GetBackgroundSyncContext() {
1432 DCHECK(initialized_);
1433 return background_sync_context_.get();
1434 }
1435
GetFileSystemContext()1436 storage::FileSystemContext* StoragePartitionImpl::GetFileSystemContext() {
1437 DCHECK(initialized_);
1438 return filesystem_context_.get();
1439 }
1440
GetDatabaseTracker()1441 storage::DatabaseTracker* StoragePartitionImpl::GetDatabaseTracker() {
1442 DCHECK(initialized_);
1443 return database_tracker_.get();
1444 }
1445
GetDOMStorageContext()1446 DOMStorageContextWrapper* StoragePartitionImpl::GetDOMStorageContext() {
1447 DCHECK(initialized_);
1448 return dom_storage_context_.get();
1449 }
1450
GetLockManager()1451 LockManager* StoragePartitionImpl::GetLockManager() {
1452 DCHECK(initialized_);
1453 return lock_manager_.get();
1454 }
1455
GetIndexedDBControl()1456 storage::mojom::IndexedDBControl& StoragePartitionImpl::GetIndexedDBControl() {
1457 DCHECK_CURRENTLY_ON(BrowserThread::UI);
1458 return *indexed_db_control_wrapper_.get();
1459 }
1460
GetIndexedDBContextInternal()1461 IndexedDBContextImpl* StoragePartitionImpl::GetIndexedDBContextInternal() {
1462 DCHECK(initialized_);
1463 return indexed_db_control_wrapper_->GetIndexedDBContextInternal();
1464 }
1465
1466 NativeFileSystemEntryFactory*
GetNativeFileSystemEntryFactory()1467 StoragePartitionImpl::GetNativeFileSystemEntryFactory() {
1468 DCHECK(initialized_);
1469 return native_file_system_manager_.get();
1470 }
1471
GetQuotaContext()1472 QuotaContext* StoragePartitionImpl::GetQuotaContext() {
1473 DCHECK(initialized_);
1474 return quota_context_.get();
1475 }
1476
GetCacheStorageContext()1477 CacheStorageContextImpl* StoragePartitionImpl::GetCacheStorageContext() {
1478 DCHECK(initialized_);
1479 return cache_storage_context_.get();
1480 }
1481
GetServiceWorkerContext()1482 ServiceWorkerContextWrapper* StoragePartitionImpl::GetServiceWorkerContext() {
1483 DCHECK(initialized_);
1484 return service_worker_context_.get();
1485 }
1486
GetDedicatedWorkerService()1487 DedicatedWorkerServiceImpl* StoragePartitionImpl::GetDedicatedWorkerService() {
1488 DCHECK(initialized_);
1489 return dedicated_worker_service_.get();
1490 }
1491
GetSharedWorkerService()1492 SharedWorkerServiceImpl* StoragePartitionImpl::GetSharedWorkerService() {
1493 DCHECK(initialized_);
1494 return shared_worker_service_.get();
1495 }
1496
1497 #if !defined(OS_ANDROID)
GetHostZoomMap()1498 HostZoomMap* StoragePartitionImpl::GetHostZoomMap() {
1499 DCHECK(initialized_);
1500 DCHECK(host_zoom_level_context_.get());
1501 return host_zoom_level_context_->GetHostZoomMap();
1502 }
1503
GetHostZoomLevelContext()1504 HostZoomLevelContext* StoragePartitionImpl::GetHostZoomLevelContext() {
1505 DCHECK(initialized_);
1506 return host_zoom_level_context_.get();
1507 }
1508
GetZoomLevelDelegate()1509 ZoomLevelDelegate* StoragePartitionImpl::GetZoomLevelDelegate() {
1510 DCHECK(initialized_);
1511 DCHECK(host_zoom_level_context_.get());
1512 return host_zoom_level_context_->GetZoomLevelDelegate();
1513 }
1514 #endif // !defined(OS_ANDROID)
1515
1516 PlatformNotificationContextImpl*
GetPlatformNotificationContext()1517 StoragePartitionImpl::GetPlatformNotificationContext() {
1518 DCHECK(initialized_);
1519 return platform_notification_context_.get();
1520 }
1521
GetBackgroundFetchContext()1522 BackgroundFetchContext* StoragePartitionImpl::GetBackgroundFetchContext() {
1523 DCHECK(initialized_);
1524 return background_fetch_context_.get();
1525 }
1526
GetPaymentAppContext()1527 PaymentAppContextImpl* StoragePartitionImpl::GetPaymentAppContext() {
1528 DCHECK(initialized_);
1529 return payment_app_context_.get();
1530 }
1531
GetBroadcastChannelProvider()1532 BroadcastChannelProvider* StoragePartitionImpl::GetBroadcastChannelProvider() {
1533 DCHECK(initialized_);
1534 return broadcast_channel_provider_.get();
1535 }
1536
1537 BluetoothAllowedDevicesMap*
GetBluetoothAllowedDevicesMap()1538 StoragePartitionImpl::GetBluetoothAllowedDevicesMap() {
1539 DCHECK(initialized_);
1540 return bluetooth_allowed_devices_map_.get();
1541 }
1542
GetBlobRegistry()1543 BlobRegistryWrapper* StoragePartitionImpl::GetBlobRegistry() {
1544 DCHECK(initialized_);
1545 return blob_registry_.get();
1546 }
1547
GetPrefetchURLLoaderService()1548 PrefetchURLLoaderService* StoragePartitionImpl::GetPrefetchURLLoaderService() {
1549 DCHECK(initialized_);
1550 return prefetch_url_loader_service_.get();
1551 }
1552
GetCookieStoreContext()1553 CookieStoreContext* StoragePartitionImpl::GetCookieStoreContext() {
1554 DCHECK(initialized_);
1555 return cookie_store_context_.get();
1556 }
1557
1558 GeneratedCodeCacheContext*
GetGeneratedCodeCacheContext()1559 StoragePartitionImpl::GetGeneratedCodeCacheContext() {
1560 DCHECK(initialized_);
1561 return generated_code_cache_context_.get();
1562 }
1563
1564 DevToolsBackgroundServicesContextImpl*
GetDevToolsBackgroundServicesContext()1565 StoragePartitionImpl::GetDevToolsBackgroundServicesContext() {
1566 DCHECK(initialized_);
1567 return devtools_background_services_context_.get();
1568 }
1569
1570 NativeFileSystemManagerImpl*
GetNativeFileSystemManager()1571 StoragePartitionImpl::GetNativeFileSystemManager() {
1572 DCHECK(initialized_);
1573 return native_file_system_manager_.get();
1574 }
1575
GetConversionManager()1576 ConversionManagerImpl* StoragePartitionImpl::GetConversionManager() {
1577 DCHECK(initialized_);
1578 return conversion_manager_.get();
1579 }
1580
GetFontAccessManager()1581 FontAccessManagerImpl* StoragePartitionImpl::GetFontAccessManager() {
1582 DCHECK(initialized_);
1583 return font_access_manager_.get();
1584 }
1585
GetPrerenderHostRegistry()1586 PrerenderHostRegistry* StoragePartitionImpl::GetPrerenderHostRegistry() {
1587 DCHECK(base::FeatureList::IsEnabled(blink::features::kPrerender2));
1588 DCHECK(initialized_);
1589 return prerender_host_registry_.get();
1590 }
1591
GetContentIndexContext()1592 ContentIndexContextImpl* StoragePartitionImpl::GetContentIndexContext() {
1593 DCHECK(initialized_);
1594 return content_index_context_.get();
1595 }
1596
GetNativeIOContext()1597 NativeIOContext* StoragePartitionImpl::GetNativeIOContext() {
1598 DCHECK(initialized_);
1599 return native_io_context_.get();
1600 }
1601
1602 leveldb_proto::ProtoDatabaseProvider*
GetProtoDatabaseProvider()1603 StoragePartitionImpl::GetProtoDatabaseProvider() {
1604 if (!proto_database_provider_) {
1605 proto_database_provider_ =
1606 std::make_unique<leveldb_proto::ProtoDatabaseProvider>(partition_path_,
1607 is_in_memory_);
1608 }
1609 return proto_database_provider_.get();
1610 }
1611
SetProtoDatabaseProvider(std::unique_ptr<leveldb_proto::ProtoDatabaseProvider> proto_db_provider)1612 void StoragePartitionImpl::SetProtoDatabaseProvider(
1613 std::unique_ptr<leveldb_proto::ProtoDatabaseProvider> proto_db_provider) {
1614 DCHECK(!proto_database_provider_);
1615 proto_database_provider_ = std::move(proto_db_provider);
1616 }
1617
1618 leveldb_proto::ProtoDatabaseProvider*
GetProtoDatabaseProviderForTesting()1619 StoragePartitionImpl::GetProtoDatabaseProviderForTesting() {
1620 return proto_database_provider_.get();
1621 }
1622
OpenLocalStorage(const url::Origin & origin,mojo::PendingReceiver<blink::mojom::StorageArea> receiver)1623 void StoragePartitionImpl::OpenLocalStorage(
1624 const url::Origin& origin,
1625 mojo::PendingReceiver<blink::mojom::StorageArea> receiver) {
1626 DCHECK(initialized_);
1627 const auto& security_policy_handle = dom_storage_receivers_.current_context();
1628 if (!security_policy_handle->CanAccessDataForOrigin(origin)) {
1629 SYSLOG(WARNING) << "Killing renderer: illegal localStorage request.";
1630 dom_storage_receivers_.ReportBadMessage(
1631 "Access denied for localStorage request");
1632 return;
1633 }
1634 dom_storage_context_->OpenLocalStorage(origin, std::move(receiver));
1635 }
1636
BindSessionStorageNamespace(const std::string & namespace_id,mojo::PendingReceiver<blink::mojom::SessionStorageNamespace> receiver)1637 void StoragePartitionImpl::BindSessionStorageNamespace(
1638 const std::string& namespace_id,
1639 mojo::PendingReceiver<blink::mojom::SessionStorageNamespace> receiver) {
1640 DCHECK(initialized_);
1641 dom_storage_context_->BindNamespace(
1642 namespace_id, dom_storage_receivers_.GetBadMessageCallback(),
1643 std::move(receiver));
1644 }
1645
BindSessionStorageArea(const url::Origin & origin,const std::string & namespace_id,mojo::PendingReceiver<blink::mojom::StorageArea> receiver)1646 void StoragePartitionImpl::BindSessionStorageArea(
1647 const url::Origin& origin,
1648 const std::string& namespace_id,
1649 mojo::PendingReceiver<blink::mojom::StorageArea> receiver) {
1650 DCHECK(initialized_);
1651 ChildProcessSecurityPolicyImpl::Handle security_policy_handle =
1652 dom_storage_receivers_.current_context()->Duplicate();
1653 dom_storage_context_->BindStorageArea(
1654 std::move(security_policy_handle), origin, namespace_id,
1655 dom_storage_receivers_.GetBadMessageCallback(), std::move(receiver));
1656 }
1657
OnAuthRequired(const base::Optional<base::UnguessableToken> & window_id,int32_t process_id,int32_t routing_id,uint32_t request_id,const GURL & url,bool first_auth_attempt,const net::AuthChallengeInfo & auth_info,network::mojom::URLResponseHeadPtr head,mojo::PendingRemote<network::mojom::AuthChallengeResponder> auth_challenge_responder)1658 void StoragePartitionImpl::OnAuthRequired(
1659 const base::Optional<base::UnguessableToken>& window_id,
1660 int32_t process_id,
1661 int32_t routing_id,
1662 uint32_t request_id,
1663 const GURL& url,
1664 bool first_auth_attempt,
1665 const net::AuthChallengeInfo& auth_info,
1666 network::mojom::URLResponseHeadPtr head,
1667 mojo::PendingRemote<network::mojom::AuthChallengeResponder>
1668 auth_challenge_responder) {
1669 if (window_id) {
1670 bool is_main_frame = false;
1671 base::RepeatingCallback<WebContents*(void)> web_contents_getter;
1672 if (service_worker_context_->context()) {
1673 auto* container_host =
1674 service_worker_context_->context()->GetContainerHostByWindowId(
1675 *window_id);
1676 if (container_host) {
1677 int frame_tree_node_id = container_host->frame_tree_node_id();
1678 if (FrameTreeNode* frame_tree_node =
1679 FrameTreeNode::GloballyFindByID(frame_tree_node_id)) {
1680 is_main_frame = frame_tree_node->IsMainFrame();
1681 web_contents_getter = base::BindRepeating(
1682 &WebContents::FromFrameTreeNodeId, frame_tree_node_id);
1683 }
1684 }
1685 }
1686 OnAuthRequiredContinuation(
1687 process_id, routing_id, request_id, url, is_main_frame,
1688 first_auth_attempt, auth_info, std::move(head),
1689 std::move(auth_challenge_responder), web_contents_getter);
1690 return;
1691 }
1692 OnAuthRequiredContinuation(
1693 process_id, routing_id, request_id, url,
1694 IsMainFrameRequest(process_id, routing_id), first_auth_attempt, auth_info,
1695 std::move(head), std::move(auth_challenge_responder),
1696 base::BindRepeating(GetWebContents, process_id, routing_id));
1697 }
1698
OnCertificateRequested(const base::Optional<base::UnguessableToken> & window_id,int32_t process_id,int32_t routing_id,uint32_t request_id,const scoped_refptr<net::SSLCertRequestInfo> & cert_info,mojo::PendingRemote<network::mojom::ClientCertificateResponder> cert_responder)1699 void StoragePartitionImpl::OnCertificateRequested(
1700 const base::Optional<base::UnguessableToken>& window_id,
1701 int32_t process_id,
1702 int32_t routing_id,
1703 uint32_t request_id,
1704 const scoped_refptr<net::SSLCertRequestInfo>& cert_info,
1705 mojo::PendingRemote<network::mojom::ClientCertificateResponder>
1706 cert_responder) {
1707 // Use |window_id| if it's provided.
1708 if (window_id) {
1709 base::RepeatingCallback<WebContents*(void)> web_contents_getter;
1710 if (service_worker_context_->context()) {
1711 auto* container_host =
1712 service_worker_context_->context()->GetContainerHostByWindowId(
1713 *window_id);
1714 if (container_host) {
1715 int frame_tree_node_id = container_host->frame_tree_node_id();
1716 web_contents_getter = base::BindRepeating(
1717 &WebContents::FromFrameTreeNodeId, frame_tree_node_id);
1718 }
1719 }
1720 OnCertificateRequestedContinuation(process_id, routing_id, request_id,
1721 cert_info, std::move(cert_responder),
1722 web_contents_getter);
1723 return;
1724 }
1725
1726 OnCertificateRequestedContinuation(
1727 process_id, routing_id, request_id, cert_info, std::move(cert_responder),
1728 base::BindRepeating(GetWebContents, process_id, routing_id));
1729 }
1730
OnSSLCertificateError(int32_t process_id,int32_t routing_id,const GURL & url,int net_error,const net::SSLInfo & ssl_info,bool fatal,OnSSLCertificateErrorCallback response)1731 void StoragePartitionImpl::OnSSLCertificateError(
1732 int32_t process_id,
1733 int32_t routing_id,
1734 const GURL& url,
1735 int net_error,
1736 const net::SSLInfo& ssl_info,
1737 bool fatal,
1738 OnSSLCertificateErrorCallback response) {
1739 SSLErrorDelegate* delegate =
1740 new SSLErrorDelegate(std::move(response)); // deletes self
1741 bool is_main_frame_request = IsMainFrameRequest(process_id, routing_id);
1742 SSLManager::OnSSLCertificateError(
1743 delegate->GetWeakPtr(), is_main_frame_request, url,
1744 GetWebContents(process_id, routing_id), net_error, ssl_info, fatal);
1745 }
1746
OnFileUploadRequested(int32_t process_id,bool async,const std::vector<base::FilePath> & file_paths,OnFileUploadRequestedCallback callback)1747 void StoragePartitionImpl::OnFileUploadRequested(
1748 int32_t process_id,
1749 bool async,
1750 const std::vector<base::FilePath>& file_paths,
1751 OnFileUploadRequestedCallback callback) {
1752 NetworkContextOnFileUploadRequested(process_id, async, file_paths,
1753 std::move(callback));
1754 }
1755
OnCanSendReportingReports(const std::vector<url::Origin> & origins,OnCanSendReportingReportsCallback callback)1756 void StoragePartitionImpl::OnCanSendReportingReports(
1757 const std::vector<url::Origin>& origins,
1758 OnCanSendReportingReportsCallback callback) {
1759 DCHECK(initialized_);
1760 PermissionController* permission_controller =
1761 BrowserContext::GetPermissionController(browser_context_);
1762 DCHECK(permission_controller);
1763
1764 std::vector<url::Origin> origins_out;
1765 for (auto& origin : origins) {
1766 GURL origin_url = origin.GetURL();
1767 bool allowed = permission_controller->GetPermissionStatus(
1768 PermissionType::BACKGROUND_SYNC, origin_url,
1769 origin_url) == blink::mojom::PermissionStatus::GRANTED;
1770 if (allowed)
1771 origins_out.push_back(origin);
1772 }
1773
1774 std::move(callback).Run(origins_out);
1775 }
1776
OnCanSendDomainReliabilityUpload(const GURL & origin,OnCanSendDomainReliabilityUploadCallback callback)1777 void StoragePartitionImpl::OnCanSendDomainReliabilityUpload(
1778 const GURL& origin,
1779 OnCanSendDomainReliabilityUploadCallback callback) {
1780 DCHECK(initialized_);
1781 PermissionController* permission_controller =
1782 BrowserContext::GetPermissionController(browser_context_);
1783 std::move(callback).Run(
1784 permission_controller->GetPermissionStatus(
1785 content::PermissionType::BACKGROUND_SYNC, origin, origin) ==
1786 blink::mojom::PermissionStatus::GRANTED);
1787 }
1788
OnClearSiteData(int32_t process_id,int32_t routing_id,const GURL & url,const std::string & header_value,int load_flags,OnClearSiteDataCallback callback)1789 void StoragePartitionImpl::OnClearSiteData(int32_t process_id,
1790 int32_t routing_id,
1791 const GURL& url,
1792 const std::string& header_value,
1793 int load_flags,
1794 OnClearSiteDataCallback callback) {
1795 DCHECK(initialized_);
1796 auto browser_context_getter = base::BindRepeating(
1797 GetBrowserContextFromStoragePartition, weak_factory_.GetWeakPtr());
1798 auto web_contents_getter = base::BindRepeating(
1799 GetWebContentsForStoragePartition, process_id, routing_id);
1800 ClearSiteDataHandler::HandleHeader(browser_context_getter,
1801 web_contents_getter, url, header_value,
1802 load_flags, std::move(callback));
1803 }
1804
1805 #if defined(OS_ANDROID)
OnGenerateHttpNegotiateAuthToken(const std::string & server_auth_token,bool can_delegate,const std::string & auth_negotiate_android_account_type,const std::string & spn,OnGenerateHttpNegotiateAuthTokenCallback callback)1806 void StoragePartitionImpl::OnGenerateHttpNegotiateAuthToken(
1807 const std::string& server_auth_token,
1808 bool can_delegate,
1809 const std::string& auth_negotiate_android_account_type,
1810 const std::string& spn,
1811 OnGenerateHttpNegotiateAuthTokenCallback callback) {
1812 // The callback takes ownership of these unique_ptrs and destroys them when
1813 // run.
1814 auto prefs = std::make_unique<net::HttpAuthPreferences>();
1815 prefs->set_auth_android_negotiate_account_type(
1816 auth_negotiate_android_account_type);
1817
1818 auto auth_negotiate =
1819 std::make_unique<net::android::HttpAuthNegotiateAndroid>(prefs.get());
1820 net::android::HttpAuthNegotiateAndroid* auth_negotiate_raw =
1821 auth_negotiate.get();
1822 auth_negotiate->set_server_auth_token(server_auth_token);
1823 auth_negotiate->set_can_delegate(can_delegate);
1824
1825 auto auth_token = std::make_unique<std::string>();
1826 auth_negotiate_raw->GenerateAuthTokenAndroid(
1827 nullptr, spn, std::string(), auth_token.get(),
1828 base::BindOnce(&FinishGenerateNegotiateAuthToken,
1829 std::move(auth_negotiate), std::move(auth_token),
1830 std::move(prefs), std::move(callback)));
1831 }
1832 #endif
1833
1834 #if defined(OS_CHROMEOS)
OnTrustAnchorUsed()1835 void StoragePartitionImpl::OnTrustAnchorUsed() {
1836 GetContentClient()->browser()->OnTrustAnchorUsed(browser_context_);
1837 }
1838 #endif
1839
OnTrustTokenIssuanceDivertedToSystem(network::mojom::FulfillTrustTokenIssuanceRequestPtr request,OnTrustTokenIssuanceDivertedToSystemCallback callback)1840 void StoragePartitionImpl::OnTrustTokenIssuanceDivertedToSystem(
1841 network::mojom::FulfillTrustTokenIssuanceRequestPtr request,
1842 OnTrustTokenIssuanceDivertedToSystemCallback callback) {
1843 // TODO(crbug.com/1130272): Implement logic that allows executing Trust
1844 // Tokens operations when available, rather than failing unconditionally.
1845 auto response = network::mojom::FulfillTrustTokenIssuanceAnswer::New();
1846 response->status =
1847 network::mojom::FulfillTrustTokenIssuanceAnswer::Status::kNotFound;
1848 std::move(callback).Run(std::move(response));
1849 }
1850
ClearDataImpl(uint32_t remove_mask,uint32_t quota_storage_remove_mask,const GURL & storage_origin,OriginMatcherFunction origin_matcher,CookieDeletionFilterPtr cookie_deletion_filter,bool perform_storage_cleanup,const base::Time begin,const base::Time end,base::OnceClosure callback)1851 void StoragePartitionImpl::ClearDataImpl(
1852 uint32_t remove_mask,
1853 uint32_t quota_storage_remove_mask,
1854 const GURL& storage_origin,
1855 OriginMatcherFunction origin_matcher,
1856 CookieDeletionFilterPtr cookie_deletion_filter,
1857 bool perform_storage_cleanup,
1858 const base::Time begin,
1859 const base::Time end,
1860 base::OnceClosure callback) {
1861 DCHECK_CURRENTLY_ON(BrowserThread::UI);
1862
1863 for (auto& observer : data_removal_observers_) {
1864 auto filter = CreateGenericOriginMatcher(storage_origin, origin_matcher,
1865 special_storage_policy_);
1866 observer.OnOriginDataCleared(remove_mask, std::move(filter), begin, end);
1867 }
1868
1869 DataDeletionHelper* helper = new DataDeletionHelper(
1870 remove_mask, quota_storage_remove_mask,
1871 base::BindOnce(&StoragePartitionImpl::DeletionHelperDone,
1872 weak_factory_.GetWeakPtr(), std::move(callback)));
1873 // |helper| deletes itself when done in
1874 // DataDeletionHelper::DecrementTaskCount().
1875 deletion_helpers_running_++;
1876 helper->ClearDataOnUIThread(
1877 storage_origin, std::move(origin_matcher),
1878 std::move(cookie_deletion_filter), GetPath(), dom_storage_context_.get(),
1879 quota_manager_.get(), special_storage_policy_.get(),
1880 filesystem_context_.get(), GetCookieManagerForBrowserProcess(),
1881 conversion_manager_.get(), perform_storage_cleanup, begin, end);
1882 }
1883
DeletionHelperDone(base::OnceClosure callback)1884 void StoragePartitionImpl::DeletionHelperDone(base::OnceClosure callback) {
1885 std::move(callback).Run();
1886 deletion_helpers_running_--;
1887 if (on_deletion_helpers_done_callback_ && deletion_helpers_running_ == 0) {
1888 // Notify tests that storage partition is done with all deletion tasks.
1889 std::move(on_deletion_helpers_done_callback_).Run();
1890 }
1891 }
1892
1893 void StoragePartitionImpl::QuotaManagedDataDeletionHelper::
IncrementTaskCountOnIO()1894 IncrementTaskCountOnIO() {
1895 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1896 ++task_count_;
1897 }
1898
1899 void StoragePartitionImpl::QuotaManagedDataDeletionHelper::
DecrementTaskCountOnIO()1900 DecrementTaskCountOnIO() {
1901 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1902 DCHECK_GT(task_count_, 0);
1903 --task_count_;
1904 if (task_count_)
1905 return;
1906
1907 std::move(callback_).Run();
1908 delete this;
1909 }
1910
ClearDataOnIOThread(const scoped_refptr<storage::QuotaManager> & quota_manager,const base::Time begin,const base::Time end,const scoped_refptr<storage::SpecialStoragePolicy> & special_storage_policy,StoragePartition::OriginMatcherFunction origin_matcher,bool perform_storage_cleanup)1911 void StoragePartitionImpl::QuotaManagedDataDeletionHelper::ClearDataOnIOThread(
1912 const scoped_refptr<storage::QuotaManager>& quota_manager,
1913 const base::Time begin,
1914 const base::Time end,
1915 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy,
1916 StoragePartition::OriginMatcherFunction origin_matcher,
1917 bool perform_storage_cleanup) {
1918 IncrementTaskCountOnIO();
1919 base::RepeatingClosure decrement_callback = base::BindRepeating(
1920 &QuotaManagedDataDeletionHelper::DecrementTaskCountOnIO,
1921 base::Unretained(this));
1922
1923 if (quota_storage_remove_mask_ & QUOTA_MANAGED_STORAGE_MASK_PERSISTENT) {
1924 IncrementTaskCountOnIO();
1925 // Ask the QuotaManager for all origins with persistent quota modified
1926 // within the user-specified timeframe, and deal with the resulting set in
1927 // ClearQuotaManagedOriginsOnIOThread().
1928 quota_manager->GetOriginsModifiedBetween(
1929 blink::mojom::StorageType::kPersistent, begin, end,
1930 base::BindOnce(&QuotaManagedDataDeletionHelper::ClearOriginsOnIOThread,
1931 base::Unretained(this), base::RetainedRef(quota_manager),
1932 special_storage_policy, origin_matcher,
1933 perform_storage_cleanup, decrement_callback));
1934 }
1935
1936 // Do the same for temporary quota.
1937 if (quota_storage_remove_mask_ & QUOTA_MANAGED_STORAGE_MASK_TEMPORARY) {
1938 IncrementTaskCountOnIO();
1939 quota_manager->GetOriginsModifiedBetween(
1940 blink::mojom::StorageType::kTemporary, begin, end,
1941 base::BindOnce(&QuotaManagedDataDeletionHelper::ClearOriginsOnIOThread,
1942 base::Unretained(this), base::RetainedRef(quota_manager),
1943 special_storage_policy, origin_matcher,
1944 perform_storage_cleanup, decrement_callback));
1945 }
1946
1947 // Do the same for syncable quota.
1948 if (quota_storage_remove_mask_ & QUOTA_MANAGED_STORAGE_MASK_SYNCABLE) {
1949 IncrementTaskCountOnIO();
1950 quota_manager->GetOriginsModifiedBetween(
1951 blink::mojom::StorageType::kSyncable, begin, end,
1952 base::BindOnce(&QuotaManagedDataDeletionHelper::ClearOriginsOnIOThread,
1953 base::Unretained(this), base::RetainedRef(quota_manager),
1954 special_storage_policy, std::move(origin_matcher),
1955 perform_storage_cleanup, decrement_callback));
1956 }
1957
1958 DecrementTaskCountOnIO();
1959 }
1960
1961 void StoragePartitionImpl::QuotaManagedDataDeletionHelper::
ClearOriginsOnIOThread(storage::QuotaManager * quota_manager,const scoped_refptr<storage::SpecialStoragePolicy> & special_storage_policy,StoragePartition::OriginMatcherFunction origin_matcher,bool perform_storage_cleanup,base::OnceClosure callback,const std::set<url::Origin> & origins,blink::mojom::StorageType quota_storage_type)1962 ClearOriginsOnIOThread(
1963 storage::QuotaManager* quota_manager,
1964 const scoped_refptr<storage::SpecialStoragePolicy>&
1965 special_storage_policy,
1966 StoragePartition::OriginMatcherFunction origin_matcher,
1967 bool perform_storage_cleanup,
1968 base::OnceClosure callback,
1969 const std::set<url::Origin>& origins,
1970 blink::mojom::StorageType quota_storage_type) {
1971 // The QuotaManager manages all storage other than cookies, LocalStorage,
1972 // and SessionStorage. This loop wipes out most HTML5 storage for the given
1973 // origins.
1974 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1975 if (origins.empty()) {
1976 std::move(callback).Run();
1977 return;
1978 }
1979
1980 storage::QuotaClientTypes quota_client_types =
1981 StoragePartitionImpl::GenerateQuotaClientTypes(remove_mask_);
1982
1983 // The logic below (via CheckQuotaManagedDataDeletionStatus) only
1984 // invokes the callback when all processing is complete.
1985 base::RepeatingClosure done_callback = base::AdaptCallbackForRepeating(
1986 perform_storage_cleanup
1987 ? base::BindOnce(&PerformQuotaManagerStorageCleanup,
1988 base::WrapRefCounted(quota_manager),
1989 quota_storage_type, quota_client_types,
1990 std::move(callback))
1991 : std::move(callback));
1992
1993 size_t* deletion_task_count = new size_t(0u);
1994 (*deletion_task_count)++;
1995 for (const auto& origin : origins) {
1996 // TODO(mkwst): Clean this up, it's slow. http://crbug.com/130746
1997 if (storage_origin_.has_value() && origin != *storage_origin_)
1998 continue;
1999
2000 if (origin_matcher &&
2001 !origin_matcher.Run(origin, special_storage_policy.get())) {
2002 continue;
2003 }
2004
2005 (*deletion_task_count)++;
2006 quota_manager->DeleteOriginData(
2007 origin, quota_storage_type, quota_client_types,
2008 base::BindOnce(&OnQuotaManagedOriginDeleted, origin, quota_storage_type,
2009 deletion_task_count, done_callback));
2010 }
2011 (*deletion_task_count)--;
2012
2013 CheckQuotaManagedDataDeletionStatus(deletion_task_count, done_callback);
2014 }
2015
2016 base::OnceClosure
CreateTaskCompletionClosure(TracingDataType data_type)2017 StoragePartitionImpl::DataDeletionHelper::CreateTaskCompletionClosure(
2018 TracingDataType data_type) {
2019 DCHECK_CURRENTLY_ON(BrowserThread::UI);
2020 auto result = pending_tasks_.insert(data_type);
2021 DCHECK(result.second) << "Task already started: "
2022 << static_cast<int>(data_type);
2023
2024 static int tracing_id = 0;
2025 TRACE_EVENT_ASYNC_BEGIN1("browsing_data", "StoragePartitionImpl",
2026 ++tracing_id, "data_type",
2027 static_cast<int>(data_type));
2028 return base::BindOnce(
2029 &StoragePartitionImpl::DataDeletionHelper::OnTaskComplete,
2030 base::Unretained(this), data_type, tracing_id);
2031 }
2032
OnTaskComplete(TracingDataType data_type,int tracing_id)2033 void StoragePartitionImpl::DataDeletionHelper::OnTaskComplete(
2034 TracingDataType data_type,
2035 int tracing_id) {
2036 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
2037 GetUIThreadTaskRunner({})->PostTask(
2038 FROM_HERE,
2039 base::BindOnce(&DataDeletionHelper::OnTaskComplete,
2040 base::Unretained(this), data_type, tracing_id));
2041 return;
2042 }
2043 size_t num_erased = pending_tasks_.erase(data_type);
2044 DCHECK_EQ(num_erased, 1U) << static_cast<int>(data_type);
2045 TRACE_EVENT_ASYNC_END0("browsing_data", "StoragePartitionImpl", tracing_id);
2046
2047 if (pending_tasks_.empty()) {
2048 std::move(callback_).Run();
2049 delete this;
2050 }
2051 }
2052
RecordUnfinishedSubTasks()2053 void StoragePartitionImpl::DataDeletionHelper::RecordUnfinishedSubTasks() {
2054 DCHECK(!pending_tasks_.empty());
2055 for (TracingDataType task : pending_tasks_) {
2056 base::UmaHistogramEnumeration(
2057 "History.ClearBrowsingData.Duration.SlowTasks180sStoragePartition",
2058 task);
2059 }
2060 }
2061
ClearDataOnUIThread(const GURL & storage_origin,OriginMatcherFunction origin_matcher,CookieDeletionFilterPtr cookie_deletion_filter,const base::FilePath & path,DOMStorageContextWrapper * dom_storage_context,storage::QuotaManager * quota_manager,storage::SpecialStoragePolicy * special_storage_policy,storage::FileSystemContext * filesystem_context,network::mojom::CookieManager * cookie_manager,ConversionManagerImpl * conversion_manager,bool perform_storage_cleanup,const base::Time begin,const base::Time end)2062 void StoragePartitionImpl::DataDeletionHelper::ClearDataOnUIThread(
2063 const GURL& storage_origin,
2064 OriginMatcherFunction origin_matcher,
2065 CookieDeletionFilterPtr cookie_deletion_filter,
2066 const base::FilePath& path,
2067 DOMStorageContextWrapper* dom_storage_context,
2068 storage::QuotaManager* quota_manager,
2069 storage::SpecialStoragePolicy* special_storage_policy,
2070 storage::FileSystemContext* filesystem_context,
2071 network::mojom::CookieManager* cookie_manager,
2072 ConversionManagerImpl* conversion_manager,
2073 bool perform_storage_cleanup,
2074 const base::Time begin,
2075 const base::Time end) {
2076 DCHECK_NE(remove_mask_, 0u);
2077 DCHECK(callback_);
2078
2079 // Only one of |storage_origin| and |origin_matcher| can be set.
2080 DCHECK(storage_origin.is_empty() || origin_matcher.is_null());
2081
2082 GetUIThreadTaskRunner({})->PostDelayedTask(
2083 FROM_HERE,
2084 base::BindOnce(
2085 &StoragePartitionImpl::DataDeletionHelper::RecordUnfinishedSubTasks,
2086 weak_factory_.GetWeakPtr()),
2087 kSlowTaskTimeout);
2088
2089 base::ScopedClosureRunner synchronous_clear_operations(
2090 CreateTaskCompletionClosure(TracingDataType::kSynchronous));
2091
2092 scoped_refptr<storage::SpecialStoragePolicy> storage_policy_ref =
2093 base::WrapRefCounted(special_storage_policy);
2094
2095 if (remove_mask_ & REMOVE_DATA_MASK_COOKIES) {
2096 // The CookieDeletionFilter has a redundant time interval to |begin| and
2097 // |end|. Ensure that the filter has no time interval specified to help
2098 // callers detect when they are using the wrong interval values.
2099 DCHECK(!cookie_deletion_filter->created_after_time.has_value());
2100 DCHECK(!cookie_deletion_filter->created_before_time.has_value());
2101
2102 if (!begin.is_null())
2103 cookie_deletion_filter->created_after_time = begin;
2104 if (!end.is_null())
2105 cookie_deletion_filter->created_before_time = end;
2106
2107 cookie_manager->DeleteCookies(
2108 std::move(cookie_deletion_filter),
2109 base::BindOnce(
2110 &OnClearedCookies,
2111 // Handle the cookie store being destroyed and the callback thus not
2112 // being called.
2113 mojo::WrapCallbackWithDefaultInvokeIfNotRun(
2114 CreateTaskCompletionClosure(TracingDataType::kCookies))));
2115 }
2116
2117 if (remove_mask_ & REMOVE_DATA_MASK_INDEXEDDB ||
2118 remove_mask_ & REMOVE_DATA_MASK_WEBSQL ||
2119 remove_mask_ & REMOVE_DATA_MASK_APPCACHE ||
2120 remove_mask_ & REMOVE_DATA_MASK_FILE_SYSTEMS ||
2121 remove_mask_ & REMOVE_DATA_MASK_SERVICE_WORKERS ||
2122 remove_mask_ & REMOVE_DATA_MASK_CACHE_STORAGE) {
2123 GetIOThreadTaskRunner({})->PostTask(
2124 FROM_HERE,
2125 base::BindOnce(&DataDeletionHelper::ClearQuotaManagedDataOnIOThread,
2126 base::Unretained(this),
2127 base::WrapRefCounted(quota_manager), begin, end,
2128 storage_origin, storage_policy_ref, origin_matcher,
2129 perform_storage_cleanup,
2130 CreateTaskCompletionClosure(TracingDataType::kQuota)));
2131 }
2132
2133 if (remove_mask_ & REMOVE_DATA_MASK_LOCAL_STORAGE) {
2134 ClearLocalStorageOnUIThread(
2135 base::WrapRefCounted(dom_storage_context), storage_policy_ref,
2136 origin_matcher, storage_origin, perform_storage_cleanup, begin, end,
2137 mojo::WrapCallbackWithDefaultInvokeIfNotRun(
2138 CreateTaskCompletionClosure(TracingDataType::kLocalStorage)));
2139
2140 // ClearDataImpl cannot clear session storage data when a particular origin
2141 // is specified. Therefore we ignore clearing session storage in this case.
2142 // TODO(lazyboy): Fix.
2143 if (storage_origin.is_empty()) {
2144 // TODO(crbug.com/960325): Sometimes SessionStorage fails to call its
2145 // callback. Figure out why.
2146 ClearSessionStorageOnUIThread(
2147 base::WrapRefCounted(dom_storage_context), storage_policy_ref,
2148 origin_matcher, perform_storage_cleanup,
2149 mojo::WrapCallbackWithDefaultInvokeIfNotRun(
2150 CreateTaskCompletionClosure(TracingDataType::kSessionStorage)));
2151 }
2152 }
2153
2154 if (remove_mask_ & REMOVE_DATA_MASK_SHADER_CACHE) {
2155 GetIOThreadTaskRunner({})->PostTask(
2156 FROM_HERE, base::BindOnce(&ClearShaderCacheOnIOThread, path, begin, end,
2157 CreateTaskCompletionClosure(
2158 TracingDataType::kShaderCache)));
2159 }
2160
2161 auto filter = CreateGenericOriginMatcher(storage_origin, origin_matcher,
2162 storage_policy_ref);
2163 if (conversion_manager && (remove_mask_ & REMOVE_DATA_MASK_CONVERSIONS)) {
2164 conversion_manager->ClearData(
2165 begin, end, std::move(filter),
2166 CreateTaskCompletionClosure(TracingDataType::kConversions));
2167 }
2168
2169 #if BUILDFLAG(ENABLE_PLUGINS)
2170 if (remove_mask_ & REMOVE_DATA_MASK_PLUGIN_PRIVATE_DATA) {
2171 filesystem_context->default_file_task_runner()->PostTask(
2172 FROM_HERE,
2173 base::BindOnce(
2174 &ClearPluginPrivateDataOnFileTaskRunner,
2175 base::WrapRefCounted(filesystem_context), storage_origin,
2176 origin_matcher, storage_policy_ref, begin, end,
2177 CreateTaskCompletionClosure(TracingDataType::kPluginPrivate)));
2178 }
2179 #endif // BUILDFLAG(ENABLE_PLUGINS)
2180 }
2181
ClearDataForOrigin(uint32_t remove_mask,uint32_t quota_storage_remove_mask,const GURL & storage_origin)2182 void StoragePartitionImpl::ClearDataForOrigin(
2183 uint32_t remove_mask,
2184 uint32_t quota_storage_remove_mask,
2185 const GURL& storage_origin) {
2186 DCHECK_CURRENTLY_ON(BrowserThread::UI);
2187 DCHECK(initialized_);
2188 CookieDeletionFilterPtr deletion_filter = CookieDeletionFilter::New();
2189 if (!storage_origin.host().empty())
2190 deletion_filter->host_name = storage_origin.host();
2191 ClearDataImpl(remove_mask, quota_storage_remove_mask, storage_origin,
2192 OriginMatcherFunction(), std::move(deletion_filter), false,
2193 base::Time(), base::Time::Max(), base::DoNothing());
2194 }
2195
ClearData(uint32_t remove_mask,uint32_t quota_storage_remove_mask,const GURL & storage_origin,const base::Time begin,const base::Time end,base::OnceClosure callback)2196 void StoragePartitionImpl::ClearData(uint32_t remove_mask,
2197 uint32_t quota_storage_remove_mask,
2198 const GURL& storage_origin,
2199 const base::Time begin,
2200 const base::Time end,
2201 base::OnceClosure callback) {
2202 DCHECK(initialized_);
2203 CookieDeletionFilterPtr deletion_filter = CookieDeletionFilter::New();
2204 if (!storage_origin.host().empty())
2205 deletion_filter->host_name = storage_origin.host();
2206 bool perform_storage_cleanup =
2207 begin.is_null() && end.is_max() && storage_origin.is_empty();
2208 ClearDataImpl(remove_mask, quota_storage_remove_mask, storage_origin,
2209 OriginMatcherFunction(), std::move(deletion_filter),
2210 perform_storage_cleanup, begin, end, std::move(callback));
2211 }
2212
ClearData(uint32_t remove_mask,uint32_t quota_storage_remove_mask,OriginMatcherFunction origin_matcher,network::mojom::CookieDeletionFilterPtr cookie_deletion_filter,bool perform_storage_cleanup,const base::Time begin,const base::Time end,base::OnceClosure callback)2213 void StoragePartitionImpl::ClearData(
2214 uint32_t remove_mask,
2215 uint32_t quota_storage_remove_mask,
2216 OriginMatcherFunction origin_matcher,
2217 network::mojom::CookieDeletionFilterPtr cookie_deletion_filter,
2218 bool perform_storage_cleanup,
2219 const base::Time begin,
2220 const base::Time end,
2221 base::OnceClosure callback) {
2222 DCHECK(initialized_);
2223 ClearDataImpl(remove_mask, quota_storage_remove_mask, GURL(),
2224 std::move(origin_matcher), std::move(cookie_deletion_filter),
2225 perform_storage_cleanup, begin, end, std::move(callback));
2226 }
2227
ClearCodeCaches(const base::Time begin,const base::Time end,const base::RepeatingCallback<bool (const GURL &)> & url_matcher,base::OnceClosure callback)2228 void StoragePartitionImpl::ClearCodeCaches(
2229 const base::Time begin,
2230 const base::Time end,
2231 const base::RepeatingCallback<bool(const GURL&)>& url_matcher,
2232 base::OnceClosure callback) {
2233 DCHECK(initialized_);
2234 // StoragePartitionCodeCacheDataRemover deletes itself when it is done.
2235 StoragePartitionCodeCacheDataRemover::Create(this, url_matcher, begin, end)
2236 ->Remove(std::move(callback));
2237 }
2238
Flush()2239 void StoragePartitionImpl::Flush() {
2240 DCHECK_CURRENTLY_ON(BrowserThread::UI);
2241 DCHECK(initialized_);
2242 if (GetDOMStorageContext())
2243 GetDOMStorageContext()->Flush();
2244 }
2245
ResetURLLoaderFactories()2246 void StoragePartitionImpl::ResetURLLoaderFactories() {
2247 DCHECK(initialized_);
2248 GetNetworkContext()->ResetURLLoaderFactories();
2249 url_loader_factory_for_browser_process_.reset();
2250 url_loader_factory_for_browser_process_with_corb_.reset();
2251 url_loader_factory_getter_->Initialize(this);
2252 }
2253
ClearBluetoothAllowedDevicesMapForTesting()2254 void StoragePartitionImpl::ClearBluetoothAllowedDevicesMapForTesting() {
2255 DCHECK(initialized_);
2256 bluetooth_allowed_devices_map_->Clear();
2257 }
2258
AddObserver(DataRemovalObserver * observer)2259 void StoragePartitionImpl::AddObserver(DataRemovalObserver* observer) {
2260 data_removal_observers_.AddObserver(observer);
2261 }
2262
RemoveObserver(DataRemovalObserver * observer)2263 void StoragePartitionImpl::RemoveObserver(DataRemovalObserver* observer) {
2264 data_removal_observers_.RemoveObserver(observer);
2265 }
2266
FlushNetworkInterfaceForTesting()2267 void StoragePartitionImpl::FlushNetworkInterfaceForTesting() {
2268 DCHECK(initialized_);
2269 DCHECK(network_context_);
2270 network_context_.FlushForTesting();
2271 if (url_loader_factory_for_browser_process_)
2272 url_loader_factory_for_browser_process_.FlushForTesting();
2273 if (url_loader_factory_for_browser_process_with_corb_)
2274 url_loader_factory_for_browser_process_with_corb_.FlushForTesting();
2275 if (cookie_manager_for_browser_process_)
2276 cookie_manager_for_browser_process_.FlushForTesting();
2277 if (origin_policy_manager_for_browser_process_)
2278 origin_policy_manager_for_browser_process_.FlushForTesting();
2279 }
2280
WaitForDeletionTasksForTesting()2281 void StoragePartitionImpl::WaitForDeletionTasksForTesting() {
2282 DCHECK(initialized_);
2283 if (deletion_helpers_running_) {
2284 base::RunLoop loop;
2285 on_deletion_helpers_done_callback_ = loop.QuitClosure();
2286 loop.Run();
2287 }
2288 }
2289
WaitForCodeCacheShutdownForTesting()2290 void StoragePartitionImpl::WaitForCodeCacheShutdownForTesting() {
2291 DCHECK(initialized_);
2292 if (generated_code_cache_context_) {
2293 // If this is still running its initialization task it may check
2294 // enabled features on a sequenced worker pool which could race
2295 // between ScopedFeatureList destruction.
2296 base::RunLoop loop;
2297 generated_code_cache_context_->generated_js_code_cache()->GetBackend(
2298 base::BindOnce([](base::OnceClosure quit,
2299 disk_cache::Backend*) { std::move(quit).Run(); },
2300 loop.QuitClosure()));
2301 loop.Run();
2302 generated_code_cache_context_->Shutdown();
2303 }
2304 }
2305
SetNetworkContextForTesting(mojo::PendingRemote<network::mojom::NetworkContext> network_context_remote)2306 void StoragePartitionImpl::SetNetworkContextForTesting(
2307 mojo::PendingRemote<network::mojom::NetworkContext>
2308 network_context_remote) {
2309 network_context_.reset();
2310 network_context_.Bind(std::move(network_context_remote));
2311 }
2312
browser_context() const2313 BrowserContext* StoragePartitionImpl::browser_context() const {
2314 return browser_context_;
2315 }
2316
GetStorageServicePartition()2317 storage::mojom::Partition* StoragePartitionImpl::GetStorageServicePartition() {
2318 if (!remote_partition_) {
2319 base::Optional<base::FilePath> storage_path;
2320 if (!is_in_memory_) {
2321 storage_path =
2322 browser_context_->GetPath().Append(relative_partition_path_);
2323 }
2324 GetStorageServiceRemote()->BindPartition(
2325 storage_path, remote_partition_.BindNewPipeAndPassReceiver());
2326 remote_partition_.set_disconnect_handler(
2327 base::BindOnce(&StoragePartitionImpl::OnStorageServiceDisconnected,
2328 base::Unretained(this)));
2329 }
2330 return remote_partition_.get();
2331 }
2332
2333 // static
2334 mojo::Remote<storage::mojom::StorageService>&
GetStorageServiceForTesting()2335 StoragePartitionImpl::GetStorageServiceForTesting() {
2336 return GetStorageServiceRemote();
2337 }
2338
BindDomStorage(int process_id,mojo::PendingReceiver<blink::mojom::DomStorage> receiver,mojo::PendingRemote<blink::mojom::DomStorageClient> client)2339 mojo::ReceiverId StoragePartitionImpl::BindDomStorage(
2340 int process_id,
2341 mojo::PendingReceiver<blink::mojom::DomStorage> receiver,
2342 mojo::PendingRemote<blink::mojom::DomStorageClient> client) {
2343 DCHECK(initialized_);
2344 auto handle =
2345 ChildProcessSecurityPolicyImpl::GetInstance()->CreateHandle(process_id);
2346 mojo::ReceiverId id = dom_storage_receivers_.Add(
2347 this, std::move(receiver),
2348 std::make_unique<SecurityPolicyHandle>(std::move(handle)));
2349 dom_storage_clients_[id].Bind(std::move(client));
2350 return id;
2351 }
2352
UnbindDomStorage(mojo::ReceiverId receiver_id)2353 void StoragePartitionImpl::UnbindDomStorage(mojo::ReceiverId receiver_id) {
2354 DCHECK(initialized_);
2355 dom_storage_receivers_.Remove(receiver_id);
2356 dom_storage_clients_.erase(receiver_id);
2357 }
2358
OverrideQuotaManagerForTesting(storage::QuotaManager * quota_manager)2359 void StoragePartitionImpl::OverrideQuotaManagerForTesting(
2360 storage::QuotaManager* quota_manager) {
2361 DCHECK(initialized_);
2362 quota_manager_ = quota_manager;
2363 }
2364
OverrideSpecialStoragePolicyForTesting(storage::SpecialStoragePolicy * special_storage_policy)2365 void StoragePartitionImpl::OverrideSpecialStoragePolicyForTesting(
2366 storage::SpecialStoragePolicy* special_storage_policy) {
2367 DCHECK(initialized_);
2368 special_storage_policy_ = special_storage_policy;
2369 }
2370
ShutdownBackgroundSyncContextForTesting()2371 void StoragePartitionImpl::ShutdownBackgroundSyncContextForTesting() {
2372 DCHECK(initialized_);
2373 if (GetBackgroundSyncContext())
2374 GetBackgroundSyncContext()->Shutdown();
2375 }
2376
OverrideBackgroundSyncContextForTesting(BackgroundSyncContextImpl * background_sync_context)2377 void StoragePartitionImpl::OverrideBackgroundSyncContextForTesting(
2378 BackgroundSyncContextImpl* background_sync_context) {
2379 DCHECK(initialized_);
2380 DCHECK(!GetBackgroundSyncContext() ||
2381 !GetBackgroundSyncContext()->background_sync_manager());
2382 background_sync_context_ = background_sync_context;
2383 }
2384
OverrideSharedWorkerServiceForTesting(std::unique_ptr<SharedWorkerServiceImpl> shared_worker_service)2385 void StoragePartitionImpl::OverrideSharedWorkerServiceForTesting(
2386 std::unique_ptr<SharedWorkerServiceImpl> shared_worker_service) {
2387 DCHECK(initialized_);
2388 shared_worker_service_ = std::move(shared_worker_service);
2389 }
2390
GetQuotaSettings(storage::OptionalQuotaSettingsCallback callback)2391 void StoragePartitionImpl::GetQuotaSettings(
2392 storage::OptionalQuotaSettingsCallback callback) {
2393 if (g_test_quota_settings) {
2394 // For debugging tests harness can inject settings.
2395 std::move(callback).Run(*g_test_quota_settings);
2396 return;
2397 }
2398
2399 storage::GetNominalDynamicSettings(
2400 GetPath(), browser_context_->IsOffTheRecord(),
2401 storage::GetDefaultDeviceInfoHelper(), std::move(callback));
2402 }
2403
InitNetworkContext()2404 void StoragePartitionImpl::InitNetworkContext() {
2405 network::mojom::NetworkContextParamsPtr context_params =
2406 network::mojom::NetworkContextParams::New();
2407 network::mojom::CertVerifierCreationParamsPtr cert_verifier_creation_params =
2408 network::mojom::CertVerifierCreationParams::New();
2409 GetContentClient()->browser()->ConfigureNetworkContextParams(
2410 browser_context_, is_in_memory_, relative_partition_path_,
2411 context_params.get(), cert_verifier_creation_params.get());
2412 devtools_instrumentation::ApplyNetworkContextParamsOverrides(
2413 browser_context_, context_params.get());
2414 DCHECK(!context_params->cert_verifier_params)
2415 << "|cert_verifier_params| should not be set in the NetworkContextParams,"
2416 "as they will be replaced with either the newly configured "
2417 "|cert_verifier_creation_params| or with a new pipe to the "
2418 "CertVerifierService.";
2419
2420 context_params->cert_verifier_params =
2421 GetCertVerifierParams(std::move(cert_verifier_creation_params));
2422
2423 // This mechanisms should be used only for legacy internal headers. You can
2424 // find a recommended alternative approach on URLRequest::cors_exempt_headers
2425 // at services/network/public/mojom/url_loader.mojom.
2426 context_params->cors_exempt_header_list.push_back(
2427 kCorsExemptPurposeHeaderName);
2428 context_params->cors_exempt_header_list.push_back(
2429 GetCorsExemptRequestedWithHeaderName());
2430 variations::UpdateCorsExemptHeaderForVariations(context_params.get());
2431
2432 cors_exempt_header_list_ = context_params->cors_exempt_header_list;
2433
2434 network_context_.reset();
2435 GetNetworkService()->CreateNetworkContext(
2436 network_context_.BindNewPipeAndPassReceiver(), std::move(context_params));
2437 DCHECK(network_context_);
2438
2439 network_context_client_receiver_.reset();
2440 network_context_->SetClient(
2441 network_context_client_receiver_.BindNewPipeAndPassRemote());
2442 network_context_.set_disconnect_handler(base::BindOnce(
2443 &StoragePartitionImpl::InitNetworkContext, weak_factory_.GetWeakPtr()));
2444 }
2445
2446 network::mojom::URLLoaderFactory*
GetURLLoaderFactoryForBrowserProcessInternal(bool corb_enabled)2447 StoragePartitionImpl::GetURLLoaderFactoryForBrowserProcessInternal(
2448 bool corb_enabled) {
2449 auto& url_loader_factory =
2450 corb_enabled ? url_loader_factory_for_browser_process_with_corb_
2451 : url_loader_factory_for_browser_process_;
2452 auto& is_test_url_loader_factory =
2453 corb_enabled ? is_test_url_loader_factory_for_browser_process_with_corb_
2454 : is_test_url_loader_factory_for_browser_process_;
2455
2456 // Create the URLLoaderFactory as needed, but make sure not to reuse a
2457 // previously created one if the test override has changed.
2458 if (url_loader_factory && url_loader_factory.is_connected() &&
2459 is_test_url_loader_factory != !GetCreateURLLoaderFactoryCallback()) {
2460 return url_loader_factory.get();
2461 }
2462
2463 network::mojom::URLLoaderFactoryParamsPtr params =
2464 network::mojom::URLLoaderFactoryParams::New();
2465 params->process_id = network::mojom::kBrowserProcessId;
2466 params->automatically_assign_isolation_info = true;
2467 params->is_corb_enabled = corb_enabled;
2468 // Corb requests are likely made on behalf of untrusted renderers.
2469 if (!corb_enabled)
2470 params->is_trusted = true;
2471 params->disable_web_security =
2472 base::CommandLine::ForCurrentProcess()->HasSwitch(
2473 switches::kDisableWebSecurity);
2474 url_loader_factory.reset();
2475 if (!GetCreateURLLoaderFactoryCallback()) {
2476 GetNetworkContext()->CreateURLLoaderFactory(
2477 url_loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
2478 is_test_url_loader_factory = false;
2479 return url_loader_factory.get();
2480 }
2481
2482 mojo::PendingRemote<network::mojom::URLLoaderFactory> original_factory;
2483 GetNetworkContext()->CreateURLLoaderFactory(
2484 original_factory.InitWithNewPipeAndPassReceiver(), std::move(params));
2485 url_loader_factory.Bind(
2486 GetCreateURLLoaderFactoryCallback().Run(std::move(original_factory)));
2487 is_test_url_loader_factory = true;
2488 return url_loader_factory.get();
2489 }
2490
2491 network::mojom::OriginPolicyManager*
GetOriginPolicyManagerForBrowserProcess()2492 StoragePartitionImpl::GetOriginPolicyManagerForBrowserProcess() {
2493 DCHECK(initialized_);
2494 if (!origin_policy_manager_for_browser_process_ ||
2495 !origin_policy_manager_for_browser_process_.is_connected()) {
2496 GetNetworkContext()->GetOriginPolicyManager(
2497 origin_policy_manager_for_browser_process_
2498 .BindNewPipeAndPassReceiver());
2499 }
2500 return origin_policy_manager_for_browser_process_.get();
2501 }
2502
SetOriginPolicyManagerForBrowserProcessForTesting(mojo::PendingRemote<network::mojom::OriginPolicyManager> test_origin_policy_manager)2503 void StoragePartitionImpl::SetOriginPolicyManagerForBrowserProcessForTesting(
2504 mojo::PendingRemote<network::mojom::OriginPolicyManager>
2505 test_origin_policy_manager) {
2506 DCHECK(initialized_);
2507 origin_policy_manager_for_browser_process_.Bind(
2508 std::move(test_origin_policy_manager));
2509 }
2510
2511 void StoragePartitionImpl::
ResetOriginPolicyManagerForBrowserProcessForTesting()2512 ResetOriginPolicyManagerForBrowserProcessForTesting() {
2513 DCHECK(initialized_);
2514 origin_policy_manager_for_browser_process_.reset();
2515 }
2516
SetDefaultQuotaSettingsForTesting(const storage::QuotaSettings * settings)2517 void StoragePartition::SetDefaultQuotaSettingsForTesting(
2518 const storage::QuotaSettings* settings) {
2519 g_test_quota_settings = settings;
2520 }
2521
IsAppCacheEnabled()2522 bool StoragePartition::IsAppCacheEnabled() {
2523 return base::FeatureList::IsEnabled(blink::features::kAppCache);
2524 }
2525
2526 mojo::PendingRemote<network::mojom::CookieAccessObserver>
CreateCookieAccessObserverForServiceWorker()2527 StoragePartitionImpl::CreateCookieAccessObserverForServiceWorker() {
2528 mojo::PendingRemote<network::mojom::CookieAccessObserver> remote;
2529 service_worker_cookie_observers_.Add(
2530 std::make_unique<ServiceWorkerCookieAccessObserver>(this),
2531 remote.InitWithNewPipeAndPassReceiver());
2532 return remote;
2533 }
2534
2535 } // namespace content
2536