OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/dom_storage/dom_storage_context_impl.h" | 5 #include "content/browser/dom_storage/dom_storage_context_wrapper.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/bind_helpers.h" | 8 #include "base/bind_helpers.h" |
9 #include "base/files/file_path.h" | 9 #include "base/files/file_path.h" |
10 #include "base/message_loop/message_loop_proxy.h" | 10 #include "base/message_loop/message_loop_proxy.h" |
| 11 #include "content/browser/dom_storage/dom_storage_area.h" |
| 12 #include "content/browser/dom_storage/dom_storage_context_impl.h" |
| 13 #include "content/browser/dom_storage/dom_storage_task_runner.h" |
11 #include "content/browser/dom_storage/session_storage_namespace_impl.h" | 14 #include "content/browser/dom_storage/session_storage_namespace_impl.h" |
12 #include "content/public/browser/browser_thread.h" | 15 #include "content/public/browser/browser_thread.h" |
13 #include "webkit/browser/dom_storage/dom_storage_area.h" | 16 #include "content/public/browser/local_storage_usage_info.h" |
14 #include "webkit/browser/dom_storage/dom_storage_context.h" | 17 #include "content/public/browser/session_storage_usage_info.h" |
15 #include "webkit/browser/dom_storage/dom_storage_task_runner.h" | |
16 | |
17 using dom_storage::DomStorageArea; | |
18 using dom_storage::DomStorageContext; | |
19 using dom_storage::DomStorageTaskRunner; | |
20 using dom_storage::DomStorageWorkerPoolTaskRunner; | |
21 | 18 |
22 namespace content { | 19 namespace content { |
23 namespace { | 20 namespace { |
24 | 21 |
25 const char kLocalStorageDirectory[] = "Local Storage"; | 22 const char kLocalStorageDirectory[] = "Local Storage"; |
26 const char kSessionStorageDirectory[] = "Session Storage"; | 23 const char kSessionStorageDirectory[] = "Session Storage"; |
27 | 24 |
28 void InvokeLocalStorageUsageCallbackHelper( | 25 void InvokeLocalStorageUsageCallbackHelper( |
29 const DOMStorageContext::GetLocalStorageUsageCallback& callback, | 26 const DOMStorageContext::GetLocalStorageUsageCallback& callback, |
30 const std::vector<dom_storage::LocalStorageUsageInfo>* infos) { | 27 const std::vector<LocalStorageUsageInfo>* infos) { |
31 callback.Run(*infos); | 28 callback.Run(*infos); |
32 } | 29 } |
33 | 30 |
34 void GetLocalStorageUsageHelper( | 31 void GetLocalStorageUsageHelper( |
35 base::MessageLoopProxy* reply_loop, | 32 base::MessageLoopProxy* reply_loop, |
36 DomStorageContext* context, | 33 DOMStorageContextImpl* context, |
37 const DOMStorageContext::GetLocalStorageUsageCallback& callback) { | 34 const DOMStorageContext::GetLocalStorageUsageCallback& callback) { |
38 std::vector<dom_storage::LocalStorageUsageInfo>* infos = | 35 std::vector<LocalStorageUsageInfo>* infos = |
39 new std::vector<dom_storage::LocalStorageUsageInfo>; | 36 new std::vector<LocalStorageUsageInfo>; |
40 context->GetLocalStorageUsage(infos, true); | 37 context->GetLocalStorageUsage(infos, true); |
41 reply_loop->PostTask( | 38 reply_loop->PostTask( |
42 FROM_HERE, | 39 FROM_HERE, |
43 base::Bind(&InvokeLocalStorageUsageCallbackHelper, | 40 base::Bind(&InvokeLocalStorageUsageCallbackHelper, |
44 callback, base::Owned(infos))); | 41 callback, base::Owned(infos))); |
45 } | 42 } |
46 | 43 |
47 void InvokeSessionStorageUsageCallbackHelper( | 44 void InvokeSessionStorageUsageCallbackHelper( |
48 const DOMStorageContext::GetSessionStorageUsageCallback& callback, | 45 const DOMStorageContext::GetSessionStorageUsageCallback& callback, |
49 const std::vector<dom_storage::SessionStorageUsageInfo>* infos) { | 46 const std::vector<SessionStorageUsageInfo>* infos) { |
50 callback.Run(*infos); | 47 callback.Run(*infos); |
51 } | 48 } |
52 | 49 |
53 void GetSessionStorageUsageHelper( | 50 void GetSessionStorageUsageHelper( |
54 base::MessageLoopProxy* reply_loop, | 51 base::MessageLoopProxy* reply_loop, |
55 DomStorageContext* context, | 52 DOMStorageContextImpl* context, |
56 const DOMStorageContext::GetSessionStorageUsageCallback& callback) { | 53 const DOMStorageContext::GetSessionStorageUsageCallback& callback) { |
57 std::vector<dom_storage::SessionStorageUsageInfo>* infos = | 54 std::vector<SessionStorageUsageInfo>* infos = |
58 new std::vector<dom_storage::SessionStorageUsageInfo>; | 55 new std::vector<SessionStorageUsageInfo>; |
59 context->GetSessionStorageUsage(infos); | 56 context->GetSessionStorageUsage(infos); |
60 reply_loop->PostTask( | 57 reply_loop->PostTask( |
61 FROM_HERE, | 58 FROM_HERE, |
62 base::Bind(&InvokeSessionStorageUsageCallbackHelper, | 59 base::Bind(&InvokeSessionStorageUsageCallbackHelper, |
63 callback, base::Owned(infos))); | 60 callback, base::Owned(infos))); |
64 } | 61 } |
65 | 62 |
66 } // namespace | 63 } // namespace |
67 | 64 |
68 DOMStorageContextImpl::DOMStorageContextImpl( | 65 DOMStorageContextWrapper::DOMStorageContextWrapper( |
69 const base::FilePath& data_path, | 66 const base::FilePath& data_path, |
70 quota::SpecialStoragePolicy* special_storage_policy) { | 67 quota::SpecialStoragePolicy* special_storage_policy) { |
71 base::SequencedWorkerPool* worker_pool = BrowserThread::GetBlockingPool(); | 68 base::SequencedWorkerPool* worker_pool = BrowserThread::GetBlockingPool(); |
72 context_ = new dom_storage::DomStorageContext( | 69 context_ = new DOMStorageContextImpl( |
73 data_path.empty() ? data_path | 70 data_path.empty() ? data_path |
74 : data_path.AppendASCII(kLocalStorageDirectory), | 71 : data_path.AppendASCII(kLocalStorageDirectory), |
75 data_path.empty() ? data_path | 72 data_path.empty() ? data_path |
76 : data_path.AppendASCII(kSessionStorageDirectory), | 73 : data_path.AppendASCII(kSessionStorageDirectory), |
77 special_storage_policy, | 74 special_storage_policy, |
78 new DomStorageWorkerPoolTaskRunner( | 75 new DOMStorageWorkerPoolTaskRunner( |
79 worker_pool, | 76 worker_pool, |
80 worker_pool->GetNamedSequenceToken("dom_storage_primary"), | 77 worker_pool->GetNamedSequenceToken("dom_storage_primary"), |
81 worker_pool->GetNamedSequenceToken("dom_storage_commit"), | 78 worker_pool->GetNamedSequenceToken("dom_storage_commit"), |
82 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO) | 79 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO) |
83 .get())); | 80 .get())); |
84 } | 81 } |
85 | 82 |
86 DOMStorageContextImpl::~DOMStorageContextImpl() { | 83 DOMStorageContextWrapper::~DOMStorageContextWrapper() { |
87 } | 84 } |
88 | 85 |
89 void DOMStorageContextImpl::GetLocalStorageUsage( | 86 void DOMStorageContextWrapper::GetLocalStorageUsage( |
90 const GetLocalStorageUsageCallback& callback) { | 87 const GetLocalStorageUsageCallback& callback) { |
91 DCHECK(context_.get()); | 88 DCHECK(context_.get()); |
92 context_->task_runner() | 89 context_->task_runner() |
93 ->PostShutdownBlockingTask(FROM_HERE, | 90 ->PostShutdownBlockingTask(FROM_HERE, |
94 DomStorageTaskRunner::PRIMARY_SEQUENCE, | 91 DOMStorageTaskRunner::PRIMARY_SEQUENCE, |
95 base::Bind(&GetLocalStorageUsageHelper, | 92 base::Bind(&GetLocalStorageUsageHelper, |
96 base::MessageLoopProxy::current(), | 93 base::MessageLoopProxy::current(), |
97 context_, | 94 context_, |
98 callback)); | 95 callback)); |
99 } | 96 } |
100 | 97 |
101 void DOMStorageContextImpl::GetSessionStorageUsage( | 98 void DOMStorageContextWrapper::GetSessionStorageUsage( |
102 const GetSessionStorageUsageCallback& callback) { | 99 const GetSessionStorageUsageCallback& callback) { |
103 DCHECK(context_.get()); | 100 DCHECK(context_.get()); |
104 context_->task_runner() | 101 context_->task_runner() |
105 ->PostShutdownBlockingTask(FROM_HERE, | 102 ->PostShutdownBlockingTask(FROM_HERE, |
106 DomStorageTaskRunner::PRIMARY_SEQUENCE, | 103 DOMStorageTaskRunner::PRIMARY_SEQUENCE, |
107 base::Bind(&GetSessionStorageUsageHelper, | 104 base::Bind(&GetSessionStorageUsageHelper, |
108 base::MessageLoopProxy::current(), | 105 base::MessageLoopProxy::current(), |
109 context_, | 106 context_, |
110 callback)); | 107 callback)); |
111 } | 108 } |
112 | 109 |
113 void DOMStorageContextImpl::DeleteLocalStorage(const GURL& origin) { | 110 void DOMStorageContextWrapper::DeleteLocalStorage(const GURL& origin) { |
114 DCHECK(context_.get()); | 111 DCHECK(context_.get()); |
115 context_->task_runner()->PostShutdownBlockingTask( | 112 context_->task_runner()->PostShutdownBlockingTask( |
116 FROM_HERE, | 113 FROM_HERE, |
117 DomStorageTaskRunner::PRIMARY_SEQUENCE, | 114 DOMStorageTaskRunner::PRIMARY_SEQUENCE, |
118 base::Bind(&DomStorageContext::DeleteLocalStorage, context_, origin)); | 115 base::Bind(&DOMStorageContextImpl::DeleteLocalStorage, context_, origin)); |
119 } | 116 } |
120 | 117 |
121 void DOMStorageContextImpl::DeleteSessionStorage( | 118 void DOMStorageContextWrapper::DeleteSessionStorage( |
122 const dom_storage::SessionStorageUsageInfo& usage_info) { | 119 const SessionStorageUsageInfo& usage_info) { |
123 DCHECK(context_.get()); | 120 DCHECK(context_.get()); |
124 context_->task_runner()->PostShutdownBlockingTask( | 121 context_->task_runner()->PostShutdownBlockingTask( |
125 FROM_HERE, | 122 FROM_HERE, |
126 DomStorageTaskRunner::PRIMARY_SEQUENCE, | 123 DOMStorageTaskRunner::PRIMARY_SEQUENCE, |
127 base::Bind( | 124 base::Bind(&DOMStorageContextImpl::DeleteSessionStorage, |
128 &DomStorageContext::DeleteSessionStorage, context_, usage_info)); | 125 context_, usage_info)); |
129 } | 126 } |
130 | 127 |
131 void DOMStorageContextImpl::SetSaveSessionStorageOnDisk() { | 128 void DOMStorageContextWrapper::SetSaveSessionStorageOnDisk() { |
132 DCHECK(context_.get()); | 129 DCHECK(context_.get()); |
133 context_->SetSaveSessionStorageOnDisk(); | 130 context_->SetSaveSessionStorageOnDisk(); |
134 } | 131 } |
135 | 132 |
136 scoped_refptr<SessionStorageNamespace> | 133 scoped_refptr<SessionStorageNamespace> |
137 DOMStorageContextImpl::RecreateSessionStorage( | 134 DOMStorageContextWrapper::RecreateSessionStorage( |
138 const std::string& persistent_id) { | 135 const std::string& persistent_id) { |
139 return scoped_refptr<SessionStorageNamespace>( | 136 return scoped_refptr<SessionStorageNamespace>( |
140 new SessionStorageNamespaceImpl(this, persistent_id)); | 137 new SessionStorageNamespaceImpl(this, persistent_id)); |
141 } | 138 } |
142 | 139 |
143 void DOMStorageContextImpl::StartScavengingUnusedSessionStorage() { | 140 void DOMStorageContextWrapper::StartScavengingUnusedSessionStorage() { |
144 DCHECK(context_.get()); | 141 DCHECK(context_.get()); |
145 context_->task_runner()->PostShutdownBlockingTask( | 142 context_->task_runner()->PostShutdownBlockingTask( |
146 FROM_HERE, | 143 FROM_HERE, |
147 DomStorageTaskRunner::PRIMARY_SEQUENCE, | 144 DOMStorageTaskRunner::PRIMARY_SEQUENCE, |
148 base::Bind(&DomStorageContext::StartScavengingUnusedSessionStorage, | 145 base::Bind(&DOMStorageContextImpl::StartScavengingUnusedSessionStorage, |
149 context_)); | 146 context_)); |
150 } | 147 } |
151 | 148 |
152 void DOMStorageContextImpl::PurgeMemory() { | 149 void DOMStorageContextWrapper::PurgeMemory() { |
153 DCHECK(context_.get()); | 150 DCHECK(context_.get()); |
154 context_->task_runner()->PostShutdownBlockingTask( | 151 context_->task_runner()->PostShutdownBlockingTask( |
155 FROM_HERE, | 152 FROM_HERE, |
156 DomStorageTaskRunner::PRIMARY_SEQUENCE, | 153 DOMStorageTaskRunner::PRIMARY_SEQUENCE, |
157 base::Bind(&DomStorageContext::PurgeMemory, context_)); | 154 base::Bind(&DOMStorageContextImpl::PurgeMemory, context_)); |
158 } | 155 } |
159 | 156 |
160 void DOMStorageContextImpl::SetForceKeepSessionState() { | 157 void DOMStorageContextWrapper::SetForceKeepSessionState() { |
161 DCHECK(context_.get()); | 158 DCHECK(context_.get()); |
162 context_->task_runner()->PostShutdownBlockingTask( | 159 context_->task_runner()->PostShutdownBlockingTask( |
163 FROM_HERE, | 160 FROM_HERE, |
164 DomStorageTaskRunner::PRIMARY_SEQUENCE, | 161 DOMStorageTaskRunner::PRIMARY_SEQUENCE, |
165 base::Bind(&DomStorageContext::SetForceKeepSessionState, context_)); | 162 base::Bind(&DOMStorageContextImpl::SetForceKeepSessionState, context_)); |
166 } | 163 } |
167 | 164 |
168 void DOMStorageContextImpl::Shutdown() { | 165 void DOMStorageContextWrapper::Shutdown() { |
169 DCHECK(context_.get()); | 166 DCHECK(context_.get()); |
170 context_->task_runner()->PostShutdownBlockingTask( | 167 context_->task_runner()->PostShutdownBlockingTask( |
171 FROM_HERE, | 168 FROM_HERE, |
172 DomStorageTaskRunner::PRIMARY_SEQUENCE, | 169 DOMStorageTaskRunner::PRIMARY_SEQUENCE, |
173 base::Bind(&DomStorageContext::Shutdown, context_)); | 170 base::Bind(&DOMStorageContextImpl::Shutdown, context_)); |
174 } | 171 } |
175 | 172 |
176 } // namespace content | 173 } // namespace content |
OLD | NEW |