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/public/browser/browser_context.h"
6
7#if !defined(OS_IOS)
8#include "content/browser/download/download_manager_impl.h"
9#include "content/browser/fileapi/chrome_blob_storage_context.h"
10#include "content/browser/indexed_db/indexed_db_context_impl.h"
11#include "content/browser/loader/resource_dispatcher_host_impl.h"
12#include "content/browser/push_messaging_router.h"
13#include "content/browser/storage_partition_impl_map.h"
14#include "content/common/child_process_host_impl.h"
15#include "content/public/browser/blob_handle.h"
16#include "content/public/browser/browser_thread.h"
17#include "content/public/browser/content_browser_client.h"
18#include "content/public/browser/site_instance.h"
19#include "net/cookies/cookie_monster.h"
20#include "net/cookies/cookie_store.h"
21#include "net/ssl/channel_id_service.h"
22#include "net/ssl/channel_id_store.h"
23#include "net/url_request/url_request_context.h"
24#include "net/url_request/url_request_context_getter.h"
25#include "storage/browser/database/database_tracker.h"
26#include "storage/browser/fileapi/external_mount_points.h"
27#endif // !OS_IOS
28
29using base::UserDataAdapter;
30
31namespace content {
32
33// Only ~BrowserContext() is needed on iOS.
34#if !defined(OS_IOS)
35namespace {
36
37// Key names on BrowserContext.
38const char kDownloadManagerKeyName[] = "download_manager";
39const char kStorageParitionMapKeyName[] = "content_storage_partition_map";
40
41#if defined(OS_CHROMEOS)
42const char kMountPointsKey[] = "mount_points";
43#endif  // defined(OS_CHROMEOS)
44
45StoragePartitionImplMap* GetStoragePartitionMap(
46    BrowserContext* browser_context) {
47  StoragePartitionImplMap* partition_map =
48      static_cast<StoragePartitionImplMap*>(
49          browser_context->GetUserData(kStorageParitionMapKeyName));
50  if (!partition_map) {
51    partition_map = new StoragePartitionImplMap(browser_context);
52    browser_context->SetUserData(kStorageParitionMapKeyName, partition_map);
53  }
54  return partition_map;
55}
56
57StoragePartition* GetStoragePartitionFromConfig(
58    BrowserContext* browser_context,
59    const std::string& partition_domain,
60    const std::string& partition_name,
61    bool in_memory) {
62  StoragePartitionImplMap* partition_map =
63      GetStoragePartitionMap(browser_context);
64
65  if (browser_context->IsOffTheRecord())
66    in_memory = true;
67
68  return partition_map->Get(partition_domain, partition_name, in_memory);
69}
70
71void SaveSessionStateOnIOThread(
72    const scoped_refptr<net::URLRequestContextGetter>& context_getter,
73    AppCacheServiceImpl* appcache_service) {
74  net::URLRequestContext* context = context_getter->GetURLRequestContext();
75  context->cookie_store()->GetCookieMonster()->
76      SetForceKeepSessionState();
77  context->channel_id_service()->GetChannelIDStore()->
78      SetForceKeepSessionState();
79  appcache_service->set_force_keep_session_state();
80}
81
82void SaveSessionStateOnIndexedDBThread(
83    scoped_refptr<IndexedDBContextImpl> indexed_db_context) {
84  indexed_db_context->SetForceKeepSessionState();
85}
86
87}  // namespace
88
89// static
90void BrowserContext::AsyncObliterateStoragePartition(
91    BrowserContext* browser_context,
92    const GURL& site,
93    const base::Closure& on_gc_required) {
94  GetStoragePartitionMap(browser_context)->AsyncObliterate(site,
95                                                           on_gc_required);
96}
97
98// static
99void BrowserContext::GarbageCollectStoragePartitions(
100      BrowserContext* browser_context,
101      scoped_ptr<base::hash_set<base::FilePath> > active_paths,
102      const base::Closure& done) {
103  GetStoragePartitionMap(browser_context)->GarbageCollect(
104      active_paths.Pass(), done);
105}
106
107DownloadManager* BrowserContext::GetDownloadManager(
108    BrowserContext* context) {
109  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
110  if (!context->GetUserData(kDownloadManagerKeyName)) {
111    ResourceDispatcherHostImpl* rdh = ResourceDispatcherHostImpl::Get();
112    DCHECK(rdh);
113    DownloadManager* download_manager =
114        new DownloadManagerImpl(
115            GetContentClient()->browser()->GetNetLog(), context);
116
117    context->SetUserData(
118        kDownloadManagerKeyName,
119        download_manager);
120    download_manager->SetDelegate(context->GetDownloadManagerDelegate());
121  }
122
123  return static_cast<DownloadManager*>(
124      context->GetUserData(kDownloadManagerKeyName));
125}
126
127// static
128storage::ExternalMountPoints* BrowserContext::GetMountPoints(
129    BrowserContext* context) {
130  // Ensure that these methods are called on the UI thread, except for
131  // unittests where a UI thread might not have been created.
132  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
133         !BrowserThread::IsMessageLoopValid(BrowserThread::UI));
134
135#if defined(OS_CHROMEOS)
136  if (!context->GetUserData(kMountPointsKey)) {
137    scoped_refptr<storage::ExternalMountPoints> mount_points =
138        storage::ExternalMountPoints::CreateRefCounted();
139    context->SetUserData(
140        kMountPointsKey,
141        new UserDataAdapter<storage::ExternalMountPoints>(mount_points.get()));
142  }
143
144  return UserDataAdapter<storage::ExternalMountPoints>::Get(context,
145                                                            kMountPointsKey);
146#else
147  return NULL;
148#endif
149}
150
151StoragePartition* BrowserContext::GetStoragePartition(
152    BrowserContext* browser_context,
153    SiteInstance* site_instance) {
154  std::string partition_domain;
155  std::string partition_name;
156  bool in_memory = false;
157
158  // TODO(ajwong): After GetDefaultStoragePartition() is removed, get rid of
159  // this conditional and require that |site_instance| is non-NULL.
160  if (site_instance) {
161    GetContentClient()->browser()->GetStoragePartitionConfigForSite(
162        browser_context, site_instance->GetSiteURL(), true,
163        &partition_domain, &partition_name, &in_memory);
164  }
165
166  return GetStoragePartitionFromConfig(
167      browser_context, partition_domain, partition_name, in_memory);
168}
169
170StoragePartition* BrowserContext::GetStoragePartitionForSite(
171    BrowserContext* browser_context,
172    const GURL& site) {
173  std::string partition_domain;
174  std::string partition_name;
175  bool in_memory;
176
177  GetContentClient()->browser()->GetStoragePartitionConfigForSite(
178      browser_context, site, true, &partition_domain, &partition_name,
179      &in_memory);
180
181  return GetStoragePartitionFromConfig(
182      browser_context, partition_domain, partition_name, in_memory);
183}
184
185void BrowserContext::ForEachStoragePartition(
186    BrowserContext* browser_context,
187    const StoragePartitionCallback& callback) {
188  StoragePartitionImplMap* partition_map =
189      static_cast<StoragePartitionImplMap*>(
190          browser_context->GetUserData(kStorageParitionMapKeyName));
191  if (!partition_map)
192    return;
193
194  partition_map->ForEach(callback);
195}
196
197StoragePartition* BrowserContext::GetDefaultStoragePartition(
198    BrowserContext* browser_context) {
199  return GetStoragePartition(browser_context, NULL);
200}
201
202void BrowserContext::CreateMemoryBackedBlob(BrowserContext* browser_context,
203                                            const char* data, size_t length,
204                                            const BlobCallback& callback) {
205  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
206
207  ChromeBlobStorageContext* blob_context =
208      ChromeBlobStorageContext::GetFor(browser_context);
209  BrowserThread::PostTaskAndReplyWithResult(
210      BrowserThread::IO, FROM_HERE,
211      base::Bind(&ChromeBlobStorageContext::CreateMemoryBackedBlob,
212                 make_scoped_refptr(blob_context), data, length),
213      callback);
214}
215
216// static
217void BrowserContext::DeliverPushMessage(
218    BrowserContext* browser_context,
219    const GURL& origin,
220    int64 service_worker_registration_id,
221    const std::string& data,
222    const base::Callback<void(PushMessagingStatus)>& callback) {
223  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
224  PushMessagingRouter::DeliverMessage(
225      browser_context, origin, service_worker_registration_id, data, callback);
226}
227
228void BrowserContext::EnsureResourceContextInitialized(BrowserContext* context) {
229  // This will be enough to tickle initialization of BrowserContext if
230  // necessary, which initializes ResourceContext. The reason we don't call
231  // ResourceContext::InitializeResourceContext() directly here is that
232  // ResourceContext initialization may call back into BrowserContext
233  // and when that call returns it'll end rewriting its UserData map. It will
234  // end up rewriting the same value but this still causes a race condition.
235  //
236  // See http://crbug.com/115678.
237  GetDefaultStoragePartition(context);
238}
239
240void BrowserContext::SaveSessionState(BrowserContext* browser_context) {
241  GetDefaultStoragePartition(browser_context)->GetDatabaseTracker()->
242      SetForceKeepSessionState();
243  StoragePartition* storage_partition =
244      BrowserContext::GetDefaultStoragePartition(browser_context);
245
246  if (BrowserThread::IsMessageLoopValid(BrowserThread::IO)) {
247    BrowserThread::PostTask(
248        BrowserThread::IO, FROM_HERE,
249        base::Bind(
250            &SaveSessionStateOnIOThread,
251            make_scoped_refptr(browser_context->GetRequestContext()),
252            static_cast<AppCacheServiceImpl*>(
253                storage_partition->GetAppCacheService())));
254  }
255
256  DOMStorageContextWrapper* dom_storage_context_proxy =
257      static_cast<DOMStorageContextWrapper*>(
258          storage_partition->GetDOMStorageContext());
259  dom_storage_context_proxy->SetForceKeepSessionState();
260
261  IndexedDBContextImpl* indexed_db_context_impl =
262      static_cast<IndexedDBContextImpl*>(
263        storage_partition->GetIndexedDBContext());
264  // No task runner in unit tests.
265  if (indexed_db_context_impl->TaskRunner()) {
266    indexed_db_context_impl->TaskRunner()->PostTask(
267        FROM_HERE,
268        base::Bind(&SaveSessionStateOnIndexedDBThread,
269                   make_scoped_refptr(indexed_db_context_impl)));
270  }
271}
272
273#endif  // !OS_IOS
274
275BrowserContext::~BrowserContext() {
276#if !defined(OS_IOS)
277  if (GetUserData(kDownloadManagerKeyName))
278    GetDownloadManager(this)->Shutdown();
279#endif
280}
281
282}  // namespace content
283