| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/chromeos/drive/resource_metadata_storage.h" | |
| 6 | |
| 7 #include <map> | |
| 8 #include <set> | |
| 9 | |
| 10 #include "base/bind.h" | |
| 11 #include "base/containers/hash_tables.h" | |
| 12 #include "base/files/file_util.h" | |
| 13 #include "base/location.h" | |
| 14 #include "base/logging.h" | |
| 15 #include "base/metrics/histogram.h" | |
| 16 #include "base/metrics/sparse_histogram.h" | |
| 17 #include "base/sequenced_task_runner.h" | |
| 18 #include "base/threading/thread_restrictions.h" | |
| 19 #include "components/drive/drive.pb.h" | |
| 20 #include "components/drive/drive_api_util.h" | |
| 21 #include "third_party/leveldatabase/env_chromium.h" | |
| 22 #include "third_party/leveldatabase/src/include/leveldb/db.h" | |
| 23 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h" | |
| 24 | |
| 25 namespace drive { | |
| 26 namespace internal { | |
| 27 | |
| 28 namespace { | |
| 29 | |
| 30 // Enum to describe DB initialization status. | |
| 31 enum DBInitStatus { | |
| 32 DB_INIT_SUCCESS, | |
| 33 DB_INIT_NOT_FOUND, | |
| 34 DB_INIT_CORRUPTION, | |
| 35 DB_INIT_IO_ERROR, | |
| 36 DB_INIT_FAILED, | |
| 37 DB_INIT_INCOMPATIBLE, | |
| 38 DB_INIT_BROKEN, | |
| 39 DB_INIT_OPENED_EXISTING_DB, | |
| 40 DB_INIT_CREATED_NEW_DB, | |
| 41 DB_INIT_REPLACED_EXISTING_DB_WITH_NEW_DB, | |
| 42 DB_INIT_MAX_VALUE, | |
| 43 }; | |
| 44 | |
| 45 // Enum to describe DB validity check failure reason. | |
| 46 enum CheckValidityFailureReason { | |
| 47 CHECK_VALIDITY_FAILURE_INVALID_HEADER, | |
| 48 CHECK_VALIDITY_FAILURE_BROKEN_ID_ENTRY, | |
| 49 CHECK_VALIDITY_FAILURE_BROKEN_ENTRY, | |
| 50 CHECK_VALIDITY_FAILURE_INVALID_LOCAL_ID, | |
| 51 CHECK_VALIDITY_FAILURE_INVALID_PARENT_ID, | |
| 52 CHECK_VALIDITY_FAILURE_BROKEN_CHILD_MAP, | |
| 53 CHECK_VALIDITY_FAILURE_CHILD_ENTRY_COUNT_MISMATCH, | |
| 54 CHECK_VALIDITY_FAILURE_ITERATOR_ERROR, | |
| 55 CHECK_VALIDITY_FAILURE_MAX_VALUE, | |
| 56 }; | |
| 57 | |
| 58 // The name of the DB which stores the metadata. | |
| 59 const base::FilePath::CharType kResourceMapDBName[] = | |
| 60 FILE_PATH_LITERAL("resource_metadata_resource_map.db"); | |
| 61 | |
| 62 // The name of the DB which couldn't be opened, but is preserved just in case. | |
| 63 const base::FilePath::CharType kPreservedResourceMapDBName[] = | |
| 64 FILE_PATH_LITERAL("resource_metadata_preserved_resource_map.db"); | |
| 65 | |
| 66 // The name of the DB which couldn't be opened, and was replaced with a new one. | |
| 67 const base::FilePath::CharType kTrashedResourceMapDBName[] = | |
| 68 FILE_PATH_LITERAL("resource_metadata_trashed_resource_map.db"); | |
| 69 | |
| 70 // Meant to be a character which never happen to be in real IDs. | |
| 71 const char kDBKeyDelimeter = '\0'; | |
| 72 | |
| 73 // String used as a suffix of a key for a cache entry. | |
| 74 const char kCacheEntryKeySuffix[] = "CACHE"; | |
| 75 | |
| 76 // String used as a prefix of a key for a resource-ID-to-local-ID entry. | |
| 77 const char kIdEntryKeyPrefix[] = "ID"; | |
| 78 | |
| 79 // Returns a string to be used as the key for the header. | |
| 80 std::string GetHeaderDBKey() { | |
| 81 std::string key; | |
| 82 key.push_back(kDBKeyDelimeter); | |
| 83 key.append("HEADER"); | |
| 84 return key; | |
| 85 } | |
| 86 | |
| 87 // Returns true if |key| is a key for a child entry. | |
| 88 bool IsChildEntryKey(const leveldb::Slice& key) { | |
| 89 return !key.empty() && key[key.size() - 1] == kDBKeyDelimeter; | |
| 90 } | |
| 91 | |
| 92 // Returns true if |key| is a key for a cache entry. | |
| 93 bool IsCacheEntryKey(const leveldb::Slice& key) { | |
| 94 // A cache entry key should end with |kDBKeyDelimeter + kCacheEntryKeySuffix|. | |
| 95 const leveldb::Slice expected_suffix(kCacheEntryKeySuffix, | |
| 96 arraysize(kCacheEntryKeySuffix) - 1); | |
| 97 if (key.size() < 1 + expected_suffix.size() || | |
| 98 key[key.size() - expected_suffix.size() - 1] != kDBKeyDelimeter) | |
| 99 return false; | |
| 100 | |
| 101 const leveldb::Slice key_substring( | |
| 102 key.data() + key.size() - expected_suffix.size(), expected_suffix.size()); | |
| 103 return key_substring.compare(expected_suffix) == 0; | |
| 104 } | |
| 105 | |
| 106 // Returns ID extracted from a cache entry key. | |
| 107 std::string GetIdFromCacheEntryKey(const leveldb::Slice& key) { | |
| 108 DCHECK(IsCacheEntryKey(key)); | |
| 109 // Drop the suffix |kDBKeyDelimeter + kCacheEntryKeySuffix| from the key. | |
| 110 const size_t kSuffixLength = arraysize(kCacheEntryKeySuffix) - 1; | |
| 111 const int id_length = key.size() - 1 - kSuffixLength; | |
| 112 return std::string(key.data(), id_length); | |
| 113 } | |
| 114 | |
| 115 // Returns a string to be used as a key for a resource-ID-to-local-ID entry. | |
| 116 std::string GetIdEntryKey(const std::string& resource_id) { | |
| 117 std::string key; | |
| 118 key.push_back(kDBKeyDelimeter); | |
| 119 key.append(kIdEntryKeyPrefix); | |
| 120 key.push_back(kDBKeyDelimeter); | |
| 121 key.append(resource_id); | |
| 122 return key; | |
| 123 } | |
| 124 | |
| 125 // Returns true if |key| is a key for a resource-ID-to-local-ID entry. | |
| 126 bool IsIdEntryKey(const leveldb::Slice& key) { | |
| 127 // A resource-ID-to-local-ID entry key should start with | |
| 128 // |kDBKeyDelimeter + kIdEntryKeyPrefix + kDBKeyDelimeter|. | |
| 129 const leveldb::Slice expected_prefix(kIdEntryKeyPrefix, | |
| 130 arraysize(kIdEntryKeyPrefix) - 1); | |
| 131 if (key.size() < 2 + expected_prefix.size()) | |
| 132 return false; | |
| 133 const leveldb::Slice key_substring(key.data() + 1, expected_prefix.size()); | |
| 134 return key[0] == kDBKeyDelimeter && | |
| 135 key_substring.compare(expected_prefix) == 0 && | |
| 136 key[expected_prefix.size() + 1] == kDBKeyDelimeter; | |
| 137 } | |
| 138 | |
| 139 // Returns the resource ID extracted from a resource-ID-to-local-ID entry key. | |
| 140 std::string GetResourceIdFromIdEntryKey(const leveldb::Slice& key) { | |
| 141 DCHECK(IsIdEntryKey(key)); | |
| 142 // Drop the prefix |kDBKeyDelimeter + kIdEntryKeyPrefix + kDBKeyDelimeter| | |
| 143 // from the key. | |
| 144 const size_t kPrefixLength = arraysize(kIdEntryKeyPrefix) - 1; | |
| 145 const int offset = kPrefixLength + 2; | |
| 146 return std::string(key.data() + offset, key.size() - offset); | |
| 147 } | |
| 148 | |
| 149 // Converts leveldb::Status to DBInitStatus. | |
| 150 DBInitStatus LevelDBStatusToDBInitStatus(const leveldb::Status& status) { | |
| 151 if (status.ok()) | |
| 152 return DB_INIT_SUCCESS; | |
| 153 if (status.IsNotFound()) | |
| 154 return DB_INIT_NOT_FOUND; | |
| 155 if (status.IsCorruption()) | |
| 156 return DB_INIT_CORRUPTION; | |
| 157 if (status.IsIOError()) | |
| 158 return DB_INIT_IO_ERROR; | |
| 159 return DB_INIT_FAILED; | |
| 160 } | |
| 161 | |
| 162 // Converts leveldb::Status to FileError. | |
| 163 FileError LevelDBStatusToFileError(const leveldb::Status& status) { | |
| 164 if (status.ok()) | |
| 165 return FILE_ERROR_OK; | |
| 166 if (status.IsNotFound()) | |
| 167 return FILE_ERROR_NOT_FOUND; | |
| 168 if (leveldb_env::IndicatesDiskFull(status)) | |
| 169 return FILE_ERROR_NO_LOCAL_SPACE; | |
| 170 return FILE_ERROR_FAILED; | |
| 171 } | |
| 172 | |
| 173 ResourceMetadataHeader GetDefaultHeaderEntry() { | |
| 174 ResourceMetadataHeader header; | |
| 175 header.set_version(ResourceMetadataStorage::kDBVersion); | |
| 176 return header; | |
| 177 } | |
| 178 | |
| 179 bool MoveIfPossible(const base::FilePath& from, const base::FilePath& to) { | |
| 180 return !base::PathExists(from) || base::Move(from, to); | |
| 181 } | |
| 182 | |
| 183 void RecordCheckValidityFailure(CheckValidityFailureReason reason) { | |
| 184 UMA_HISTOGRAM_ENUMERATION("Drive.MetadataDBValidityCheckFailureReason", | |
| 185 reason, | |
| 186 CHECK_VALIDITY_FAILURE_MAX_VALUE); | |
| 187 } | |
| 188 | |
| 189 } // namespace | |
| 190 | |
| 191 ResourceMetadataStorage::Iterator::Iterator(scoped_ptr<leveldb::Iterator> it) | |
| 192 : it_(it.Pass()) { | |
| 193 base::ThreadRestrictions::AssertIOAllowed(); | |
| 194 DCHECK(it_); | |
| 195 | |
| 196 // Skip the header entry. | |
| 197 // Note: The header entry comes before all other entries because its key | |
| 198 // starts with kDBKeyDelimeter. (i.e. '\0') | |
| 199 it_->Seek(leveldb::Slice(GetHeaderDBKey())); | |
| 200 | |
| 201 Advance(); | |
| 202 } | |
| 203 | |
| 204 ResourceMetadataStorage::Iterator::~Iterator() { | |
| 205 base::ThreadRestrictions::AssertIOAllowed(); | |
| 206 } | |
| 207 | |
| 208 bool ResourceMetadataStorage::Iterator::IsAtEnd() const { | |
| 209 base::ThreadRestrictions::AssertIOAllowed(); | |
| 210 return !it_->Valid(); | |
| 211 } | |
| 212 | |
| 213 std::string ResourceMetadataStorage::Iterator::GetID() const { | |
| 214 return it_->key().ToString(); | |
| 215 } | |
| 216 | |
| 217 const ResourceEntry& ResourceMetadataStorage::Iterator::GetValue() const { | |
| 218 base::ThreadRestrictions::AssertIOAllowed(); | |
| 219 DCHECK(!IsAtEnd()); | |
| 220 return entry_; | |
| 221 } | |
| 222 | |
| 223 void ResourceMetadataStorage::Iterator::Advance() { | |
| 224 base::ThreadRestrictions::AssertIOAllowed(); | |
| 225 DCHECK(!IsAtEnd()); | |
| 226 | |
| 227 for (it_->Next() ; it_->Valid(); it_->Next()) { | |
| 228 if (!IsChildEntryKey(it_->key()) && | |
| 229 !IsIdEntryKey(it_->key()) && | |
| 230 entry_.ParseFromArray(it_->value().data(), it_->value().size())) { | |
| 231 break; | |
| 232 } | |
| 233 } | |
| 234 } | |
| 235 | |
| 236 bool ResourceMetadataStorage::Iterator::HasError() const { | |
| 237 base::ThreadRestrictions::AssertIOAllowed(); | |
| 238 return !it_->status().ok(); | |
| 239 } | |
| 240 | |
| 241 // static | |
| 242 bool ResourceMetadataStorage::UpgradeOldDB( | |
| 243 const base::FilePath& directory_path) { | |
| 244 base::ThreadRestrictions::AssertIOAllowed(); | |
| 245 static_assert( | |
| 246 kDBVersion == 13, | |
| 247 "database version and this function must be updated at the same time"); | |
| 248 | |
| 249 const base::FilePath resource_map_path = | |
| 250 directory_path.Append(kResourceMapDBName); | |
| 251 const base::FilePath preserved_resource_map_path = | |
| 252 directory_path.Append(kPreservedResourceMapDBName); | |
| 253 | |
| 254 if (base::PathExists(preserved_resource_map_path)) { | |
| 255 // Preserved DB is found. The previous attempt to create a new DB should not | |
| 256 // be successful. Discard the imperfect new DB and restore the old DB. | |
| 257 if (!base::DeleteFile(resource_map_path, false /* recursive */) || | |
| 258 !base::Move(preserved_resource_map_path, resource_map_path)) | |
| 259 return false; | |
| 260 } | |
| 261 | |
| 262 if (!base::PathExists(resource_map_path)) | |
| 263 return false; | |
| 264 | |
| 265 // Open DB. | |
| 266 leveldb::DB* db = NULL; | |
| 267 leveldb::Options options; | |
| 268 options.max_open_files = 0; // Use minimum. | |
| 269 options.create_if_missing = false; | |
| 270 options.reuse_logs = leveldb_env::kDefaultLogReuseOptionValue; | |
| 271 if (!leveldb::DB::Open(options, resource_map_path.AsUTF8Unsafe(), &db).ok()) | |
| 272 return false; | |
| 273 scoped_ptr<leveldb::DB> resource_map(db); | |
| 274 | |
| 275 // Check DB version. | |
| 276 std::string serialized_header; | |
| 277 ResourceMetadataHeader header; | |
| 278 if (!resource_map->Get(leveldb::ReadOptions(), | |
| 279 leveldb::Slice(GetHeaderDBKey()), | |
| 280 &serialized_header).ok() || | |
| 281 !header.ParseFromString(serialized_header)) | |
| 282 return false; | |
| 283 UMA_HISTOGRAM_SPARSE_SLOWLY("Drive.MetadataDBVersionBeforeUpgradeCheck", | |
| 284 header.version()); | |
| 285 | |
| 286 if (header.version() == kDBVersion) { | |
| 287 // Before r272134, UpgradeOldDB() was not deleting unused ID entries. | |
| 288 // Delete unused ID entries to fix crbug.com/374648. | |
| 289 std::set<std::string> used_ids; | |
| 290 | |
| 291 scoped_ptr<leveldb::Iterator> it( | |
| 292 resource_map->NewIterator(leveldb::ReadOptions())); | |
| 293 it->Seek(leveldb::Slice(GetHeaderDBKey())); | |
| 294 it->Next(); | |
| 295 for (; it->Valid(); it->Next()) { | |
| 296 if (IsCacheEntryKey(it->key())) { | |
| 297 used_ids.insert(GetIdFromCacheEntryKey(it->key())); | |
| 298 } else if (!IsChildEntryKey(it->key()) && !IsIdEntryKey(it->key())) { | |
| 299 used_ids.insert(it->key().ToString()); | |
| 300 } | |
| 301 } | |
| 302 if (!it->status().ok()) | |
| 303 return false; | |
| 304 | |
| 305 leveldb::WriteBatch batch; | |
| 306 for (it->SeekToFirst(); it->Valid(); it->Next()) { | |
| 307 if (IsIdEntryKey(it->key()) && !used_ids.count(it->value().ToString())) | |
| 308 batch.Delete(it->key()); | |
| 309 } | |
| 310 if (!it->status().ok()) | |
| 311 return false; | |
| 312 | |
| 313 return resource_map->Write(leveldb::WriteOptions(), &batch).ok(); | |
| 314 } else if (header.version() < 6) { // Too old, nothing can be done. | |
| 315 return false; | |
| 316 } else if (header.version() < 11) { // Cache entries can be reused. | |
| 317 leveldb::ReadOptions options; | |
| 318 options.verify_checksums = true; | |
| 319 scoped_ptr<leveldb::Iterator> it(resource_map->NewIterator(options)); | |
| 320 | |
| 321 leveldb::WriteBatch batch; | |
| 322 // First, remove all entries. | |
| 323 for (it->SeekToFirst(); it->Valid(); it->Next()) | |
| 324 batch.Delete(it->key()); | |
| 325 | |
| 326 // Put ID entries and cache entries. | |
| 327 for (it->SeekToFirst(); it->Valid(); it->Next()) { | |
| 328 if (IsCacheEntryKey(it->key())) { | |
| 329 FileCacheEntry cache_entry; | |
| 330 if (!cache_entry.ParseFromArray(it->value().data(), it->value().size())) | |
| 331 return false; | |
| 332 | |
| 333 // The resource ID might be in old WAPI format. We need to canonicalize | |
| 334 // to the format of API service currently in use. | |
| 335 const std::string& id = GetIdFromCacheEntryKey(it->key()); | |
| 336 const std::string& id_new = util::CanonicalizeResourceId(id); | |
| 337 | |
| 338 // Before v11, resource ID was directly used as local ID. Such entries | |
| 339 // can be migrated by adding an identity ID mapping. | |
| 340 batch.Put(GetIdEntryKey(id_new), id_new); | |
| 341 | |
| 342 // Put cache state into a ResourceEntry. | |
| 343 ResourceEntry entry; | |
| 344 entry.set_local_id(id_new); | |
| 345 entry.set_resource_id(id_new); | |
| 346 *entry.mutable_file_specific_info()->mutable_cache_state() = | |
| 347 cache_entry; | |
| 348 | |
| 349 std::string serialized_entry; | |
| 350 if (!entry.SerializeToString(&serialized_entry)) { | |
| 351 DLOG(ERROR) << "Failed to serialize the entry: " << id; | |
| 352 return false; | |
| 353 } | |
| 354 batch.Put(id_new, serialized_entry); | |
| 355 } | |
| 356 } | |
| 357 if (!it->status().ok()) | |
| 358 return false; | |
| 359 | |
| 360 // Put header with the latest version number. | |
| 361 std::string serialized_header; | |
| 362 if (!GetDefaultHeaderEntry().SerializeToString(&serialized_header)) | |
| 363 return false; | |
| 364 batch.Put(GetHeaderDBKey(), serialized_header); | |
| 365 | |
| 366 return resource_map->Write(leveldb::WriteOptions(), &batch).ok(); | |
| 367 } else if (header.version() < 12) { // Cache and ID map entries are reusable. | |
| 368 leveldb::ReadOptions options; | |
| 369 options.verify_checksums = true; | |
| 370 scoped_ptr<leveldb::Iterator> it(resource_map->NewIterator(options)); | |
| 371 | |
| 372 // First, get the set of local IDs associated with cache entries. | |
| 373 std::set<std::string> cached_entry_ids; | |
| 374 for (it->SeekToFirst(); it->Valid(); it->Next()) { | |
| 375 if (IsCacheEntryKey(it->key())) | |
| 376 cached_entry_ids.insert(GetIdFromCacheEntryKey(it->key())); | |
| 377 } | |
| 378 if (!it->status().ok()) | |
| 379 return false; | |
| 380 | |
| 381 // Remove all entries except used ID entries. | |
| 382 leveldb::WriteBatch batch; | |
| 383 std::map<std::string, std::string> local_id_to_resource_id; | |
| 384 for (it->SeekToFirst(); it->Valid(); it->Next()) { | |
| 385 const bool is_used_id = IsIdEntryKey(it->key()) && | |
| 386 cached_entry_ids.count(it->value().ToString()); | |
| 387 if (is_used_id) { | |
| 388 local_id_to_resource_id[it->value().ToString()] = | |
| 389 GetResourceIdFromIdEntryKey(it->key()); | |
| 390 } else { | |
| 391 batch.Delete(it->key()); | |
| 392 } | |
| 393 } | |
| 394 if (!it->status().ok()) | |
| 395 return false; | |
| 396 | |
| 397 // Put cache entries. | |
| 398 for (it->SeekToFirst(); it->Valid(); it->Next()) { | |
| 399 if (IsCacheEntryKey(it->key())) { | |
| 400 const std::string& id = GetIdFromCacheEntryKey(it->key()); | |
| 401 | |
| 402 std::map<std::string, std::string>::const_iterator iter_resource_id = | |
| 403 local_id_to_resource_id.find(id); | |
| 404 if (iter_resource_id == local_id_to_resource_id.end()) | |
| 405 continue; | |
| 406 | |
| 407 FileCacheEntry cache_entry; | |
| 408 if (!cache_entry.ParseFromArray(it->value().data(), it->value().size())) | |
| 409 return false; | |
| 410 | |
| 411 // Put cache state into a ResourceEntry. | |
| 412 ResourceEntry entry; | |
| 413 entry.set_local_id(id); | |
| 414 entry.set_resource_id(iter_resource_id->second); | |
| 415 *entry.mutable_file_specific_info()->mutable_cache_state() = | |
| 416 cache_entry; | |
| 417 | |
| 418 std::string serialized_entry; | |
| 419 if (!entry.SerializeToString(&serialized_entry)) { | |
| 420 DLOG(ERROR) << "Failed to serialize the entry: " << id; | |
| 421 return false; | |
| 422 } | |
| 423 batch.Put(id, serialized_entry); | |
| 424 } | |
| 425 } | |
| 426 if (!it->status().ok()) | |
| 427 return false; | |
| 428 | |
| 429 // Put header with the latest version number. | |
| 430 std::string serialized_header; | |
| 431 if (!GetDefaultHeaderEntry().SerializeToString(&serialized_header)) | |
| 432 return false; | |
| 433 batch.Put(GetHeaderDBKey(), serialized_header); | |
| 434 | |
| 435 return resource_map->Write(leveldb::WriteOptions(), &batch).ok(); | |
| 436 } else if (header.version() < 13) { // Reuse all entries. | |
| 437 leveldb::ReadOptions options; | |
| 438 options.verify_checksums = true; | |
| 439 scoped_ptr<leveldb::Iterator> it(resource_map->NewIterator(options)); | |
| 440 | |
| 441 // First, get local ID to resource ID map. | |
| 442 std::map<std::string, std::string> local_id_to_resource_id; | |
| 443 for (it->SeekToFirst(); it->Valid(); it->Next()) { | |
| 444 if (IsIdEntryKey(it->key())) { | |
| 445 local_id_to_resource_id[it->value().ToString()] = | |
| 446 GetResourceIdFromIdEntryKey(it->key()); | |
| 447 } | |
| 448 } | |
| 449 if (!it->status().ok()) | |
| 450 return false; | |
| 451 | |
| 452 leveldb::WriteBatch batch; | |
| 453 // Merge cache entries to ResourceEntry. | |
| 454 for (it->SeekToFirst(); it->Valid(); it->Next()) { | |
| 455 if (IsCacheEntryKey(it->key())) { | |
| 456 const std::string& id = GetIdFromCacheEntryKey(it->key()); | |
| 457 | |
| 458 FileCacheEntry cache_entry; | |
| 459 if (!cache_entry.ParseFromArray(it->value().data(), it->value().size())) | |
| 460 return false; | |
| 461 | |
| 462 std::string serialized_entry; | |
| 463 leveldb::Status status = resource_map->Get(options, | |
| 464 leveldb::Slice(id), | |
| 465 &serialized_entry); | |
| 466 | |
| 467 std::map<std::string, std::string>::const_iterator iter_resource_id = | |
| 468 local_id_to_resource_id.find(id); | |
| 469 | |
| 470 // No need to keep cache-only entries without resource ID. | |
| 471 if (status.IsNotFound() && | |
| 472 iter_resource_id == local_id_to_resource_id.end()) | |
| 473 continue; | |
| 474 | |
| 475 ResourceEntry entry; | |
| 476 if (status.ok()) { | |
| 477 if (!entry.ParseFromString(serialized_entry)) | |
| 478 return false; | |
| 479 } else if (status.IsNotFound()) { | |
| 480 entry.set_local_id(id); | |
| 481 entry.set_resource_id(iter_resource_id->second); | |
| 482 } else { | |
| 483 DLOG(ERROR) << "Failed to get the entry: " << id; | |
| 484 return false; | |
| 485 } | |
| 486 *entry.mutable_file_specific_info()->mutable_cache_state() = | |
| 487 cache_entry; | |
| 488 | |
| 489 if (!entry.SerializeToString(&serialized_entry)) { | |
| 490 DLOG(ERROR) << "Failed to serialize the entry: " << id; | |
| 491 return false; | |
| 492 } | |
| 493 batch.Delete(it->key()); | |
| 494 batch.Put(id, serialized_entry); | |
| 495 } | |
| 496 } | |
| 497 if (!it->status().ok()) | |
| 498 return false; | |
| 499 | |
| 500 // Put header with the latest version number. | |
| 501 header.set_version(ResourceMetadataStorage::kDBVersion); | |
| 502 std::string serialized_header; | |
| 503 if (!header.SerializeToString(&serialized_header)) | |
| 504 return false; | |
| 505 batch.Put(GetHeaderDBKey(), serialized_header); | |
| 506 | |
| 507 return resource_map->Write(leveldb::WriteOptions(), &batch).ok(); | |
| 508 } | |
| 509 | |
| 510 LOG(WARNING) << "Unexpected DB version: " << header.version(); | |
| 511 return false; | |
| 512 } | |
| 513 | |
| 514 ResourceMetadataStorage::ResourceMetadataStorage( | |
| 515 const base::FilePath& directory_path, | |
| 516 base::SequencedTaskRunner* blocking_task_runner) | |
| 517 : directory_path_(directory_path), | |
| 518 cache_file_scan_is_needed_(true), | |
| 519 blocking_task_runner_(blocking_task_runner) { | |
| 520 } | |
| 521 | |
| 522 void ResourceMetadataStorage::Destroy() { | |
| 523 blocking_task_runner_->PostTask( | |
| 524 FROM_HERE, | |
| 525 base::Bind(&ResourceMetadataStorage::DestroyOnBlockingPool, | |
| 526 base::Unretained(this))); | |
| 527 } | |
| 528 | |
| 529 bool ResourceMetadataStorage::Initialize() { | |
| 530 base::ThreadRestrictions::AssertIOAllowed(); | |
| 531 | |
| 532 resource_map_.reset(); | |
| 533 | |
| 534 const base::FilePath resource_map_path = | |
| 535 directory_path_.Append(kResourceMapDBName); | |
| 536 const base::FilePath preserved_resource_map_path = | |
| 537 directory_path_.Append(kPreservedResourceMapDBName); | |
| 538 const base::FilePath trashed_resource_map_path = | |
| 539 directory_path_.Append(kTrashedResourceMapDBName); | |
| 540 | |
| 541 // Discard unneeded DBs. | |
| 542 if (!base::DeleteFile(preserved_resource_map_path, true /* recursive */) || | |
| 543 !base::DeleteFile(trashed_resource_map_path, true /* recursive */)) { | |
| 544 LOG(ERROR) << "Failed to remove unneeded DBs."; | |
| 545 return false; | |
| 546 } | |
| 547 | |
| 548 // Try to open the existing DB. | |
| 549 leveldb::DB* db = NULL; | |
| 550 leveldb::Options options; | |
| 551 options.max_open_files = 0; // Use minimum. | |
| 552 options.create_if_missing = false; | |
| 553 options.reuse_logs = leveldb_env::kDefaultLogReuseOptionValue; | |
| 554 | |
| 555 DBInitStatus open_existing_result = DB_INIT_NOT_FOUND; | |
| 556 leveldb::Status status; | |
| 557 if (base::PathExists(resource_map_path)) { | |
| 558 status = leveldb::DB::Open(options, resource_map_path.AsUTF8Unsafe(), &db); | |
| 559 open_existing_result = LevelDBStatusToDBInitStatus(status); | |
| 560 } | |
| 561 | |
| 562 if (open_existing_result == DB_INIT_SUCCESS) { | |
| 563 resource_map_.reset(db); | |
| 564 | |
| 565 // Check the validity of existing DB. | |
| 566 int db_version = -1; | |
| 567 ResourceMetadataHeader header; | |
| 568 if (GetHeader(&header) == FILE_ERROR_OK) | |
| 569 db_version = header.version(); | |
| 570 | |
| 571 bool should_discard_db = true; | |
| 572 if (db_version != kDBVersion) { | |
| 573 open_existing_result = DB_INIT_INCOMPATIBLE; | |
| 574 DVLOG(1) << "Reject incompatible DB."; | |
| 575 } else if (!CheckValidity()) { | |
| 576 open_existing_result = DB_INIT_BROKEN; | |
| 577 LOG(ERROR) << "Reject invalid DB."; | |
| 578 } else { | |
| 579 should_discard_db = false; | |
| 580 } | |
| 581 | |
| 582 if (should_discard_db) | |
| 583 resource_map_.reset(); | |
| 584 else | |
| 585 cache_file_scan_is_needed_ = false; | |
| 586 } | |
| 587 | |
| 588 UMA_HISTOGRAM_ENUMERATION("Drive.MetadataDBOpenExistingResult", | |
| 589 open_existing_result, | |
| 590 DB_INIT_MAX_VALUE); | |
| 591 | |
| 592 DBInitStatus init_result = DB_INIT_OPENED_EXISTING_DB; | |
| 593 | |
| 594 // Failed to open the existing DB, create new DB. | |
| 595 if (!resource_map_) { | |
| 596 // Move the existing DB to the preservation path. The moved old DB is | |
| 597 // deleted once the new DB creation succeeds, or is restored later in | |
| 598 // UpgradeOldDB() when the creation fails. | |
| 599 MoveIfPossible(resource_map_path, preserved_resource_map_path); | |
| 600 | |
| 601 // Create DB. | |
| 602 options.max_open_files = 0; // Use minimum. | |
| 603 options.create_if_missing = true; | |
| 604 options.error_if_exists = true; | |
| 605 options.reuse_logs = leveldb_env::kDefaultLogReuseOptionValue; | |
| 606 | |
| 607 status = leveldb::DB::Open(options, resource_map_path.AsUTF8Unsafe(), &db); | |
| 608 if (status.ok()) { | |
| 609 resource_map_.reset(db); | |
| 610 | |
| 611 // Set up header and trash the old DB. | |
| 612 if (PutHeader(GetDefaultHeaderEntry()) == FILE_ERROR_OK && | |
| 613 MoveIfPossible(preserved_resource_map_path, | |
| 614 trashed_resource_map_path)) { | |
| 615 init_result = open_existing_result == DB_INIT_NOT_FOUND ? | |
| 616 DB_INIT_CREATED_NEW_DB : DB_INIT_REPLACED_EXISTING_DB_WITH_NEW_DB; | |
| 617 } else { | |
| 618 init_result = DB_INIT_FAILED; | |
| 619 resource_map_.reset(); | |
| 620 } | |
| 621 } else { | |
| 622 LOG(ERROR) << "Failed to create resource map DB: " << status.ToString(); | |
| 623 init_result = LevelDBStatusToDBInitStatus(status); | |
| 624 } | |
| 625 } | |
| 626 | |
| 627 UMA_HISTOGRAM_ENUMERATION("Drive.MetadataDBInitResult", | |
| 628 init_result, | |
| 629 DB_INIT_MAX_VALUE); | |
| 630 return resource_map_; | |
| 631 } | |
| 632 | |
| 633 void ResourceMetadataStorage::RecoverCacheInfoFromTrashedResourceMap( | |
| 634 RecoveredCacheInfoMap* out_info) { | |
| 635 const base::FilePath trashed_resource_map_path = | |
| 636 directory_path_.Append(kTrashedResourceMapDBName); | |
| 637 | |
| 638 if (!base::PathExists(trashed_resource_map_path)) | |
| 639 return; | |
| 640 | |
| 641 leveldb::Options options; | |
| 642 options.max_open_files = 0; // Use minimum. | |
| 643 options.create_if_missing = false; | |
| 644 options.reuse_logs = leveldb_env::kDefaultLogReuseOptionValue; | |
| 645 | |
| 646 // Trashed DB may be broken, repair it first. | |
| 647 leveldb::Status status; | |
| 648 status = leveldb::RepairDB(trashed_resource_map_path.AsUTF8Unsafe(), options); | |
| 649 if (!status.ok()) { | |
| 650 LOG(ERROR) << "Failed to repair trashed DB: " << status.ToString(); | |
| 651 return; | |
| 652 } | |
| 653 | |
| 654 // Open it. | |
| 655 leveldb::DB* db = NULL; | |
| 656 status = leveldb::DB::Open(options, trashed_resource_map_path.AsUTF8Unsafe(), | |
| 657 &db); | |
| 658 if (!status.ok()) { | |
| 659 LOG(ERROR) << "Failed to open trashed DB: " << status.ToString(); | |
| 660 return; | |
| 661 } | |
| 662 scoped_ptr<leveldb::DB> resource_map(db); | |
| 663 | |
| 664 // Check DB version. | |
| 665 std::string serialized_header; | |
| 666 ResourceMetadataHeader header; | |
| 667 if (!resource_map->Get(leveldb::ReadOptions(), | |
| 668 leveldb::Slice(GetHeaderDBKey()), | |
| 669 &serialized_header).ok() || | |
| 670 !header.ParseFromString(serialized_header) || | |
| 671 header.version() != kDBVersion) { | |
| 672 LOG(ERROR) << "Incompatible DB version: " << header.version(); | |
| 673 return; | |
| 674 } | |
| 675 | |
| 676 // Collect cache entries. | |
| 677 scoped_ptr<leveldb::Iterator> it( | |
| 678 resource_map->NewIterator(leveldb::ReadOptions())); | |
| 679 for (it->SeekToFirst(); it->Valid(); it->Next()) { | |
| 680 if (!IsChildEntryKey(it->key()) && | |
| 681 !IsIdEntryKey(it->key())) { | |
| 682 const std::string id = it->key().ToString(); | |
| 683 ResourceEntry entry; | |
| 684 if (entry.ParseFromArray(it->value().data(), it->value().size()) && | |
| 685 entry.file_specific_info().has_cache_state()) { | |
| 686 RecoveredCacheInfo* info = &(*out_info)[id]; | |
| 687 info->is_dirty = entry.file_specific_info().cache_state().is_dirty(); | |
| 688 info->md5 = entry.file_specific_info().cache_state().md5(); | |
| 689 info->title = entry.title(); | |
| 690 } | |
| 691 } | |
| 692 } | |
| 693 } | |
| 694 | |
| 695 FileError ResourceMetadataStorage::SetLargestChangestamp( | |
| 696 int64 largest_changestamp) { | |
| 697 base::ThreadRestrictions::AssertIOAllowed(); | |
| 698 | |
| 699 ResourceMetadataHeader header; | |
| 700 FileError error = GetHeader(&header); | |
| 701 if (error != FILE_ERROR_OK) { | |
| 702 DLOG(ERROR) << "Failed to get the header."; | |
| 703 return error; | |
| 704 } | |
| 705 header.set_largest_changestamp(largest_changestamp); | |
| 706 return PutHeader(header); | |
| 707 } | |
| 708 | |
| 709 FileError ResourceMetadataStorage::GetLargestChangestamp( | |
| 710 int64* largest_changestamp) { | |
| 711 base::ThreadRestrictions::AssertIOAllowed(); | |
| 712 ResourceMetadataHeader header; | |
| 713 FileError error = GetHeader(&header); | |
| 714 if (error != FILE_ERROR_OK) { | |
| 715 DLOG(ERROR) << "Failed to get the header."; | |
| 716 return error; | |
| 717 } | |
| 718 *largest_changestamp = header.largest_changestamp(); | |
| 719 return FILE_ERROR_OK; | |
| 720 } | |
| 721 | |
| 722 FileError ResourceMetadataStorage::PutEntry(const ResourceEntry& entry) { | |
| 723 base::ThreadRestrictions::AssertIOAllowed(); | |
| 724 | |
| 725 const std::string& id = entry.local_id(); | |
| 726 DCHECK(!id.empty()); | |
| 727 | |
| 728 // Try to get existing entry. | |
| 729 std::string serialized_entry; | |
| 730 leveldb::Status status = resource_map_->Get(leveldb::ReadOptions(), | |
| 731 leveldb::Slice(id), | |
| 732 &serialized_entry); | |
| 733 if (!status.ok() && !status.IsNotFound()) // Unexpected errors. | |
| 734 return LevelDBStatusToFileError(status); | |
| 735 | |
| 736 ResourceEntry old_entry; | |
| 737 if (status.ok() && !old_entry.ParseFromString(serialized_entry)) | |
| 738 return FILE_ERROR_FAILED; | |
| 739 | |
| 740 // Construct write batch. | |
| 741 leveldb::WriteBatch batch; | |
| 742 | |
| 743 // Remove from the old parent. | |
| 744 if (!old_entry.parent_local_id().empty()) { | |
| 745 batch.Delete(GetChildEntryKey(old_entry.parent_local_id(), | |
| 746 old_entry.base_name())); | |
| 747 } | |
| 748 // Add to the new parent. | |
| 749 if (!entry.parent_local_id().empty()) | |
| 750 batch.Put(GetChildEntryKey(entry.parent_local_id(), entry.base_name()), id); | |
| 751 | |
| 752 // Refresh resource-ID-to-local-ID mapping entry. | |
| 753 if (old_entry.resource_id() != entry.resource_id()) { | |
| 754 // Resource ID should not change. | |
| 755 DCHECK(old_entry.resource_id().empty() || entry.resource_id().empty()); | |
| 756 | |
| 757 if (!old_entry.resource_id().empty()) | |
| 758 batch.Delete(GetIdEntryKey(old_entry.resource_id())); | |
| 759 if (!entry.resource_id().empty()) | |
| 760 batch.Put(GetIdEntryKey(entry.resource_id()), id); | |
| 761 } | |
| 762 | |
| 763 // Put the entry itself. | |
| 764 if (!entry.SerializeToString(&serialized_entry)) { | |
| 765 DLOG(ERROR) << "Failed to serialize the entry: " << id; | |
| 766 return FILE_ERROR_FAILED; | |
| 767 } | |
| 768 batch.Put(id, serialized_entry); | |
| 769 | |
| 770 status = resource_map_->Write(leveldb::WriteOptions(), &batch); | |
| 771 return LevelDBStatusToFileError(status); | |
| 772 } | |
| 773 | |
| 774 FileError ResourceMetadataStorage::GetEntry(const std::string& id, | |
| 775 ResourceEntry* out_entry) { | |
| 776 base::ThreadRestrictions::AssertIOAllowed(); | |
| 777 DCHECK(!id.empty()); | |
| 778 | |
| 779 std::string serialized_entry; | |
| 780 const leveldb::Status status = resource_map_->Get(leveldb::ReadOptions(), | |
| 781 leveldb::Slice(id), | |
| 782 &serialized_entry); | |
| 783 if (!status.ok()) | |
| 784 return LevelDBStatusToFileError(status); | |
| 785 if (!out_entry->ParseFromString(serialized_entry)) | |
| 786 return FILE_ERROR_FAILED; | |
| 787 return FILE_ERROR_OK; | |
| 788 } | |
| 789 | |
| 790 FileError ResourceMetadataStorage::RemoveEntry(const std::string& id) { | |
| 791 base::ThreadRestrictions::AssertIOAllowed(); | |
| 792 DCHECK(!id.empty()); | |
| 793 | |
| 794 ResourceEntry entry; | |
| 795 FileError error = GetEntry(id, &entry); | |
| 796 if (error != FILE_ERROR_OK) | |
| 797 return error; | |
| 798 | |
| 799 leveldb::WriteBatch batch; | |
| 800 | |
| 801 // Remove from the parent. | |
| 802 if (!entry.parent_local_id().empty()) | |
| 803 batch.Delete(GetChildEntryKey(entry.parent_local_id(), entry.base_name())); | |
| 804 | |
| 805 // Remove resource ID-local ID mapping entry. | |
| 806 if (!entry.resource_id().empty()) | |
| 807 batch.Delete(GetIdEntryKey(entry.resource_id())); | |
| 808 | |
| 809 // Remove the entry itself. | |
| 810 batch.Delete(id); | |
| 811 | |
| 812 const leveldb::Status status = resource_map_->Write(leveldb::WriteOptions(), | |
| 813 &batch); | |
| 814 return LevelDBStatusToFileError(status); | |
| 815 } | |
| 816 | |
| 817 scoped_ptr<ResourceMetadataStorage::Iterator> | |
| 818 ResourceMetadataStorage::GetIterator() { | |
| 819 base::ThreadRestrictions::AssertIOAllowed(); | |
| 820 | |
| 821 scoped_ptr<leveldb::Iterator> it( | |
| 822 resource_map_->NewIterator(leveldb::ReadOptions())); | |
| 823 return make_scoped_ptr(new Iterator(it.Pass())); | |
| 824 } | |
| 825 | |
| 826 FileError ResourceMetadataStorage::GetChild(const std::string& parent_id, | |
| 827 const std::string& child_name, | |
| 828 std::string* child_id) { | |
| 829 base::ThreadRestrictions::AssertIOAllowed(); | |
| 830 DCHECK(!parent_id.empty()); | |
| 831 DCHECK(!child_name.empty()); | |
| 832 | |
| 833 const leveldb::Status status = | |
| 834 resource_map_->Get( | |
| 835 leveldb::ReadOptions(), | |
| 836 leveldb::Slice(GetChildEntryKey(parent_id, child_name)), | |
| 837 child_id); | |
| 838 return LevelDBStatusToFileError(status); | |
| 839 } | |
| 840 | |
| 841 FileError ResourceMetadataStorage::GetChildren( | |
| 842 const std::string& parent_id, | |
| 843 std::vector<std::string>* children) { | |
| 844 base::ThreadRestrictions::AssertIOAllowed(); | |
| 845 DCHECK(!parent_id.empty()); | |
| 846 | |
| 847 // Iterate over all entries with keys starting with |parent_id|. | |
| 848 scoped_ptr<leveldb::Iterator> it( | |
| 849 resource_map_->NewIterator(leveldb::ReadOptions())); | |
| 850 for (it->Seek(parent_id); | |
| 851 it->Valid() && it->key().starts_with(leveldb::Slice(parent_id)); | |
| 852 it->Next()) { | |
| 853 if (IsChildEntryKey(it->key())) | |
| 854 children->push_back(it->value().ToString()); | |
| 855 } | |
| 856 return LevelDBStatusToFileError(it->status()); | |
| 857 } | |
| 858 | |
| 859 ResourceMetadataStorage::RecoveredCacheInfo::RecoveredCacheInfo() | |
| 860 : is_dirty(false) {} | |
| 861 | |
| 862 ResourceMetadataStorage::RecoveredCacheInfo::~RecoveredCacheInfo() {} | |
| 863 | |
| 864 FileError ResourceMetadataStorage::GetIdByResourceId( | |
| 865 const std::string& resource_id, | |
| 866 std::string* out_id) { | |
| 867 base::ThreadRestrictions::AssertIOAllowed(); | |
| 868 DCHECK(!resource_id.empty()); | |
| 869 | |
| 870 const leveldb::Status status = resource_map_->Get( | |
| 871 leveldb::ReadOptions(), | |
| 872 leveldb::Slice(GetIdEntryKey(resource_id)), | |
| 873 out_id); | |
| 874 return LevelDBStatusToFileError(status); | |
| 875 } | |
| 876 | |
| 877 ResourceMetadataStorage::~ResourceMetadataStorage() { | |
| 878 base::ThreadRestrictions::AssertIOAllowed(); | |
| 879 } | |
| 880 | |
| 881 void ResourceMetadataStorage::DestroyOnBlockingPool() { | |
| 882 delete this; | |
| 883 } | |
| 884 | |
| 885 // static | |
| 886 std::string ResourceMetadataStorage::GetChildEntryKey( | |
| 887 const std::string& parent_id, | |
| 888 const std::string& child_name) { | |
| 889 DCHECK(!parent_id.empty()); | |
| 890 DCHECK(!child_name.empty()); | |
| 891 | |
| 892 std::string key = parent_id; | |
| 893 key.push_back(kDBKeyDelimeter); | |
| 894 key.append(child_name); | |
| 895 key.push_back(kDBKeyDelimeter); | |
| 896 return key; | |
| 897 } | |
| 898 | |
| 899 FileError ResourceMetadataStorage::PutHeader( | |
| 900 const ResourceMetadataHeader& header) { | |
| 901 base::ThreadRestrictions::AssertIOAllowed(); | |
| 902 | |
| 903 std::string serialized_header; | |
| 904 if (!header.SerializeToString(&serialized_header)) { | |
| 905 DLOG(ERROR) << "Failed to serialize the header"; | |
| 906 return FILE_ERROR_FAILED; | |
| 907 } | |
| 908 | |
| 909 const leveldb::Status status = resource_map_->Put( | |
| 910 leveldb::WriteOptions(), | |
| 911 leveldb::Slice(GetHeaderDBKey()), | |
| 912 leveldb::Slice(serialized_header)); | |
| 913 return LevelDBStatusToFileError(status); | |
| 914 } | |
| 915 | |
| 916 FileError ResourceMetadataStorage::GetHeader(ResourceMetadataHeader* header) { | |
| 917 base::ThreadRestrictions::AssertIOAllowed(); | |
| 918 | |
| 919 std::string serialized_header; | |
| 920 const leveldb::Status status = resource_map_->Get( | |
| 921 leveldb::ReadOptions(), | |
| 922 leveldb::Slice(GetHeaderDBKey()), | |
| 923 &serialized_header); | |
| 924 if (!status.ok()) | |
| 925 return LevelDBStatusToFileError(status); | |
| 926 return header->ParseFromString(serialized_header) ? | |
| 927 FILE_ERROR_OK : FILE_ERROR_FAILED; | |
| 928 } | |
| 929 | |
| 930 bool ResourceMetadataStorage::CheckValidity() { | |
| 931 base::ThreadRestrictions::AssertIOAllowed(); | |
| 932 | |
| 933 // Perform read with checksums verification enabled. | |
| 934 leveldb::ReadOptions options; | |
| 935 options.verify_checksums = true; | |
| 936 | |
| 937 scoped_ptr<leveldb::Iterator> it(resource_map_->NewIterator(options)); | |
| 938 it->SeekToFirst(); | |
| 939 | |
| 940 // DB is organized like this: | |
| 941 // | |
| 942 // <key> : <value> | |
| 943 // "\0HEADER" : ResourceMetadataHeader | |
| 944 // "\0ID\0|resource ID 1|" : Local ID associated to resource ID 1. | |
| 945 // "\0ID\0|resource ID 2|" : Local ID associated to resource ID 2. | |
| 946 // ... | |
| 947 // "|ID of A|" : ResourceEntry for entry A. | |
| 948 // "|ID of A|\0|child name 1|\0" : ID of the 1st child entry of entry A. | |
| 949 // "|ID of A|\0|child name 2|\0" : ID of the 2nd child entry of entry A. | |
| 950 // ... | |
| 951 // "|ID of A|\0|child name n|\0" : ID of the nth child entry of entry A. | |
| 952 // "|ID of B|" : ResourceEntry for entry B. | |
| 953 // ... | |
| 954 | |
| 955 // Check the header. | |
| 956 ResourceMetadataHeader header; | |
| 957 if (!it->Valid() || | |
| 958 it->key() != GetHeaderDBKey() || // Header entry must come first. | |
| 959 !header.ParseFromArray(it->value().data(), it->value().size()) || | |
| 960 header.version() != kDBVersion) { | |
| 961 DLOG(ERROR) << "Invalid header detected. version = " << header.version(); | |
| 962 RecordCheckValidityFailure(CHECK_VALIDITY_FAILURE_INVALID_HEADER); | |
| 963 return false; | |
| 964 } | |
| 965 | |
| 966 // First scan. Remember relationships between IDs. | |
| 967 typedef base::hash_map<std::string, std::string> KeyToIdMapping; | |
| 968 KeyToIdMapping local_id_to_resource_id_map; | |
| 969 KeyToIdMapping child_key_to_local_id_map; | |
| 970 std::set<std::string> resource_entries; | |
| 971 std::string first_resource_entry_key; | |
| 972 for (it->Next(); it->Valid(); it->Next()) { | |
| 973 if (IsChildEntryKey(it->key())) { | |
| 974 child_key_to_local_id_map[it->key().ToString()] = it->value().ToString(); | |
| 975 continue; | |
| 976 } | |
| 977 | |
| 978 if (IsIdEntryKey(it->key())) { | |
| 979 const auto result = local_id_to_resource_id_map.insert(std::make_pair( | |
| 980 it->value().ToString(), | |
| 981 GetResourceIdFromIdEntryKey(it->key().ToString()))); | |
| 982 // Check that no local ID is associated with more than one resource ID. | |
| 983 if (!result.second) { | |
| 984 DLOG(ERROR) << "Broken ID entry."; | |
| 985 RecordCheckValidityFailure(CHECK_VALIDITY_FAILURE_BROKEN_ID_ENTRY); | |
| 986 return false; | |
| 987 } | |
| 988 continue; | |
| 989 } | |
| 990 | |
| 991 // Remember the key of the first resource entry record, so the second scan | |
| 992 // can start from this point. | |
| 993 if (first_resource_entry_key.empty()) | |
| 994 first_resource_entry_key = it->key().ToString(); | |
| 995 | |
| 996 resource_entries.insert(it->key().ToString()); | |
| 997 } | |
| 998 | |
| 999 // Second scan. Verify relationships and resource entry correctness. | |
| 1000 size_t num_entries_with_parent = 0; | |
| 1001 ResourceEntry entry; | |
| 1002 for (it->Seek(first_resource_entry_key); it->Valid(); it->Next()) { | |
| 1003 if (IsChildEntryKey(it->key())) | |
| 1004 continue; | |
| 1005 | |
| 1006 if (!entry.ParseFromArray(it->value().data(), it->value().size())) { | |
| 1007 DLOG(ERROR) << "Broken entry detected."; | |
| 1008 RecordCheckValidityFailure(CHECK_VALIDITY_FAILURE_BROKEN_ENTRY); | |
| 1009 return false; | |
| 1010 } | |
| 1011 | |
| 1012 // Resource-ID-to-local-ID mapping without entry for the local ID is OK, | |
| 1013 // but if it exists, then the resource ID must be consistent. | |
| 1014 const auto mapping_it = | |
| 1015 local_id_to_resource_id_map.find(it->key().ToString()); | |
| 1016 if (mapping_it != local_id_to_resource_id_map.end() && | |
| 1017 entry.resource_id() != mapping_it->second) { | |
| 1018 DLOG(ERROR) << "Broken ID entry."; | |
| 1019 RecordCheckValidityFailure(CHECK_VALIDITY_FAILURE_BROKEN_ID_ENTRY); | |
| 1020 return false; | |
| 1021 } | |
| 1022 | |
| 1023 // If the parent is referenced, then confirm that it exists and check the | |
| 1024 // parent-child relationships. | |
| 1025 if (!entry.parent_local_id().empty()) { | |
| 1026 const auto mapping_it = resource_entries.find(entry.parent_local_id()); | |
| 1027 if (mapping_it == resource_entries.end()) { | |
| 1028 DLOG(ERROR) << "Parent entry not found."; | |
| 1029 RecordCheckValidityFailure(CHECK_VALIDITY_FAILURE_INVALID_PARENT_ID); | |
| 1030 return false; | |
| 1031 } | |
| 1032 | |
| 1033 // Check if parent-child relationship is stored correctly. | |
| 1034 const auto child_mapping_it = child_key_to_local_id_map.find( | |
| 1035 GetChildEntryKey(entry.parent_local_id(), entry.base_name())); | |
| 1036 if (child_mapping_it == child_key_to_local_id_map.end() || | |
| 1037 leveldb::Slice(child_mapping_it->second) != it->key()) { | |
| 1038 DLOG(ERROR) << "Child map is broken."; | |
| 1039 RecordCheckValidityFailure(CHECK_VALIDITY_FAILURE_BROKEN_CHILD_MAP); | |
| 1040 return false; | |
| 1041 } | |
| 1042 ++num_entries_with_parent; | |
| 1043 } | |
| 1044 } | |
| 1045 | |
| 1046 if (!it->status().ok()) { | |
| 1047 DLOG(ERROR) << "Error during checking resource map. status = " | |
| 1048 << it->status().ToString(); | |
| 1049 RecordCheckValidityFailure(CHECK_VALIDITY_FAILURE_ITERATOR_ERROR); | |
| 1050 return false; | |
| 1051 } | |
| 1052 | |
| 1053 if (child_key_to_local_id_map.size() != num_entries_with_parent) { | |
| 1054 DLOG(ERROR) << "Child entry count mismatch."; | |
| 1055 RecordCheckValidityFailure( | |
| 1056 CHECK_VALIDITY_FAILURE_CHILD_ENTRY_COUNT_MISMATCH); | |
| 1057 return false; | |
| 1058 } | |
| 1059 | |
| 1060 return true; | |
| 1061 } | |
| 1062 | |
| 1063 } // namespace internal | |
| 1064 } // namespace drive | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1296483003:
Move chrome/browser/chromeos/drive/resource* (+deps) into components/drive. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master