1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_DOM_STORAGE_DOM_STORAGE_CONTEXT_WRAPPER_H_
#define CONTENT_BROWSER_DOM_STORAGE_DOM_STORAGE_CONTEXT_WRAPPER_H_
#include <map>
#include <string>
#include "base/macros.h"
#include "base/memory/memory_coordinator_client.h"
#include "base/memory/memory_pressure_listener.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/synchronization/lock.h"
#include "content/browser/dom_storage/dom_storage_context_impl.h"
#include "content/common/content_export.h"
#include "content/common/storage_partition_service.mojom.h"
#include "content/public/browser/dom_storage_context.h"
#include "url/origin.h"
namespace base {
class FilePath;
}
namespace service_manager {
class Connector;
}
namespace storage {
class SpecialStoragePolicy;
}
namespace content {
class DOMStorageContextImpl;
class LocalStorageContextMojo;
class SessionStorageContextMojo;
class SessionStorageNamespaceImpl;
// This is owned by Storage Partition and encapsulates all its dom storage
// state.
class CONTENT_EXPORT DOMStorageContextWrapper
: public DOMStorageContext,
public base::RefCountedThreadSafe<DOMStorageContextWrapper>,
public base::MemoryCoordinatorClient {
public:
// If |data_path| is empty, nothing will be saved to disk.
DOMStorageContextWrapper(
service_manager::Connector* connector,
const base::FilePath& data_path,
const base::FilePath& local_partition_path,
storage::SpecialStoragePolicy* special_storage_policy);
// DOMStorageContext implementation.
void GetLocalStorageUsage(
const GetLocalStorageUsageCallback& callback) override;
void GetSessionStorageUsage(GetSessionStorageUsageCallback callback) override;
void DeleteLocalStorage(const GURL& origin,
base::OnceClosure callback) override;
void DeleteSessionStorage(const SessionStorageUsageInfo& usage_info) override;
void SetSaveSessionStorageOnDisk() override;
scoped_refptr<SessionStorageNamespace> RecreateSessionStorage(
const std::string& namespace_id) override;
void StartScavengingUnusedSessionStorage() override;
// Used by content settings to alter the behavior around
// what data to keep and what data to discard at shutdown.
// The policy is not so straight forward to describe, see
// the implementation for details.
void SetForceKeepSessionState();
// Called when the BrowserContext/Profile is going away.
void Shutdown();
void Flush();
// See mojom::StoragePartitionService interface.
void OpenLocalStorage(const url::Origin& origin,
mojom::LevelDBWrapperRequest request);
void OpenSessionStorage(int process_id,
const std::string& namespace_id,
mojom::SessionStorageNamespaceRequest request);
void SetLocalStorageDatabaseForTesting(
leveldb::mojom::LevelDBDatabaseAssociatedPtr database);
SessionStorageContextMojo* mojo_session_state() {
return mojo_session_state_;
}
private:
friend class DOMStorageMessageFilter; // for access to context()
friend class SessionStorageNamespaceImpl; // ditto
friend class base::RefCountedThreadSafe<DOMStorageContextWrapper>;
friend class DOMStorageBrowserTest;
~DOMStorageContextWrapper() override;
DOMStorageContextImpl* context() const { return context_.get(); }
base::SequencedTaskRunner* mojo_task_runner() {
return mojo_task_runner_.get();
}
scoped_refptr<SessionStorageNamespaceImpl> MaybeGetExistingNamespace(
const std::string& namespace_id) const;
// Note: can be called on multiple threads, protected by a mutex.
void AddNamespace(const std::string& namespace_id,
SessionStorageNamespaceImpl* session_namespace);
// Note: can be called on multiple threads, protected by a mutex.
void RemoveNamespace(const std::string& namespace_id);
// Called on UI thread when the system is under memory pressure.
void OnMemoryPressure(
base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
// base::MemoryCoordinatorClient implementation:
void OnPurgeMemory() override;
void PurgeMemory(DOMStorageContextImpl::PurgeOption purge_option);
// Keep all mojo-ish details together and not bleed them through the public
// interface. The |mojo_state_| object is owned by this object, but destroyed
// asynchronously on the |mojo_task_runner_|.
LocalStorageContextMojo* mojo_state_ = nullptr;
SessionStorageContextMojo* mojo_session_state_ = nullptr;
scoped_refptr<base::SequencedTaskRunner> mojo_task_runner_;
// Since the tab restore code keeps a reference to the session namespaces
// of recently closed tabs (see sessions::ContentPlatformSpecificTabData and
// sessions::TabRestoreService), a SessionStorageNamespaceImpl can outlive the
// destruction of the browser window. A session restore can also happen
// without the browser context being shutdown or destroyed in between. The
// design of SessionStorageNamespaceImpl assumes there is only one object per
// namespace. A session restore creates new objects for all tabs while the
// Profile wasn't destructed. This map allows the restored session to re-use
// the SessionStorageNamespaceImpl objects that are still alive thanks to the
// sessions component.
std::map<std::string, SessionStorageNamespaceImpl*> alive_namespaces_;
mutable base::Lock alive_namespaces_lock_;
base::FilePath legacy_localstorage_path_;
// To receive memory pressure signals.
std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_;
scoped_refptr<DOMStorageContextImpl> context_;
DISALLOW_IMPLICIT_CONSTRUCTORS(DOMStorageContextWrapper);
};
} // namespace content
#endif // CONTENT_BROWSER_DOM_STORAGE_DOM_STORAGE_CONTEXT_WRAPPER_H_
|
