net/disk_cache/simple/simple_synchronous_entry.cc

   1 // Copyright (c) 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 "net/disk_cache/simple/simple_synchronous_entry.h"
   6
   7 #include <algorithm>
   8 #include <cstring>
   9 #include <functional>
  10 #include <limits>
  11
  12 #include "base/basictypes.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/file_util.h"
  15 #include "base/hash.h"
  16 #include "base/location.h"
  17 #include "base/metrics/histogram.h"
  18 #include "base/sha1.h"
  19 #include "base/strings/stringprintf.h"
  20 #include "net/base/io_buffer.h"
  21 #include "net/base/net_errors.h"
  22 #include "net/disk_cache/simple/simple_util.h"
  23 #include "third_party/zlib/zlib.h"
  24
  25 using base::kInvalidPlatformFileValue;
  26 using base::ClosePlatformFile;
  27 using base::FilePath;
  28 using base::GetPlatformFileInfo;
  29 using base::PlatformFileError;
  30 using base::PlatformFileInfo;
  31 using base::PLATFORM_FILE_CREATE;
  32 using base::PLATFORM_FILE_ERROR_EXISTS;
  33 using base::PLATFORM_FILE_OK;
  34 using base::PLATFORM_FILE_OPEN;
  35 using base::PLATFORM_FILE_READ;
  36 using base::PLATFORM_FILE_WRITE;
  37 using base::ReadPlatformFile;
  38 using base::Time;
  39 using base::TruncatePlatformFile;
  40 using base::WritePlatformFile;
  41
  42 namespace {
  43
  44 // Used in histograms, please only add entries at the end.
  45 enum OpenEntryResult {
  46   OPEN_ENTRY_SUCCESS = 0,
  47   OPEN_ENTRY_PLATFORM_FILE_ERROR = 1,
  48   OPEN_ENTRY_CANT_READ_HEADER = 2,
  49   OPEN_ENTRY_BAD_MAGIC_NUMBER = 3,
  50   OPEN_ENTRY_BAD_VERSION = 4,
  51   OPEN_ENTRY_CANT_READ_KEY = 5,
  52   // OPEN_ENTRY_KEY_MISMATCH = 6, Deprecated.
  53   OPEN_ENTRY_KEY_HASH_MISMATCH = 7,
  54   OPEN_ENTRY_MAX = 8,
  55 };
  56
  57 // Used in histograms, please only add entries at the end.
  58 enum CreateEntryResult {
  59   CREATE_ENTRY_SUCCESS = 0,
  60   CREATE_ENTRY_PLATFORM_FILE_ERROR = 1,
  61   CREATE_ENTRY_CANT_WRITE_HEADER = 2,
  62   CREATE_ENTRY_CANT_WRITE_KEY = 3,
  63   CREATE_ENTRY_MAX = 4,
  64 };
  65
  66 // Used in histograms, please only add entries at the end.
  67 enum WriteResult {
  68   WRITE_RESULT_SUCCESS = 0,
  69   WRITE_RESULT_PRETRUNCATE_FAILURE,
  70   WRITE_RESULT_WRITE_FAILURE,
  71   WRITE_RESULT_TRUNCATE_FAILURE,
  72   WRITE_RESULT_MAX,
  73 };
  74
  75 // Used in histograms, please only add entries at the end.
  76 enum CheckEOFResult {
  77   CHECK_EOF_RESULT_SUCCESS,
  78   CHECK_EOF_RESULT_READ_FAILURE,
  79   CHECK_EOF_RESULT_MAGIC_NUMBER_MISMATCH,
  80   CHECK_EOF_RESULT_CRC_MISMATCH,
  81   CHECK_EOF_RESULT_MAX,
  82 };
  83
  84 // Used in histograms, please only add entries at the end.
  85 enum CloseResult {
  86   CLOSE_RESULT_SUCCESS,
  87   CLOSE_RESULT_WRITE_FAILURE,
  88 };
  89
  90 void RecordSyncOpenResult(OpenEntryResult result, bool had_index) {
  91   DCHECK_GT(OPEN_ENTRY_MAX, result);
  92   UMA_HISTOGRAM_ENUMERATION(
  93       "SimpleCache.SyncOpenResult", result, OPEN_ENTRY_MAX);
  94   if (had_index) {
  95     UMA_HISTOGRAM_ENUMERATION(
  96         "SimpleCache.SyncOpenResult_WithIndex", result, OPEN_ENTRY_MAX);
  97   } else {
  98     UMA_HISTOGRAM_ENUMERATION(
  99         "SimpleCache.SyncOpenResult_WithoutIndex", result, OPEN_ENTRY_MAX);
 100   }
 101 }
 102
 103 void RecordSyncCreateResult(CreateEntryResult result, bool had_index) {
 104   DCHECK_GT(CREATE_ENTRY_MAX, result);
 105   UMA_HISTOGRAM_ENUMERATION(
 106       "SimpleCache.SyncCreateResult", result, CREATE_ENTRY_MAX);
 107   if (had_index) {
 108     UMA_HISTOGRAM_ENUMERATION(
 109         "SimpleCache.SyncCreateResult_WithIndex", result, CREATE_ENTRY_MAX);
 110   } else {
 111     UMA_HISTOGRAM_ENUMERATION(
 112         "SimpleCache.SyncCreateResult_WithoutIndex", result, CREATE_ENTRY_MAX);
 113   }
 114 }
 115
 116 void RecordWriteResult(WriteResult result) {
 117   UMA_HISTOGRAM_ENUMERATION(
 118       "SimpleCache.SyncWriteResult", result, WRITE_RESULT_MAX);
 119 }
 120
 121 void RecordCheckEOFResult(CheckEOFResult result) {
 122   UMA_HISTOGRAM_ENUMERATION(
 123       "SimpleCache.SyncCheckEOFResult", result, CHECK_EOF_RESULT_MAX);
 124 }
 125
 126 void RecordCloseResult(CloseResult result) {
 127   UMA_HISTOGRAM_ENUMERATION(
 128       "SimpleCache.SyncCloseResult", result, WRITE_RESULT_MAX);
 129 }
 130
 131 }  // namespace
 132
 133 namespace disk_cache {
 134
 135 using simple_util::ConvertEntryHashKeyToHexString;
 136 using simple_util::GetEntryHashKey;
 137 using simple_util::GetFilenameFromEntryHashAndIndex;
 138 using simple_util::GetDataSizeFromKeyAndFileSize;
 139 using simple_util::GetFileSizeFromKeyAndDataSize;
 140 using simple_util::GetFileOffsetFromKeyAndDataOffset;
 141
 142 SimpleEntryStat::SimpleEntryStat() {}
 143
 144 SimpleEntryStat::SimpleEntryStat(base::Time last_used_p,
 145                                  base::Time last_modified_p,
 146                                  const int32 data_size_p[])
 147     : last_used(last_used_p),
 148       last_modified(last_modified_p) {
 149   memcpy(data_size, data_size_p, sizeof(data_size));
 150 }
 151
 152 SimpleEntryCreationResults::SimpleEntryCreationResults(
 153     SimpleEntryStat entry_stat)
 154     : sync_entry(NULL),
 155       entry_stat(entry_stat),
 156       result(net::OK) {
 157 }
 158
 159 SimpleEntryCreationResults::~SimpleEntryCreationResults() {
 160 }
 161
 162 SimpleSynchronousEntry::CRCRecord::CRCRecord() : index(-1),
 163                                                  has_crc32(false),
 164                                                  data_crc32(0) {
 165 }
 166
 167 SimpleSynchronousEntry::CRCRecord::CRCRecord(int index_p,
 168                                              bool has_crc32_p,
 169                                              uint32 data_crc32_p)
 170     : index(index_p),
 171       has_crc32(has_crc32_p),
 172       data_crc32(data_crc32_p) {}
 173
 174 SimpleSynchronousEntry::EntryOperationData::EntryOperationData(int index_p,
 175                                                                int offset_p,
 176                                                                int buf_len_p)
 177     : index(index_p),
 178       offset(offset_p),
 179       buf_len(buf_len_p) {}
 180
 181 SimpleSynchronousEntry::EntryOperationData::EntryOperationData(int index_p,
 182                                                                int offset_p,
 183                                                                int buf_len_p,
 184                                                                bool truncate_p)
 185     : index(index_p),
 186       offset(offset_p),
 187       buf_len(buf_len_p),
 188       truncate(truncate_p) {}
 189
 190 // static
 191 void SimpleSynchronousEntry::OpenEntry(
 192     const FilePath& path,
 193     const uint64 entry_hash,
 194     bool had_index,
 195     SimpleEntryCreationResults *out_results) {
 196   SimpleSynchronousEntry* sync_entry = new SimpleSynchronousEntry(path, "",
 197                                                                   entry_hash);
 198   out_results->result = sync_entry->InitializeForOpen(
 199       had_index, &out_results->entry_stat);
 200   if (out_results->result != net::OK) {
 201     sync_entry->Doom();
 202     delete sync_entry;
 203     out_results->sync_entry = NULL;
 204     return;
 205   }
 206   out_results->sync_entry = sync_entry;
 207 }
 208
 209 // static
 210 void SimpleSynchronousEntry::CreateEntry(
 211     const FilePath& path,
 212     const std::string& key,
 213     const uint64 entry_hash,
 214     bool had_index,
 215     SimpleEntryCreationResults *out_results) {
 216   DCHECK_EQ(entry_hash, GetEntryHashKey(key));
 217   SimpleSynchronousEntry* sync_entry = new SimpleSynchronousEntry(path, key,
 218                                                                   entry_hash);
 219   out_results->result = sync_entry->InitializeForCreate(
 220       had_index, &out_results->entry_stat);
 221   if (out_results->result != net::OK) {
 222     if (out_results->result != net::ERR_FILE_EXISTS)
 223       sync_entry->Doom();
 224     delete sync_entry;
 225     out_results->sync_entry = NULL;
 226     return;
 227   }
 228   out_results->sync_entry = sync_entry;
 229 }
 230
 231 // TODO(gavinp): Move this function to its correct location in this .cc file.
 232 // static
 233 bool SimpleSynchronousEntry::DeleteFilesForEntryHash(
 234     const FilePath& path,
 235     const uint64 entry_hash) {
 236   bool result = true;
 237   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 238     FilePath to_delete = path.AppendASCII(
 239         GetFilenameFromEntryHashAndIndex(entry_hash, i));
 240     if (!base::DeleteFile(to_delete, false)) {
 241       result = false;
 242       DLOG(ERROR) << "Could not delete " << to_delete.MaybeAsASCII();
 243     }
 244   }
 245   return result;
 246 }
 247
 248 // static
 249 void SimpleSynchronousEntry::DoomEntry(
 250     const FilePath& path,
 251     const std::string& key,
 252     uint64 entry_hash,
 253     int* out_result) {
 254   DCHECK_EQ(entry_hash, GetEntryHashKey(key));
 255   bool deleted_well = DeleteFilesForEntryHash(path, entry_hash);
 256   *out_result = deleted_well ? net::OK : net::ERR_FAILED;
 257 }
 258
 259 // static
 260 int SimpleSynchronousEntry::DoomEntrySet(
 261     scoped_ptr<std::vector<uint64> > key_hashes,
 262     const FilePath& path) {
 263   const size_t did_delete_count = std::count_if(
 264       key_hashes->begin(), key_hashes->end(), std::bind1st(
 265           std::ptr_fun(SimpleSynchronousEntry::DeleteFilesForEntryHash), path));
 266   return (did_delete_count == key_hashes->size()) ? net::OK : net::ERR_FAILED;
 267 }
 268
 269 void SimpleSynchronousEntry::ReadData(const EntryOperationData& in_entry_op,
 270                                       net::IOBuffer* out_buf,
 271                                       uint32* out_crc32,
 272                                       base::Time* out_last_used,
 273                                       int* out_result) const {
 274   DCHECK(initialized_);
 275   int64 file_offset =
 276       GetFileOffsetFromKeyAndDataOffset(key_, in_entry_op.offset);
 277   int bytes_read = ReadPlatformFile(files_[in_entry_op.index],
 278                                     file_offset,
 279                                     out_buf->data(),
 280                                     in_entry_op.buf_len);
 281   if (bytes_read > 0) {
 282     *out_last_used = Time::Now();
 283     *out_crc32 = crc32(crc32(0L, Z_NULL, 0),
 284                        reinterpret_cast<const Bytef*>(out_buf->data()),
 285                        bytes_read);
 286   }
 287   if (bytes_read >= 0) {
 288     *out_result = bytes_read;
 289   } else {
 290     *out_result = net::ERR_CACHE_READ_FAILURE;
 291     Doom();
 292   }
 293 }
 294
 295 void SimpleSynchronousEntry::WriteData(const EntryOperationData& in_entry_op,
 296                                        net::IOBuffer* in_buf,
 297                                        SimpleEntryStat* out_entry_stat,
 298                                        int* out_result) const {
 299   DCHECK(initialized_);
 300   int index = in_entry_op.index;
 301   int offset = in_entry_op.offset;
 302   int buf_len = in_entry_op.buf_len;
 303   int truncate = in_entry_op.truncate;
 304
 305   bool extending_by_write = offset + buf_len > out_entry_stat->data_size[index];
 306   if (extending_by_write) {
 307     // We are extending the file, and need to insure the EOF record is zeroed.
 308     const int64 file_eof_offset = GetFileOffsetFromKeyAndDataOffset(
 309         key_, out_entry_stat->data_size[index]);
 310     if (!TruncatePlatformFile(files_[index], file_eof_offset)) {
 311       RecordWriteResult(WRITE_RESULT_PRETRUNCATE_FAILURE);
 312       Doom();
 313       *out_result = net::ERR_CACHE_WRITE_FAILURE;
 314       return;
 315     }
 316   }
 317   const int64 file_offset = GetFileOffsetFromKeyAndDataOffset(key_, offset);
 318   if (buf_len > 0) {
 319     if (WritePlatformFile(
 320             files_[index], file_offset, in_buf->data(), buf_len) != buf_len) {
 321       RecordWriteResult(WRITE_RESULT_WRITE_FAILURE);
 322       Doom();
 323       *out_result = net::ERR_CACHE_WRITE_FAILURE;
 324       return;
 325     }
 326   }
 327   if (!truncate && (buf_len > 0 || !extending_by_write)) {
 328     out_entry_stat->data_size[index] =
 329         std::max(out_entry_stat->data_size[index], offset + buf_len);
 330   } else {
 331     if (!TruncatePlatformFile(files_[index], file_offset + buf_len)) {
 332       RecordWriteResult(WRITE_RESULT_TRUNCATE_FAILURE);
 333       Doom();
 334       *out_result = net::ERR_CACHE_WRITE_FAILURE;
 335       return;
 336     }
 337     out_entry_stat->data_size[index] = offset + buf_len;
 338   }
 339
 340   RecordWriteResult(WRITE_RESULT_SUCCESS);
 341   out_entry_stat->last_used = out_entry_stat->last_modified = Time::Now();
 342   *out_result = buf_len;
 343 }
 344
 345 void SimpleSynchronousEntry::CheckEOFRecord(int index,
 346                                             int32 data_size,
 347                                             uint32 expected_crc32,
 348                                             int* out_result) const {
 349   DCHECK(initialized_);
 350
 351   SimpleFileEOF eof_record;
 352   int64 file_offset = GetFileOffsetFromKeyAndDataOffset(key_, data_size);
 353   if (ReadPlatformFile(files_[index],
 354                        file_offset,
 355                        reinterpret_cast<char*>(&eof_record),
 356                        sizeof(eof_record)) != sizeof(eof_record)) {
 357     RecordCheckEOFResult(CHECK_EOF_RESULT_READ_FAILURE);
 358     Doom();
 359     *out_result = net::ERR_CACHE_CHECKSUM_READ_FAILURE;
 360     return;
 361   }
 362
 363   if (eof_record.final_magic_number != kSimpleFinalMagicNumber) {
 364     RecordCheckEOFResult(CHECK_EOF_RESULT_MAGIC_NUMBER_MISMATCH);
 365     DLOG(INFO) << "eof record had bad magic number.";
 366     Doom();
 367     *out_result = net::ERR_CACHE_CHECKSUM_READ_FAILURE;
 368     return;
 369   }
 370
 371   const bool has_crc = (eof_record.flags & SimpleFileEOF::FLAG_HAS_CRC32) ==
 372                        SimpleFileEOF::FLAG_HAS_CRC32;
 373   UMA_HISTOGRAM_BOOLEAN("SimpleCache.SyncCheckEOFHasCrc", has_crc);
 374   if (has_crc && eof_record.data_crc32 != expected_crc32) {
 375     RecordCheckEOFResult(CHECK_EOF_RESULT_CRC_MISMATCH);
 376     DLOG(INFO) << "eof record had bad crc.";
 377     Doom();
 378     *out_result = net::ERR_CACHE_CHECKSUM_MISMATCH;
 379     return;
 380   }
 381
 382   RecordCheckEOFResult(CHECK_EOF_RESULT_SUCCESS);
 383   *out_result = net::OK;
 384 }
 385
 386 void SimpleSynchronousEntry::Close(
 387     const SimpleEntryStat& entry_stat,
 388     scoped_ptr<std::vector<CRCRecord> > crc32s_to_write) {
 389   for (std::vector<CRCRecord>::const_iterator it = crc32s_to_write->begin();
 390        it != crc32s_to_write->end(); ++it) {
 391     SimpleFileEOF eof_record;
 392     eof_record.final_magic_number = kSimpleFinalMagicNumber;
 393     eof_record.flags = 0;
 394     if (it->has_crc32)
 395       eof_record.flags |= SimpleFileEOF::FLAG_HAS_CRC32;
 396     eof_record.data_crc32 = it->data_crc32;
 397     int64 file_offset = GetFileOffsetFromKeyAndDataOffset(
 398         key_, entry_stat.data_size[it->index]);
 399     if (WritePlatformFile(files_[it->index],
 400                           file_offset,
 401                           reinterpret_cast<const char*>(&eof_record),
 402                           sizeof(eof_record)) != sizeof(eof_record)) {
 403       RecordCloseResult(CLOSE_RESULT_WRITE_FAILURE);
 404       DLOG(INFO) << "Could not write eof record.";
 405       Doom();
 406       break;
 407     }
 408     const int64 file_size = file_offset + sizeof(eof_record);
 409     UMA_HISTOGRAM_CUSTOM_COUNTS("SimpleCache.LastClusterSize",
 410                                 file_size % 4096, 0, 4097, 50);
 411     const int64 cluster_loss = file_size % 4096 ? 4096 - file_size % 4096 : 0;
 412     UMA_HISTOGRAM_PERCENTAGE("SimpleCache.LastClusterLossPercent",
 413                              cluster_loss * 100 / (cluster_loss + file_size));
 414   }
 415
 416   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 417     bool did_close_file = ClosePlatformFile(files_[i]);
 418     CHECK(did_close_file);
 419   }
 420   RecordCloseResult(CLOSE_RESULT_SUCCESS);
 421   have_open_files_ = false;
 422   delete this;
 423 }
 424
 425 SimpleSynchronousEntry::SimpleSynchronousEntry(const FilePath& path,
 426                                                const std::string& key,
 427                                                const uint64 entry_hash)
 428     : path_(path),
 429       entry_hash_(entry_hash),
 430       key_(key),
 431       have_open_files_(false),
 432       initialized_(false) {
 433   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 434     files_[i] = kInvalidPlatformFileValue;
 435   }
 436 }
 437
 438 SimpleSynchronousEntry::~SimpleSynchronousEntry() {
 439   DCHECK(!(have_open_files_ && initialized_));
 440   if (have_open_files_)
 441     CloseFiles();
 442 }
 443
 444 bool SimpleSynchronousEntry::OpenOrCreateFiles(
 445     bool create,
 446     bool had_index,
 447     SimpleEntryStat* out_entry_stat) {
 448   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 449     FilePath filename = path_.AppendASCII(
 450         GetFilenameFromEntryHashAndIndex(entry_hash_, i));
 451     int flags = PLATFORM_FILE_READ | PLATFORM_FILE_WRITE;
 452     if (create)
 453       flags |= PLATFORM_FILE_CREATE;
 454     else
 455       flags |= PLATFORM_FILE_OPEN;
 456     PlatformFileError error;
 457     files_[i] = CreatePlatformFile(filename, flags, NULL, &error);
 458     if (error != PLATFORM_FILE_OK) {
 459       // TODO(ttuttle,gavinp): Remove one each of these triplets of histograms.
 460       // We can calculate the third as the sum or difference of the other two.
 461       if (create) {
 462         RecordSyncCreateResult(CREATE_ENTRY_PLATFORM_FILE_ERROR, had_index);
 463         UMA_HISTOGRAM_ENUMERATION("SimpleCache.SyncCreatePlatformFileError",
 464                                   -error, -base::PLATFORM_FILE_ERROR_MAX);
 465         if (had_index) {
 466           UMA_HISTOGRAM_ENUMERATION(
 467               "SimpleCache.SyncCreatePlatformFileError_WithIndex",
 468               -error, -base::PLATFORM_FILE_ERROR_MAX);
 469         } else {
 470           UMA_HISTOGRAM_ENUMERATION(
 471               "SimpleCache.SyncCreatePlatformFileError_WithoutIndex",
 472               -error, -base::PLATFORM_FILE_ERROR_MAX);
 473         }
 474       } else {
 475         RecordSyncOpenResult(OPEN_ENTRY_PLATFORM_FILE_ERROR, had_index);
 476         UMA_HISTOGRAM_ENUMERATION("SimpleCache.SyncOpenPlatformFileError",
 477                                   -error, -base::PLATFORM_FILE_ERROR_MAX);
 478         if (had_index) {
 479           UMA_HISTOGRAM_ENUMERATION(
 480               "SimpleCache.SyncOpenPlatformFileError_WithIndex",
 481               -error, -base::PLATFORM_FILE_ERROR_MAX);
 482         } else {
 483           UMA_HISTOGRAM_ENUMERATION(
 484               "SimpleCache.SyncOpenPlatformFileError_WithoutIndex",
 485               -error, -base::PLATFORM_FILE_ERROR_MAX);
 486         }
 487       }
 488       while (--i >= 0) {
 489         bool ALLOW_UNUSED did_close = ClosePlatformFile(files_[i]);
 490         DLOG_IF(INFO, !did_close) << "Could not close file "
 491                                   << filename.MaybeAsASCII();
 492       }
 493       return false;
 494     }
 495   }
 496
 497   have_open_files_ = true;
 498   if (create) {
 499     out_entry_stat->last_modified = out_entry_stat->last_used = Time::Now();
 500     for (int i = 0; i < kSimpleEntryFileCount; ++i)
 501       out_entry_stat->data_size[i] = 0;
 502   } else {
 503     for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 504       PlatformFileInfo file_info;
 505       bool success = GetPlatformFileInfo(files_[i], &file_info);
 506       base::Time file_last_modified;
 507       if (!success) {
 508         DLOG(WARNING) << "Could not get platform file info.";
 509         continue;
 510       }
 511       out_entry_stat->last_used = file_info.last_accessed;
 512       if (simple_util::GetMTime(path_, &file_last_modified))
 513         out_entry_stat->last_modified = file_last_modified;
 514       else
 515         out_entry_stat->last_modified = file_info.last_modified;
 516
 517       // Keep the file size in |data size_| briefly until the key is initialized
 518       // properly.
 519       out_entry_stat->data_size[i] = file_info.size;
 520     }
 521   }
 522
 523   return true;
 524 }
 525
 526 void SimpleSynchronousEntry::CloseFiles() {
 527   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 528     DCHECK_NE(kInvalidPlatformFileValue, files_[i]);
 529     bool did_close = ClosePlatformFile(files_[i]);
 530     DCHECK(did_close);
 531   }
 532 }
 533
 534 int SimpleSynchronousEntry::InitializeForOpen(bool had_index,
 535                                               SimpleEntryStat* out_entry_stat) {
 536   DCHECK(!initialized_);
 537   if (!OpenOrCreateFiles(false, had_index, out_entry_stat))
 538     return net::ERR_FAILED;
 539
 540   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 541     SimpleFileHeader header;
 542     int header_read_result =
 543         ReadPlatformFile(files_[i], 0, reinterpret_cast<char*>(&header),
 544                          sizeof(header));
 545     if (header_read_result != sizeof(header)) {
 546       DLOG(WARNING) << "Cannot read header from entry.";
 547       RecordSyncOpenResult(OPEN_ENTRY_CANT_READ_HEADER, had_index);
 548       return net::ERR_FAILED;
 549     }
 550
 551     if (header.initial_magic_number != kSimpleInitialMagicNumber) {
 552       // TODO(gavinp): This seems very bad; for now we log at WARNING, but we
 553       // should give consideration to not saturating the log with these if that
 554       // becomes a problem.
 555       DLOG(WARNING) << "Magic number did not match.";
 556       RecordSyncOpenResult(OPEN_ENTRY_BAD_MAGIC_NUMBER, had_index);
 557       return net::ERR_FAILED;
 558     }
 559
 560     if (header.version != kSimpleVersion) {
 561       DLOG(WARNING) << "Unreadable version.";
 562       RecordSyncOpenResult(OPEN_ENTRY_BAD_VERSION, had_index);
 563       return net::ERR_FAILED;
 564     }
 565
 566     scoped_ptr<char[]> key(new char[header.key_length]);
 567     int key_read_result = ReadPlatformFile(files_[i], sizeof(header),
 568                                            key.get(), header.key_length);
 569     if (key_read_result != implicit_cast<int>(header.key_length)) {
 570       DLOG(WARNING) << "Cannot read key from entry.";
 571       RecordSyncOpenResult(OPEN_ENTRY_CANT_READ_KEY, had_index);
 572       return net::ERR_FAILED;
 573     }
 574
 575     key_ = std::string(key.get(), header.key_length);
 576     out_entry_stat->data_size[i] =
 577         GetDataSizeFromKeyAndFileSize(key_, out_entry_stat->data_size[i]);
 578     if (out_entry_stat->data_size[i] < 0) {
 579       // This entry can't possibly be valid, as it does not have enough space to
 580       // store a valid SimpleFileEOF record.
 581       return net::ERR_FAILED;
 582     }
 583
 584     if (base::Hash(key.get(), header.key_length) != header.key_hash) {
 585       DLOG(WARNING) << "Hash mismatch on key.";
 586       RecordSyncOpenResult(OPEN_ENTRY_KEY_HASH_MISMATCH, had_index);
 587       return net::ERR_FAILED;
 588     }
 589   }
 590   RecordSyncOpenResult(OPEN_ENTRY_SUCCESS, had_index);
 591   initialized_ = true;
 592   return net::OK;
 593 }
 594
 595 int SimpleSynchronousEntry::InitializeForCreate(
 596     bool had_index,
 597     SimpleEntryStat* out_entry_stat) {
 598   DCHECK(!initialized_);
 599   if (!OpenOrCreateFiles(true, had_index, out_entry_stat)) {
 600     DLOG(WARNING) << "Could not create platform files.";
 601     return net::ERR_FILE_EXISTS;
 602   }
 603   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 604     SimpleFileHeader header;
 605     header.initial_magic_number = kSimpleInitialMagicNumber;
 606     header.version = kSimpleVersion;
 607
 608     header.key_length = key_.size();
 609     header.key_hash = base::Hash(key_);
 610
 611     if (WritePlatformFile(files_[i], 0, reinterpret_cast<char*>(&header),
 612                           sizeof(header)) != sizeof(header)) {
 613       DLOG(WARNING) << "Could not write headers to new cache entry.";
 614       RecordSyncCreateResult(CREATE_ENTRY_CANT_WRITE_HEADER, had_index);
 615       return net::ERR_FAILED;
 616     }
 617
 618     if (WritePlatformFile(files_[i], sizeof(header), key_.data(),
 619                           key_.size()) != implicit_cast<int>(key_.size())) {
 620       DLOG(WARNING) << "Could not write keys to new cache entry.";
 621       RecordSyncCreateResult(CREATE_ENTRY_CANT_WRITE_KEY, had_index);
 622       return net::ERR_FAILED;
 623     }
 624   }
 625   RecordSyncCreateResult(CREATE_ENTRY_SUCCESS, had_index);
 626   initialized_ = true;
 627   return net::OK;
 628 }
 629
 630 void SimpleSynchronousEntry::Doom() const {
 631   // TODO(gavinp): Consider if we should guard against redundant Doom() calls.
 632   DeleteFilesForEntryHash(path_, entry_hash_);
 633 }
 634
 635 }  // namespace disk_cache