Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(485)

Side by Side Diff: content/browser/dom_storage/dom_storage_context_wrapper.cc

Issue 22297005: Move webkit/{browser,common}/dom_storage into content/ (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 7 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
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
OLDNEW
« no previous file with comments | « content/browser/dom_storage/dom_storage_context_wrapper.h ('k') | content/browser/dom_storage/dom_storage_database.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698