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

Side by Side Diff: storage/browser/fileapi/sandbox_prioritized_origin_database.cc

Issue 442383002: Move storage-related files from webkit/ to new top-level directory storage/ (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: . Created 6 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 2013 The Chromium Authors. All rights reserved. 1 // Copyright 2013 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 "webkit/browser/fileapi/sandbox_prioritized_origin_database.h" 5 #include "storage/browser/fileapi/sandbox_prioritized_origin_database.h"
6 6
7 #include "base/file_util.h" 7 #include "base/file_util.h"
8 #include "base/files/file.h" 8 #include "base/files/file.h"
9 #include "base/files/file_path.h" 9 #include "base/files/file_path.h"
10 #include "base/logging.h" 10 #include "base/logging.h"
11 #include "base/pickle.h" 11 #include "base/pickle.h"
12 #include "webkit/browser/fileapi/sandbox_isolated_origin_database.h" 12 #include "storage/browser/fileapi/sandbox_isolated_origin_database.h"
13 #include "webkit/browser/fileapi/sandbox_origin_database.h" 13 #include "storage/browser/fileapi/sandbox_origin_database.h"
14 14
15 namespace fileapi { 15 namespace storage {
16 16
17 namespace { 17 namespace {
18 18
19 const base::FilePath::CharType kPrimaryDirectory[] = 19 const base::FilePath::CharType kPrimaryDirectory[] =
20 FILE_PATH_LITERAL("primary"); 20 FILE_PATH_LITERAL("primary");
21 const base::FilePath::CharType kPrimaryOriginFile[] = 21 const base::FilePath::CharType kPrimaryOriginFile[] =
22 FILE_PATH_LITERAL("primary.origin"); 22 FILE_PATH_LITERAL("primary.origin");
23 23
24 bool WritePrimaryOriginFile(const base::FilePath& path, 24 bool WritePrimaryOriginFile(const base::FilePath& path,
25 const std::string& origin) { 25 const std::string& origin) {
26 base::File file(path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE); 26 base::File file(path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE);
27 if (!file.IsValid()) 27 if (!file.IsValid())
28 return false; 28 return false;
29 if (!file.created()) 29 if (!file.created())
30 file.SetLength(0); 30 file.SetLength(0);
31 Pickle pickle; 31 Pickle pickle;
32 pickle.WriteString(origin); 32 pickle.WriteString(origin);
33 file.Write(0, static_cast<const char*>(pickle.data()), pickle.size()); 33 file.Write(0, static_cast<const char*>(pickle.data()), pickle.size());
34 file.Flush(); 34 file.Flush();
35 return true; 35 return true;
36 } 36 }
37 37
38 bool ReadPrimaryOriginFile(const base::FilePath& path, 38 bool ReadPrimaryOriginFile(const base::FilePath& path, std::string* origin) {
39 std::string* origin) {
40 std::string buffer; 39 std::string buffer;
41 if (!base::ReadFileToString(path, &buffer)) 40 if (!base::ReadFileToString(path, &buffer))
42 return false; 41 return false;
43 Pickle pickle(buffer.data(), buffer.size()); 42 Pickle pickle(buffer.data(), buffer.size());
44 PickleIterator iter(pickle); 43 PickleIterator iter(pickle);
45 return pickle.ReadString(&iter, origin) && !origin->empty(); 44 return pickle.ReadString(&iter, origin) && !origin->empty();
46 } 45 }
47 46
48 } // namespace 47 } // namespace
49 48
50 SandboxPrioritizedOriginDatabase::SandboxPrioritizedOriginDatabase( 49 SandboxPrioritizedOriginDatabase::SandboxPrioritizedOriginDatabase(
51 const base::FilePath& file_system_directory, 50 const base::FilePath& file_system_directory,
52 leveldb::Env* env_override) 51 leveldb::Env* env_override)
53 : file_system_directory_(file_system_directory), 52 : file_system_directory_(file_system_directory),
54 env_override_(env_override), 53 env_override_(env_override),
55 primary_origin_file_( 54 primary_origin_file_(file_system_directory_.Append(kPrimaryOriginFile)) {
56 file_system_directory_.Append(kPrimaryOriginFile)) {
57 } 55 }
58 56
59 SandboxPrioritizedOriginDatabase::~SandboxPrioritizedOriginDatabase() { 57 SandboxPrioritizedOriginDatabase::~SandboxPrioritizedOriginDatabase() {
60 } 58 }
61 59
62 bool SandboxPrioritizedOriginDatabase::InitializePrimaryOrigin( 60 bool SandboxPrioritizedOriginDatabase::InitializePrimaryOrigin(
63 const std::string& origin) { 61 const std::string& origin) {
64 if (!primary_origin_database_) { 62 if (!primary_origin_database_) {
65 if (!MaybeLoadPrimaryOrigin() && ResetPrimaryOrigin(origin)) { 63 if (!MaybeLoadPrimaryOrigin() && ResetPrimaryOrigin(origin)) {
66 MaybeMigrateDatabase(origin); 64 MaybeMigrateDatabase(origin);
67 primary_origin_database_.reset( 65 primary_origin_database_.reset(new SandboxIsolatedOriginDatabase(
68 new SandboxIsolatedOriginDatabase( 66 origin, file_system_directory_, base::FilePath(kPrimaryDirectory)));
69 origin,
70 file_system_directory_,
71 base::FilePath(kPrimaryDirectory)));
72 return true; 67 return true;
73 } 68 }
74 } 69 }
75 70
76 if (primary_origin_database_) 71 if (primary_origin_database_)
77 return primary_origin_database_->HasOriginPath(origin); 72 return primary_origin_database_->HasOriginPath(origin);
78 73
79 return false; 74 return false;
80 } 75 }
81 76
82 std::string SandboxPrioritizedOriginDatabase::GetPrimaryOrigin() { 77 std::string SandboxPrioritizedOriginDatabase::GetPrimaryOrigin() {
83 MaybeLoadPrimaryOrigin(); 78 MaybeLoadPrimaryOrigin();
84 if (primary_origin_database_) 79 if (primary_origin_database_)
85 return primary_origin_database_->origin(); 80 return primary_origin_database_->origin();
86 return std::string(); 81 return std::string();
87 } 82 }
88 83
89 bool SandboxPrioritizedOriginDatabase::HasOriginPath( 84 bool SandboxPrioritizedOriginDatabase::HasOriginPath(
90 const std::string& origin) { 85 const std::string& origin) {
91 MaybeInitializeDatabases(false); 86 MaybeInitializeDatabases(false);
92 if (primary_origin_database_ && 87 if (primary_origin_database_ &&
93 primary_origin_database_->HasOriginPath(origin)) 88 primary_origin_database_->HasOriginPath(origin))
94 return true; 89 return true;
95 if (origin_database_) 90 if (origin_database_)
96 return origin_database_->HasOriginPath(origin); 91 return origin_database_->HasOriginPath(origin);
97 return false; 92 return false;
98 } 93 }
99 94
100 bool SandboxPrioritizedOriginDatabase::GetPathForOrigin( 95 bool SandboxPrioritizedOriginDatabase::GetPathForOrigin(
101 const std::string& origin, base::FilePath* directory) { 96 const std::string& origin,
97 base::FilePath* directory) {
102 MaybeInitializeDatabases(true); 98 MaybeInitializeDatabases(true);
103 if (primary_origin_database_ && 99 if (primary_origin_database_ &&
104 primary_origin_database_->GetPathForOrigin(origin, directory)) 100 primary_origin_database_->GetPathForOrigin(origin, directory))
105 return true; 101 return true;
106 DCHECK(origin_database_); 102 DCHECK(origin_database_);
107 return origin_database_->GetPathForOrigin(origin, directory); 103 return origin_database_->GetPathForOrigin(origin, directory);
108 } 104 }
109 105
110 bool SandboxPrioritizedOriginDatabase::RemovePathForOrigin( 106 bool SandboxPrioritizedOriginDatabase::RemovePathForOrigin(
111 const std::string& origin) { 107 const std::string& origin) {
(...skipping 26 matching lines...) Expand all
138 primary_origin_database_.reset(); 134 primary_origin_database_.reset();
139 origin_database_.reset(); 135 origin_database_.reset();
140 } 136 }
141 137
142 bool SandboxPrioritizedOriginDatabase::MaybeLoadPrimaryOrigin() { 138 bool SandboxPrioritizedOriginDatabase::MaybeLoadPrimaryOrigin() {
143 if (primary_origin_database_) 139 if (primary_origin_database_)
144 return true; 140 return true;
145 std::string saved_origin; 141 std::string saved_origin;
146 if (!ReadPrimaryOriginFile(primary_origin_file_, &saved_origin)) 142 if (!ReadPrimaryOriginFile(primary_origin_file_, &saved_origin))
147 return false; 143 return false;
148 primary_origin_database_.reset( 144 primary_origin_database_.reset(new SandboxIsolatedOriginDatabase(
149 new SandboxIsolatedOriginDatabase( 145 saved_origin, file_system_directory_, base::FilePath(kPrimaryDirectory)));
150 saved_origin,
151 file_system_directory_,
152 base::FilePath(kPrimaryDirectory)));
153 return true; 146 return true;
154 } 147 }
155 148
156 bool SandboxPrioritizedOriginDatabase::ResetPrimaryOrigin( 149 bool SandboxPrioritizedOriginDatabase::ResetPrimaryOrigin(
157 const std::string& origin) { 150 const std::string& origin) {
158 DCHECK(!primary_origin_database_); 151 DCHECK(!primary_origin_database_);
159 if (!WritePrimaryOriginFile(primary_origin_file_, origin)) 152 if (!WritePrimaryOriginFile(primary_origin_file_, origin))
160 return false; 153 return false;
161 // We reset the primary origin directory too. 154 // We reset the primary origin directory too.
162 // (This means the origin file corruption causes data loss 155 // (This means the origin file corruption causes data loss
(...skipping 25 matching lines...) Expand all
188 } 181 }
189 182
190 std::vector<OriginRecord> origins; 183 std::vector<OriginRecord> origins;
191 origin_database_->ListAllOrigins(&origins); 184 origin_database_->ListAllOrigins(&origins);
192 if (origins.empty()) { 185 if (origins.empty()) {
193 origin_database_->RemoveDatabase(); 186 origin_database_->RemoveDatabase();
194 origin_database_.reset(); 187 origin_database_.reset();
195 } 188 }
196 } 189 }
197 190
198 void SandboxPrioritizedOriginDatabase::MaybeInitializeDatabases( 191 void SandboxPrioritizedOriginDatabase::MaybeInitializeDatabases(bool create) {
199 bool create) {
200 MaybeLoadPrimaryOrigin(); 192 MaybeLoadPrimaryOrigin();
201 MaybeInitializeNonPrimaryDatabase(create); 193 MaybeInitializeNonPrimaryDatabase(create);
202 } 194 }
203 195
204 void SandboxPrioritizedOriginDatabase::MaybeInitializeNonPrimaryDatabase( 196 void SandboxPrioritizedOriginDatabase::MaybeInitializeNonPrimaryDatabase(
205 bool create) { 197 bool create) {
206 if (origin_database_) 198 if (origin_database_)
207 return; 199 return;
208 200
209 origin_database_.reset(new SandboxOriginDatabase(file_system_directory_, 201 origin_database_.reset(
210 env_override_)); 202 new SandboxOriginDatabase(file_system_directory_, env_override_));
211 if (!create && !base::DirectoryExists(origin_database_->GetDatabasePath())) { 203 if (!create && !base::DirectoryExists(origin_database_->GetDatabasePath())) {
212 origin_database_.reset(); 204 origin_database_.reset();
213 return; 205 return;
214 } 206 }
215 } 207 }
216 208
217 SandboxOriginDatabase* 209 SandboxOriginDatabase*
218 SandboxPrioritizedOriginDatabase::GetSandboxOriginDatabase() { 210 SandboxPrioritizedOriginDatabase::GetSandboxOriginDatabase() {
219 MaybeInitializeNonPrimaryDatabase(true); 211 MaybeInitializeNonPrimaryDatabase(true);
220 return origin_database_.get(); 212 return origin_database_.get();
221 } 213 }
222 214
223 } // namespace fileapi 215 } // namespace storage
OLDNEW
« no previous file with comments | « storage/browser/fileapi/sandbox_prioritized_origin_database.h ('k') | storage/browser/fileapi/sandbox_quota_observer.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698