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/sha1.h"
  18 #include "base/strings/stringprintf.h"
  19 #include "net/base/io_buffer.h"
  20 #include "net/base/net_errors.h"
  21 #include "net/disk_cache/simple/simple_backend_version.h"
  22 #include "net/disk_cache/simple/simple_histogram_macros.h"
  23 #include "net/disk_cache/simple/simple_util.h"
  24 #include "third_party/zlib/zlib.h"
  25
  26 using base::File;
  27 using base::FilePath;
  28 using base::Time;
  29
  30 namespace {
  31
  32 // Used in histograms, please only add entries at the end.
  33 enum OpenEntryResult {
  34   OPEN_ENTRY_SUCCESS = 0,
  35   OPEN_ENTRY_PLATFORM_FILE_ERROR = 1,
  36   OPEN_ENTRY_CANT_READ_HEADER = 2,
  37   OPEN_ENTRY_BAD_MAGIC_NUMBER = 3,
  38   OPEN_ENTRY_BAD_VERSION = 4,
  39   OPEN_ENTRY_CANT_READ_KEY = 5,
  40   // OPEN_ENTRY_KEY_MISMATCH = 6, Deprecated.
  41   OPEN_ENTRY_KEY_HASH_MISMATCH = 7,
  42   OPEN_ENTRY_SPARSE_OPEN_FAILED = 8,
  43   OPEN_ENTRY_MAX = 9,
  44 };
  45
  46 // Used in histograms, please only add entries at the end.
  47 enum WriteResult {
  48   WRITE_RESULT_SUCCESS = 0,
  49   WRITE_RESULT_PRETRUNCATE_FAILURE,
  50   WRITE_RESULT_WRITE_FAILURE,
  51   WRITE_RESULT_TRUNCATE_FAILURE,
  52   WRITE_RESULT_LAZY_STREAM_ENTRY_DOOMED,
  53   WRITE_RESULT_LAZY_CREATE_FAILURE,
  54   WRITE_RESULT_LAZY_INITIALIZE_FAILURE,
  55   WRITE_RESULT_MAX,
  56 };
  57
  58 // Used in histograms, please only add entries at the end.
  59 enum CheckEOFResult {
  60   CHECK_EOF_RESULT_SUCCESS,
  61   CHECK_EOF_RESULT_READ_FAILURE,
  62   CHECK_EOF_RESULT_MAGIC_NUMBER_MISMATCH,
  63   CHECK_EOF_RESULT_CRC_MISMATCH,
  64   CHECK_EOF_RESULT_MAX,
  65 };
  66
  67 // Used in histograms, please only add entries at the end.
  68 enum CloseResult {
  69   CLOSE_RESULT_SUCCESS,
  70   CLOSE_RESULT_WRITE_FAILURE,
  71 };
  72
  73 void RecordSyncOpenResult(net::CacheType cache_type,
  74                           OpenEntryResult result,
  75                           bool had_index) {
  76   DCHECK_GT(OPEN_ENTRY_MAX, result);
  77   SIMPLE_CACHE_UMA(ENUMERATION,
  78                    "SyncOpenResult", cache_type, result, OPEN_ENTRY_MAX);
  79   if (had_index) {
  80     SIMPLE_CACHE_UMA(ENUMERATION,
  81                      "SyncOpenResult_WithIndex", cache_type,
  82                      result, OPEN_ENTRY_MAX);
  83   } else {
  84     SIMPLE_CACHE_UMA(ENUMERATION,
  85                      "SyncOpenResult_WithoutIndex", cache_type,
  86                      result, OPEN_ENTRY_MAX);
  87   }
  88 }
  89
  90 void RecordWriteResult(net::CacheType cache_type, WriteResult result) {
  91   SIMPLE_CACHE_UMA(ENUMERATION,
  92                    "SyncWriteResult", cache_type, result, WRITE_RESULT_MAX);
  93 }
  94
  95 void RecordCheckEOFResult(net::CacheType cache_type, CheckEOFResult result) {
  96   SIMPLE_CACHE_UMA(ENUMERATION,
  97                    "SyncCheckEOFResult", cache_type,
  98                    result, CHECK_EOF_RESULT_MAX);
  99 }
 100
 101 void RecordCloseResult(net::CacheType cache_type, CloseResult result) {
 102   SIMPLE_CACHE_UMA(ENUMERATION,
 103                    "SyncCloseResult", cache_type, result, WRITE_RESULT_MAX);
 104 }
 105
 106 bool CanOmitEmptyFile(int file_index) {
 107   DCHECK_LE(0, file_index);
 108   DCHECK_GT(disk_cache::kSimpleEntryFileCount, file_index);
 109   return file_index == disk_cache::simple_util::GetFileIndexFromStreamIndex(2);
 110 }
 111
 112 }  // namespace
 113
 114 namespace disk_cache {
 115
 116 using simple_util::GetEntryHashKey;
 117 using simple_util::GetFilenameFromEntryHashAndFileIndex;
 118 using simple_util::GetSparseFilenameFromEntryHash;
 119 using simple_util::GetDataSizeFromKeyAndFileSize;
 120 using simple_util::GetFileSizeFromKeyAndDataSize;
 121 using simple_util::GetFileIndexFromStreamIndex;
 122
 123 SimpleEntryStat::SimpleEntryStat(base::Time last_used,
 124                                  base::Time last_modified,
 125                                  const int32 data_size[],
 126                                  const int32 sparse_data_size)
 127     : last_used_(last_used),
 128       last_modified_(last_modified),
 129       sparse_data_size_(sparse_data_size) {
 130   memcpy(data_size_, data_size, sizeof(data_size_));
 131 }
 132
 133 int SimpleEntryStat::GetOffsetInFile(const std::string& key,
 134                                      int offset,
 135                                      int stream_index) const {
 136   const int64 headers_size = sizeof(SimpleFileHeader) + key.size();
 137   const int64 additional_offset =
 138       stream_index == 0 ? data_size_[1] + sizeof(SimpleFileEOF) : 0;
 139   return headers_size + offset + additional_offset;
 140 }
 141
 142 int SimpleEntryStat::GetEOFOffsetInFile(const std::string& key,
 143                                         int stream_index) const {
 144   return GetOffsetInFile(key, data_size_[stream_index], stream_index);
 145 }
 146
 147 int SimpleEntryStat::GetLastEOFOffsetInFile(const std::string& key,
 148                                             int stream_index) const {
 149   const int file_index = GetFileIndexFromStreamIndex(stream_index);
 150   const int eof_data_offset =
 151       file_index == 0 ? data_size_[0] + data_size_[1] + sizeof(SimpleFileEOF)
 152                       : data_size_[2];
 153   return GetOffsetInFile(key, eof_data_offset, stream_index);
 154 }
 155
 156 int SimpleEntryStat::GetFileSize(const std::string& key, int file_index) const {
 157   const int total_data_size =
 158       file_index == 0 ? data_size_[0] + data_size_[1] + sizeof(SimpleFileEOF)
 159                       : data_size_[2];
 160   return GetFileSizeFromKeyAndDataSize(key, total_data_size);
 161 }
 162
 163 SimpleEntryCreationResults::SimpleEntryCreationResults(
 164     SimpleEntryStat entry_stat)
 165     : sync_entry(NULL),
 166       entry_stat(entry_stat),
 167       stream_0_crc32(crc32(0, Z_NULL, 0)),
 168       result(net::OK) {
 169 }
 170
 171 SimpleEntryCreationResults::~SimpleEntryCreationResults() {
 172 }
 173
 174 SimpleSynchronousEntry::CRCRecord::CRCRecord() : index(-1),
 175                                                  has_crc32(false),
 176                                                  data_crc32(0) {
 177 }
 178
 179 SimpleSynchronousEntry::CRCRecord::CRCRecord(int index_p,
 180                                              bool has_crc32_p,
 181                                              uint32 data_crc32_p)
 182     : index(index_p),
 183       has_crc32(has_crc32_p),
 184       data_crc32(data_crc32_p) {}
 185
 186 SimpleSynchronousEntry::EntryOperationData::EntryOperationData(int index_p,
 187                                                                int offset_p,
 188                                                                int buf_len_p)
 189     : index(index_p),
 190       offset(offset_p),
 191       buf_len(buf_len_p) {}
 192
 193 SimpleSynchronousEntry::EntryOperationData::EntryOperationData(int index_p,
 194                                                                int offset_p,
 195                                                                int buf_len_p,
 196                                                                bool truncate_p,
 197                                                                bool doomed_p)
 198     : index(index_p),
 199       offset(offset_p),
 200       buf_len(buf_len_p),
 201       truncate(truncate_p),
 202       doomed(doomed_p) {}
 203
 204 SimpleSynchronousEntry::EntryOperationData::EntryOperationData(
 205     int64 sparse_offset_p,
 206     int buf_len_p)
 207     : sparse_offset(sparse_offset_p),
 208       buf_len(buf_len_p) {}
 209
 210 // static
 211 void SimpleSynchronousEntry::OpenEntry(
 212     net::CacheType cache_type,
 213     const FilePath& path,
 214     const uint64 entry_hash,
 215     bool had_index,
 216     SimpleEntryCreationResults *out_results) {
 217   SimpleSynchronousEntry* sync_entry =
 218       new SimpleSynchronousEntry(cache_type, path, "", entry_hash);
 219   out_results->result =
 220       sync_entry->InitializeForOpen(had_index,
 221                                     &out_results->entry_stat,
 222                                     &out_results->stream_0_data,
 223                                     &out_results->stream_0_crc32);
 224   if (out_results->result != net::OK) {
 225     sync_entry->Doom();
 226     delete sync_entry;
 227     out_results->sync_entry = NULL;
 228     out_results->stream_0_data = NULL;
 229     return;
 230   }
 231   out_results->sync_entry = sync_entry;
 232 }
 233
 234 // static
 235 void SimpleSynchronousEntry::CreateEntry(
 236     net::CacheType cache_type,
 237     const FilePath& path,
 238     const std::string& key,
 239     const uint64 entry_hash,
 240     bool had_index,
 241     SimpleEntryCreationResults *out_results) {
 242   DCHECK_EQ(entry_hash, GetEntryHashKey(key));
 243   SimpleSynchronousEntry* sync_entry =
 244       new SimpleSynchronousEntry(cache_type, path, key, entry_hash);
 245   out_results->result = sync_entry->InitializeForCreate(
 246       had_index, &out_results->entry_stat);
 247   if (out_results->result != net::OK) {
 248     if (out_results->result != net::ERR_FILE_EXISTS)
 249       sync_entry->Doom();
 250     delete sync_entry;
 251     out_results->sync_entry = NULL;
 252     return;
 253   }
 254   out_results->sync_entry = sync_entry;
 255 }
 256
 257 // static
 258 int SimpleSynchronousEntry::DoomEntry(
 259     const FilePath& path,
 260     uint64 entry_hash) {
 261   const bool deleted_well = DeleteFilesForEntryHash(path, entry_hash);
 262   return deleted_well ? net::OK : net::ERR_FAILED;
 263 }
 264
 265 // static
 266 int SimpleSynchronousEntry::DoomEntrySet(
 267     const std::vector<uint64>* key_hashes,
 268     const FilePath& path) {
 269   const size_t did_delete_count = std::count_if(
 270       key_hashes->begin(), key_hashes->end(), std::bind1st(
 271           std::ptr_fun(SimpleSynchronousEntry::DeleteFilesForEntryHash), path));
 272   return (did_delete_count == key_hashes->size()) ? net::OK : net::ERR_FAILED;
 273 }
 274
 275 void SimpleSynchronousEntry::ReadData(const EntryOperationData& in_entry_op,
 276                                       net::IOBuffer* out_buf,
 277                                       uint32* out_crc32,
 278                                       SimpleEntryStat* entry_stat,
 279                                       int* out_result) const {
 280   DCHECK(initialized_);
 281   DCHECK_NE(0, in_entry_op.index);
 282   const int64 file_offset =
 283       entry_stat->GetOffsetInFile(key_, in_entry_op.offset, in_entry_op.index);
 284   int file_index = GetFileIndexFromStreamIndex(in_entry_op.index);
 285   // Zero-length reads and reads to the empty streams of omitted files should
 286   // be handled in the SimpleEntryImpl.
 287   DCHECK_LT(0, in_entry_op.buf_len);
 288   DCHECK(!empty_file_omitted_[file_index]);
 289   File* file = const_cast<File*>(&files_[file_index]);
 290   int bytes_read =
 291       file->Read(file_offset, out_buf->data(), in_entry_op.buf_len);
 292   if (bytes_read > 0) {
 293     entry_stat->set_last_used(Time::Now());
 294     *out_crc32 = crc32(crc32(0L, Z_NULL, 0),
 295                        reinterpret_cast<const Bytef*>(out_buf->data()),
 296                        bytes_read);
 297   }
 298   if (bytes_read >= 0) {
 299     *out_result = bytes_read;
 300   } else {
 301     *out_result = net::ERR_CACHE_READ_FAILURE;
 302     Doom();
 303   }
 304 }
 305
 306 void SimpleSynchronousEntry::WriteData(const EntryOperationData& in_entry_op,
 307                                        net::IOBuffer* in_buf,
 308                                        SimpleEntryStat* out_entry_stat,
 309                                        int* out_result) {
 310   DCHECK(initialized_);
 311   DCHECK_NE(0, in_entry_op.index);
 312   int index = in_entry_op.index;
 313   int file_index = GetFileIndexFromStreamIndex(index);
 314   int offset = in_entry_op.offset;
 315   int buf_len = in_entry_op.buf_len;
 316   bool truncate = in_entry_op.truncate;
 317   bool doomed = in_entry_op.doomed;
 318   const int64 file_offset = out_entry_stat->GetOffsetInFile(
 319       key_, in_entry_op.offset, in_entry_op.index);
 320   bool extending_by_write = offset + buf_len > out_entry_stat->data_size(index);
 321
 322   if (empty_file_omitted_[file_index]) {
 323     // Don't create a new file if the entry has been doomed, to avoid it being
 324     // mixed up with a newly-created entry with the same key.
 325     if (doomed) {
 326       DLOG(WARNING) << "Rejecting write to lazily omitted stream "
 327                     << in_entry_op.index << " of doomed cache entry.";
 328       RecordWriteResult(cache_type_, WRITE_RESULT_LAZY_STREAM_ENTRY_DOOMED);
 329       *out_result = net::ERR_CACHE_WRITE_FAILURE;
 330       return;
 331     }
 332     File::Error error;
 333     if (!MaybeCreateFile(file_index, FILE_REQUIRED, &error)) {
 334       RecordWriteResult(cache_type_, WRITE_RESULT_LAZY_CREATE_FAILURE);
 335       Doom();
 336       *out_result = net::ERR_CACHE_WRITE_FAILURE;
 337       return;
 338     }
 339     CreateEntryResult result;
 340     if (!InitializeCreatedFile(file_index, &result)) {
 341       RecordWriteResult(cache_type_, WRITE_RESULT_LAZY_INITIALIZE_FAILURE);
 342       Doom();
 343       *out_result = net::ERR_CACHE_WRITE_FAILURE;
 344       return;
 345     }
 346   }
 347   DCHECK(!empty_file_omitted_[file_index]);
 348
 349   if (extending_by_write) {
 350     // The EOF record and the eventual stream afterward need to be zeroed out.
 351     const int64 file_eof_offset =
 352         out_entry_stat->GetEOFOffsetInFile(key_, index);
 353     if (!files_[file_index].SetLength(file_eof_offset)) {
 354       RecordWriteResult(cache_type_, WRITE_RESULT_PRETRUNCATE_FAILURE);
 355       Doom();
 356       *out_result = net::ERR_CACHE_WRITE_FAILURE;
 357       return;
 358     }
 359   }
 360   if (buf_len > 0) {
 361     if (files_[file_index].Write(file_offset, in_buf->data(), buf_len) !=
 362         buf_len) {
 363       RecordWriteResult(cache_type_, WRITE_RESULT_WRITE_FAILURE);
 364       Doom();
 365       *out_result = net::ERR_CACHE_WRITE_FAILURE;
 366       return;
 367     }
 368   }
 369   if (!truncate && (buf_len > 0 || !extending_by_write)) {
 370     out_entry_stat->set_data_size(
 371         index, std::max(out_entry_stat->data_size(index), offset + buf_len));
 372   } else {
 373     out_entry_stat->set_data_size(index, offset + buf_len);
 374     int file_eof_offset = out_entry_stat->GetLastEOFOffsetInFile(key_, index);
 375     if (!files_[file_index].SetLength(file_eof_offset)) {
 376       RecordWriteResult(cache_type_, WRITE_RESULT_TRUNCATE_FAILURE);
 377       Doom();
 378       *out_result = net::ERR_CACHE_WRITE_FAILURE;
 379       return;
 380     }
 381   }
 382
 383   RecordWriteResult(cache_type_, WRITE_RESULT_SUCCESS);
 384   base::Time modification_time = Time::Now();
 385   out_entry_stat->set_last_used(modification_time);
 386   out_entry_stat->set_last_modified(modification_time);
 387   *out_result = buf_len;
 388 }
 389
 390 void SimpleSynchronousEntry::ReadSparseData(
 391     const EntryOperationData& in_entry_op,
 392     net::IOBuffer* out_buf,
 393     base::Time* out_last_used,
 394     int* out_result) {
 395   DCHECK(initialized_);
 396   int64 offset = in_entry_op.sparse_offset;
 397   int buf_len = in_entry_op.buf_len;
 398
 399   char* buf = out_buf->data();
 400   int read_so_far = 0;
 401
 402   // Find the first sparse range at or after the requested offset.
 403   SparseRangeIterator it = sparse_ranges_.lower_bound(offset);
 404
 405   if (it != sparse_ranges_.begin()) {
 406     // Hop back one range and read the one overlapping with the start.
 407     --it;
 408     SparseRange* found_range = &it->second;
 409     DCHECK_EQ(it->first, found_range->offset);
 410     if (found_range->offset + found_range->length > offset) {
 411       DCHECK_LE(0, found_range->length);
 412       DCHECK_GE(kint32max, found_range->length);
 413       DCHECK_LE(0, offset - found_range->offset);
 414       DCHECK_GE(kint32max, offset - found_range->offset);
 415       int range_len_after_offset = found_range->length -
 416                                    (offset - found_range->offset);
 417       DCHECK_LE(0, range_len_after_offset);
 418
 419       int len_to_read = std::min(buf_len, range_len_after_offset);
 420       if (!ReadSparseRange(found_range,
 421                            offset - found_range->offset,
 422                            len_to_read,
 423                            buf)) {
 424         *out_result = net::ERR_CACHE_READ_FAILURE;
 425         return;
 426       }
 427       read_so_far += len_to_read;
 428     }
 429     ++it;
 430   }
 431
 432   // Keep reading until the buffer is full or there is not another contiguous
 433   // range.
 434   while (read_so_far < buf_len &&
 435          it != sparse_ranges_.end() &&
 436          it->second.offset == offset + read_so_far) {
 437     SparseRange* found_range = &it->second;
 438     DCHECK_EQ(it->first, found_range->offset);
 439     int range_len = (found_range->length > kint32max) ?
 440                     kint32max : found_range->length;
 441     int len_to_read = std::min(buf_len - read_so_far, range_len);
 442     if (!ReadSparseRange(found_range, 0, len_to_read, buf + read_so_far)) {
 443       *out_result = net::ERR_CACHE_READ_FAILURE;
 444       return;
 445     }
 446     read_so_far += len_to_read;
 447     ++it;
 448   }
 449
 450   *out_result = read_so_far;
 451 }
 452
 453 void SimpleSynchronousEntry::WriteSparseData(
 454     const EntryOperationData& in_entry_op,
 455     net::IOBuffer* in_buf,
 456     int64 max_sparse_data_size,
 457     SimpleEntryStat* out_entry_stat,
 458     int* out_result) {
 459   DCHECK(initialized_);
 460   int64 offset = in_entry_op.sparse_offset;
 461   int buf_len = in_entry_op.buf_len;
 462
 463   const char* buf = in_buf->data();
 464   int written_so_far = 0;
 465   int appended_so_far = 0;
 466
 467   if (!sparse_file_open() && !CreateSparseFile()) {
 468     *out_result = net::ERR_CACHE_WRITE_FAILURE;
 469     return;
 470   }
 471
 472   int64 sparse_data_size = out_entry_stat->sparse_data_size();
 473   // This is a pessimistic estimate; it assumes the entire buffer is going to
 474   // be appended as a new range, not written over existing ranges.
 475   if (sparse_data_size + buf_len > max_sparse_data_size) {
 476     DVLOG(1) << "Truncating sparse data file (" << sparse_data_size << " + "
 477              << buf_len << " > " << max_sparse_data_size << ")";
 478     TruncateSparseFile();
 479   }
 480
 481   SparseRangeIterator it = sparse_ranges_.lower_bound(offset);
 482
 483   if (it != sparse_ranges_.begin()) {
 484     --it;
 485     SparseRange* found_range = &it->second;
 486     if (found_range->offset + found_range->length > offset) {
 487       DCHECK_LE(0, found_range->length);
 488       DCHECK_GE(kint32max, found_range->length);
 489       DCHECK_LE(0, offset - found_range->offset);
 490       DCHECK_GE(kint32max, offset - found_range->offset);
 491       int range_len_after_offset = found_range->length -
 492                                    (offset - found_range->offset);
 493       DCHECK_LE(0, range_len_after_offset);
 494
 495       int len_to_write = std::min(buf_len, range_len_after_offset);
 496       if (!WriteSparseRange(found_range,
 497                             offset - found_range->offset,
 498                             len_to_write,
 499                             buf)) {
 500         *out_result = net::ERR_CACHE_WRITE_FAILURE;
 501         return;
 502       }
 503       written_so_far += len_to_write;
 504     }
 505     ++it;
 506   }
 507
 508   while (written_so_far < buf_len &&
 509          it != sparse_ranges_.end() &&
 510          it->second.offset < offset + buf_len) {
 511     SparseRange* found_range = &it->second;
 512     if (offset + written_so_far < found_range->offset) {
 513       int len_to_append = found_range->offset - (offset + written_so_far);
 514       if (!AppendSparseRange(offset + written_so_far,
 515                              len_to_append,
 516                              buf + written_so_far)) {
 517         *out_result = net::ERR_CACHE_WRITE_FAILURE;
 518         return;
 519       }
 520       written_so_far += len_to_append;
 521       appended_so_far += len_to_append;
 522     }
 523     int range_len = (found_range->length > kint32max) ?
 524                     kint32max : found_range->length;
 525     int len_to_write = std::min(buf_len - written_so_far, range_len);
 526     if (!WriteSparseRange(found_range,
 527                           0,
 528                           len_to_write,
 529                           buf + written_so_far)) {
 530       *out_result = net::ERR_CACHE_WRITE_FAILURE;
 531       return;
 532     }
 533     written_so_far += len_to_write;
 534     ++it;
 535   }
 536
 537   if (written_so_far < buf_len) {
 538     int len_to_append = buf_len - written_so_far;
 539     if (!AppendSparseRange(offset + written_so_far,
 540                            len_to_append,
 541                            buf + written_so_far)) {
 542       *out_result = net::ERR_CACHE_WRITE_FAILURE;
 543       return;
 544     }
 545     written_so_far += len_to_append;
 546     appended_so_far += len_to_append;
 547   }
 548
 549   DCHECK_EQ(buf_len, written_so_far);
 550
 551   base::Time modification_time = Time::Now();
 552   out_entry_stat->set_last_used(modification_time);
 553   out_entry_stat->set_last_modified(modification_time);
 554   int32 old_sparse_data_size = out_entry_stat->sparse_data_size();
 555   out_entry_stat->set_sparse_data_size(old_sparse_data_size + appended_so_far);
 556   *out_result = written_so_far;
 557 }
 558
 559 void SimpleSynchronousEntry::GetAvailableRange(
 560     const EntryOperationData& in_entry_op,
 561     int64* out_start,
 562     int* out_result) {
 563   DCHECK(initialized_);
 564   int64 offset = in_entry_op.sparse_offset;
 565   int len = in_entry_op.buf_len;
 566
 567   SparseRangeIterator it = sparse_ranges_.lower_bound(offset);
 568
 569   int64 start = offset;
 570   int avail_so_far = 0;
 571
 572   if (it != sparse_ranges_.end() && it->second.offset < offset + len)
 573     start = it->second.offset;
 574
 575   if ((it == sparse_ranges_.end() || it->second.offset > offset) &&
 576       it != sparse_ranges_.begin()) {
 577     --it;
 578     if (it->second.offset + it->second.length > offset) {
 579       start = offset;
 580       avail_so_far = (it->second.offset + it->second.length) - offset;
 581     }
 582     ++it;
 583   }
 584
 585   while (start + avail_so_far < offset + len &&
 586          it != sparse_ranges_.end() &&
 587          it->second.offset == start + avail_so_far) {
 588     avail_so_far += it->second.length;
 589     ++it;
 590   }
 591
 592   int len_from_start = len - (start - offset);
 593   *out_start = start;
 594   *out_result = std::min(avail_so_far, len_from_start);
 595 }
 596
 597 void SimpleSynchronousEntry::CheckEOFRecord(int index,
 598                                             const SimpleEntryStat& entry_stat,
 599                                             uint32 expected_crc32,
 600                                             int* out_result) const {
 601   DCHECK(initialized_);
 602   uint32 crc32;
 603   bool has_crc32;
 604   int stream_size;
 605   *out_result =
 606       GetEOFRecordData(index, entry_stat, &has_crc32, &crc32, &stream_size);
 607   if (*out_result != net::OK) {
 608     Doom();
 609     return;
 610   }
 611   if (has_crc32 && crc32 != expected_crc32) {
 612     DVLOG(1) << "EOF record had bad crc.";
 613     *out_result = net::ERR_CACHE_CHECKSUM_MISMATCH;
 614     RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_CRC_MISMATCH);
 615     Doom();
 616     return;
 617   }
 618   RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_SUCCESS);
 619 }
 620
 621 void SimpleSynchronousEntry::Close(
 622     const SimpleEntryStat& entry_stat,
 623     scoped_ptr<std::vector<CRCRecord> > crc32s_to_write,
 624     net::GrowableIOBuffer* stream_0_data) {
 625   DCHECK(stream_0_data);
 626   // Write stream 0 data.
 627   int stream_0_offset = entry_stat.GetOffsetInFile(key_, 0, 0);
 628   if (files_[0].Write(stream_0_offset, stream_0_data->data(),
 629                       entry_stat.data_size(0)) !=
 630       entry_stat.data_size(0)) {
 631     RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE);
 632     DVLOG(1) << "Could not write stream 0 data.";
 633     Doom();
 634   }
 635
 636   for (std::vector<CRCRecord>::const_iterator it = crc32s_to_write->begin();
 637        it != crc32s_to_write->end(); ++it) {
 638     const int stream_index = it->index;
 639     const int file_index = GetFileIndexFromStreamIndex(stream_index);
 640     if (empty_file_omitted_[file_index])
 641       continue;
 642
 643     SimpleFileEOF eof_record;
 644     eof_record.stream_size = entry_stat.data_size(stream_index);
 645     eof_record.final_magic_number = kSimpleFinalMagicNumber;
 646     eof_record.flags = 0;
 647     if (it->has_crc32)
 648       eof_record.flags |= SimpleFileEOF::FLAG_HAS_CRC32;
 649     eof_record.data_crc32 = it->data_crc32;
 650     int eof_offset = entry_stat.GetEOFOffsetInFile(key_, stream_index);
 651     // If stream 0 changed size, the file needs to be resized, otherwise the
 652     // next open will yield wrong stream sizes. On stream 1 and stream 2 proper
 653     // resizing of the file is handled in SimpleSynchronousEntry::WriteData().
 654     if (stream_index == 0 &&
 655         !files_[file_index].SetLength(eof_offset)) {
 656       RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE);
 657       DVLOG(1) << "Could not truncate stream 0 file.";
 658       Doom();
 659       break;
 660     }
 661     if (files_[file_index].Write(eof_offset,
 662                                  reinterpret_cast<const char*>(&eof_record),
 663                                  sizeof(eof_record)) !=
 664         sizeof(eof_record)) {
 665       RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE);
 666       DVLOG(1) << "Could not write eof record.";
 667       Doom();
 668       break;
 669     }
 670   }
 671   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 672     if (empty_file_omitted_[i])
 673       continue;
 674
 675     files_[i].Close();
 676     const int64 file_size = entry_stat.GetFileSize(key_, i);
 677     SIMPLE_CACHE_UMA(CUSTOM_COUNTS,
 678                      "LastClusterSize", cache_type_,
 679                      file_size % 4096, 0, 4097, 50);
 680     const int64 cluster_loss = file_size % 4096 ? 4096 - file_size % 4096 : 0;
 681     SIMPLE_CACHE_UMA(PERCENTAGE,
 682                      "LastClusterLossPercent", cache_type_,
 683                      cluster_loss * 100 / (cluster_loss + file_size));
 684   }
 685
 686   if (sparse_file_open())
 687     sparse_file_.Close();
 688
 689   if (files_created_) {
 690     const int stream2_file_index = GetFileIndexFromStreamIndex(2);
 691     SIMPLE_CACHE_UMA(BOOLEAN, "EntryCreatedAndStream2Omitted", cache_type_,
 692                      empty_file_omitted_[stream2_file_index]);
 693   }
 694   RecordCloseResult(cache_type_, CLOSE_RESULT_SUCCESS);
 695   have_open_files_ = false;
 696   delete this;
 697 }
 698
 699 SimpleSynchronousEntry::SimpleSynchronousEntry(net::CacheType cache_type,
 700                                                const FilePath& path,
 701                                                const std::string& key,
 702                                                const uint64 entry_hash)
 703     : cache_type_(cache_type),
 704       path_(path),
 705       entry_hash_(entry_hash),
 706       key_(key),
 707       have_open_files_(false),
 708       initialized_(false) {
 709   for (int i = 0; i < kSimpleEntryFileCount; ++i)
 710     empty_file_omitted_[i] = false;
 711 }
 712
 713 SimpleSynchronousEntry::~SimpleSynchronousEntry() {
 714   DCHECK(!(have_open_files_ && initialized_));
 715   if (have_open_files_)
 716     CloseFiles();
 717 }
 718
 719 bool SimpleSynchronousEntry::MaybeOpenFile(
 720     int file_index,
 721     File::Error* out_error) {
 722   DCHECK(out_error);
 723
 724   FilePath filename = GetFilenameFromFileIndex(file_index);
 725   int flags = File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE;
 726   files_[file_index].Initialize(filename, flags);
 727   *out_error = files_[file_index].error_details();
 728
 729   if (CanOmitEmptyFile(file_index) && !files_[file_index].IsValid() &&
 730       *out_error == File::FILE_ERROR_NOT_FOUND) {
 731     empty_file_omitted_[file_index] = true;
 732     return true;
 733   }
 734
 735   return files_[file_index].IsValid();
 736 }
 737
 738 bool SimpleSynchronousEntry::MaybeCreateFile(
 739     int file_index,
 740     FileRequired file_required,
 741     File::Error* out_error) {
 742   DCHECK(out_error);
 743
 744   if (CanOmitEmptyFile(file_index) && file_required == FILE_NOT_REQUIRED) {
 745     empty_file_omitted_[file_index] = true;
 746     return true;
 747   }
 748
 749   FilePath filename = GetFilenameFromFileIndex(file_index);
 750   int flags = File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE;
 751   files_[file_index].Initialize(filename, flags);
 752   *out_error = files_[file_index].error_details();
 753
 754   empty_file_omitted_[file_index] = false;
 755
 756   return files_[file_index].IsValid();
 757 }
 758
 759 bool SimpleSynchronousEntry::OpenFiles(
 760     bool had_index,
 761     SimpleEntryStat* out_entry_stat) {
 762   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 763     File::Error error;
 764     if (!MaybeOpenFile(i, &error)) {
 765       // TODO(ttuttle,gavinp): Remove one each of these triplets of histograms.
 766       // We can calculate the third as the sum or difference of the other two.
 767       RecordSyncOpenResult(
 768           cache_type_, OPEN_ENTRY_PLATFORM_FILE_ERROR, had_index);
 769       SIMPLE_CACHE_UMA(ENUMERATION,
 770                        "SyncOpenPlatformFileError", cache_type_,
 771                        -error, -base::File::FILE_ERROR_MAX);
 772       if (had_index) {
 773         SIMPLE_CACHE_UMA(ENUMERATION,
 774                          "SyncOpenPlatformFileError_WithIndex", cache_type_,
 775                          -error, -base::File::FILE_ERROR_MAX);
 776       } else {
 777         SIMPLE_CACHE_UMA(ENUMERATION,
 778                          "SyncOpenPlatformFileError_WithoutIndex",
 779                          cache_type_,
 780                          -error, -base::File::FILE_ERROR_MAX);
 781       }
 782       while (--i >= 0)
 783         CloseFile(i);
 784       return false;
 785     }
 786   }
 787
 788   have_open_files_ = true;
 789
 790   base::TimeDelta entry_age = base::Time::Now() - base::Time::UnixEpoch();
 791   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 792     if (empty_file_omitted_[i]) {
 793       out_entry_stat->set_data_size(i + 1, 0);
 794       continue;
 795     }
 796
 797     File::Info file_info;
 798     bool success = files_[i].GetInfo(&file_info);
 799     base::Time file_last_modified;
 800     if (!success) {
 801       DLOG(WARNING) << "Could not get platform file info.";
 802       continue;
 803     }
 804     out_entry_stat->set_last_used(file_info.last_accessed);
 805     if (simple_util::GetMTime(path_, &file_last_modified))
 806       out_entry_stat->set_last_modified(file_last_modified);
 807     else
 808       out_entry_stat->set_last_modified(file_info.last_modified);
 809
 810     base::TimeDelta stream_age =
 811         base::Time::Now() - out_entry_stat->last_modified();
 812     if (stream_age < entry_age)
 813       entry_age = stream_age;
 814
 815     // Two things prevent from knowing the right values for |data_size|:
 816     // 1) The key is not known, hence its length is unknown.
 817     // 2) Stream 0 and stream 1 are in the same file, and the exact size for
 818     // each will only be known when reading the EOF record for stream 0.
 819     //
 820     // The size for file 0 and 1 is temporarily kept in
 821     // |data_size(1)| and |data_size(2)| respectively. Reading the key in
 822     // InitializeForOpen yields the data size for each file. In the case of
 823     // file hash_1, this is the total size of stream 2, and is assigned to
 824     // data_size(2). In the case of file 0, it is the combined size of stream
 825     // 0, stream 1 and one EOF record. The exact distribution of sizes between
 826     // stream 1 and stream 0 is only determined after reading the EOF record
 827     // for stream 0 in ReadAndValidateStream0.
 828     out_entry_stat->set_data_size(i + 1, file_info.size);
 829   }
 830   SIMPLE_CACHE_UMA(CUSTOM_COUNTS,
 831                    "SyncOpenEntryAge", cache_type_,
 832                    entry_age.InHours(), 1, 1000, 50);
 833
 834   files_created_ = false;
 835
 836   return true;
 837 }
 838
 839 bool SimpleSynchronousEntry::CreateFiles(
 840     bool had_index,
 841     SimpleEntryStat* out_entry_stat) {
 842   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 843     File::Error error;
 844     if (!MaybeCreateFile(i, FILE_NOT_REQUIRED, &error)) {
 845       // TODO(ttuttle,gavinp): Remove one each of these triplets of histograms.
 846       // We can calculate the third as the sum or difference of the other two.
 847       RecordSyncCreateResult(CREATE_ENTRY_PLATFORM_FILE_ERROR, had_index);
 848       SIMPLE_CACHE_UMA(ENUMERATION,
 849                        "SyncCreatePlatformFileError", cache_type_,
 850                        -error, -base::File::FILE_ERROR_MAX);
 851       if (had_index) {
 852         SIMPLE_CACHE_UMA(ENUMERATION,
 853                          "SyncCreatePlatformFileError_WithIndex", cache_type_,
 854                          -error, -base::File::FILE_ERROR_MAX);
 855       } else {
 856         SIMPLE_CACHE_UMA(ENUMERATION,
 857                          "SyncCreatePlatformFileError_WithoutIndex",
 858                          cache_type_,
 859                          -error, -base::File::FILE_ERROR_MAX);
 860       }
 861       while (--i >= 0)
 862         CloseFile(i);
 863       return false;
 864     }
 865   }
 866
 867   have_open_files_ = true;
 868
 869   base::Time creation_time = Time::Now();
 870   out_entry_stat->set_last_modified(creation_time);
 871   out_entry_stat->set_last_used(creation_time);
 872   for (int i = 0; i < kSimpleEntryStreamCount; ++i)
 873       out_entry_stat->set_data_size(i, 0);
 874
 875   files_created_ = true;
 876
 877   return true;
 878 }
 879
 880 void SimpleSynchronousEntry::CloseFile(int index) {
 881   if (empty_file_omitted_[index]) {
 882     empty_file_omitted_[index] = false;
 883   } else {
 884     DCHECK(files_[index].IsValid());
 885     files_[index].Close();
 886   }
 887
 888   if (sparse_file_open())
 889     CloseSparseFile();
 890 }
 891
 892 void SimpleSynchronousEntry::CloseFiles() {
 893   for (int i = 0; i < kSimpleEntryFileCount; ++i)
 894     CloseFile(i);
 895 }
 896
 897 int SimpleSynchronousEntry::InitializeForOpen(
 898     bool had_index,
 899     SimpleEntryStat* out_entry_stat,
 900     scoped_refptr<net::GrowableIOBuffer>* stream_0_data,
 901     uint32* out_stream_0_crc32) {
 902   DCHECK(!initialized_);
 903   if (!OpenFiles(had_index, out_entry_stat)) {
 904     DLOG(WARNING) << "Could not open platform files for entry.";
 905     return net::ERR_FAILED;
 906   }
 907   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
 908     if (empty_file_omitted_[i])
 909       continue;
 910
 911     SimpleFileHeader header;
 912     int header_read_result =
 913         files_[i].Read(0, reinterpret_cast<char*>(&header), sizeof(header));
 914     if (header_read_result != sizeof(header)) {
 915       DLOG(WARNING) << "Cannot read header from entry.";
 916       RecordSyncOpenResult(cache_type_, OPEN_ENTRY_CANT_READ_HEADER, had_index);
 917       return net::ERR_FAILED;
 918     }
 919
 920     if (header.initial_magic_number != kSimpleInitialMagicNumber) {
 921       // TODO(gavinp): This seems very bad; for now we log at WARNING, but we
 922       // should give consideration to not saturating the log with these if that
 923       // becomes a problem.
 924       DLOG(WARNING) << "Magic number did not match.";
 925       RecordSyncOpenResult(cache_type_, OPEN_ENTRY_BAD_MAGIC_NUMBER, had_index);
 926       return net::ERR_FAILED;
 927     }
 928
 929     if (header.version != kSimpleEntryVersionOnDisk) {
 930       DLOG(WARNING) << "Unreadable version.";
 931       RecordSyncOpenResult(cache_type_, OPEN_ENTRY_BAD_VERSION, had_index);
 932       return net::ERR_FAILED;
 933     }
 934
 935     scoped_ptr<char[]> key(new char[header.key_length]);
 936     int key_read_result = files_[i].Read(sizeof(header), key.get(),
 937                                          header.key_length);
 938     if (key_read_result != implicit_cast<int>(header.key_length)) {
 939       DLOG(WARNING) << "Cannot read key from entry.";
 940       RecordSyncOpenResult(cache_type_, OPEN_ENTRY_CANT_READ_KEY, had_index);
 941       return net::ERR_FAILED;
 942     }
 943
 944     key_ = std::string(key.get(), header.key_length);
 945     if (i == 0) {
 946       // File size for stream 0 has been stored temporarily in data_size[1].
 947       int total_data_size =
 948           GetDataSizeFromKeyAndFileSize(key_, out_entry_stat->data_size(1));
 949       int ret_value_stream_0 = ReadAndValidateStream0(
 950           total_data_size, out_entry_stat, stream_0_data, out_stream_0_crc32);
 951       if (ret_value_stream_0 != net::OK)
 952         return ret_value_stream_0;
 953     } else {
 954       out_entry_stat->set_data_size(
 955           2, GetDataSizeFromKeyAndFileSize(key_, out_entry_stat->data_size(2)));
 956       if (out_entry_stat->data_size(2) < 0) {
 957         DLOG(WARNING) << "Stream 2 file is too small.";
 958         return net::ERR_FAILED;
 959       }
 960     }
 961
 962     if (base::Hash(key.get(), header.key_length) != header.key_hash) {
 963       DLOG(WARNING) << "Hash mismatch on key.";
 964       RecordSyncOpenResult(
 965           cache_type_, OPEN_ENTRY_KEY_HASH_MISMATCH, had_index);
 966       return net::ERR_FAILED;
 967     }
 968   }
 969
 970   int32 sparse_data_size = 0;
 971   if (!OpenSparseFileIfExists(&sparse_data_size)) {
 972     RecordSyncOpenResult(
 973         cache_type_, OPEN_ENTRY_SPARSE_OPEN_FAILED, had_index);
 974     return net::ERR_FAILED;
 975   }
 976   out_entry_stat->set_sparse_data_size(sparse_data_size);
 977
 978   bool removed_stream2 = false;
 979   const int stream2_file_index = GetFileIndexFromStreamIndex(2);
 980   DCHECK(CanOmitEmptyFile(stream2_file_index));
 981   if (!empty_file_omitted_[stream2_file_index] &&
 982       out_entry_stat->data_size(2) == 0) {
 983     DVLOG(1) << "Removing empty stream 2 file.";
 984     CloseFile(stream2_file_index);
 985     DeleteFileForEntryHash(path_, entry_hash_, stream2_file_index);
 986     empty_file_omitted_[stream2_file_index] = true;
 987     removed_stream2 = true;
 988   }
 989
 990   SIMPLE_CACHE_UMA(BOOLEAN, "EntryOpenedAndStream2Removed", cache_type_,
 991                    removed_stream2);
 992
 993   RecordSyncOpenResult(cache_type_, OPEN_ENTRY_SUCCESS, had_index);
 994   initialized_ = true;
 995   return net::OK;
 996 }
 997
 998 bool SimpleSynchronousEntry::InitializeCreatedFile(
 999     int file_index,
1000     CreateEntryResult* out_result) {
1001   SimpleFileHeader header;
1002   header.initial_magic_number = kSimpleInitialMagicNumber;
1003   header.version = kSimpleEntryVersionOnDisk;
1004
1005   header.key_length = key_.size();
1006   header.key_hash = base::Hash(key_);
1007
1008   int bytes_written = files_[file_index].Write(
1009       0, reinterpret_cast<char*>(&header), sizeof(header));
1010   if (bytes_written != sizeof(header)) {
1011     *out_result = CREATE_ENTRY_CANT_WRITE_HEADER;
1012     return false;
1013   }
1014
1015   bytes_written = files_[file_index].Write(sizeof(header), key_.data(),
1016                                            key_.size());
1017   if (bytes_written != implicit_cast<int>(key_.size())) {
1018     *out_result = CREATE_ENTRY_CANT_WRITE_KEY;
1019     return false;
1020   }
1021
1022   return true;
1023 }
1024
1025 int SimpleSynchronousEntry::InitializeForCreate(
1026     bool had_index,
1027     SimpleEntryStat* out_entry_stat) {
1028   DCHECK(!initialized_);
1029   if (!CreateFiles(had_index, out_entry_stat)) {
1030     DLOG(WARNING) << "Could not create platform files.";
1031     return net::ERR_FILE_EXISTS;
1032   }
1033   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
1034     if (empty_file_omitted_[i])
1035       continue;
1036
1037     CreateEntryResult result;
1038     if (!InitializeCreatedFile(i, &result)) {
1039       RecordSyncCreateResult(result, had_index);
1040       return net::ERR_FAILED;
1041     }
1042   }
1043   RecordSyncCreateResult(CREATE_ENTRY_SUCCESS, had_index);
1044   initialized_ = true;
1045   return net::OK;
1046 }
1047
1048 int SimpleSynchronousEntry::ReadAndValidateStream0(
1049     int total_data_size,
1050     SimpleEntryStat* out_entry_stat,
1051     scoped_refptr<net::GrowableIOBuffer>* stream_0_data,
1052     uint32* out_stream_0_crc32) const {
1053   // Temporarily assign all the data size to stream 1 in order to read the
1054   // EOF record for stream 0, which contains the size of stream 0.
1055   out_entry_stat->set_data_size(0, 0);
1056   out_entry_stat->set_data_size(1, total_data_size - sizeof(SimpleFileEOF));
1057
1058   bool has_crc32;
1059   uint32 read_crc32;
1060   int stream_0_size;
1061   int ret_value_crc32 = GetEOFRecordData(
1062       0, *out_entry_stat, &has_crc32, &read_crc32, &stream_0_size);
1063   if (ret_value_crc32 != net::OK)
1064     return ret_value_crc32;
1065
1066   if (stream_0_size > out_entry_stat->data_size(1))
1067     return net::ERR_FAILED;
1068
1069   // These are the real values of data size.
1070   out_entry_stat->set_data_size(0, stream_0_size);
1071   out_entry_stat->set_data_size(
1072       1, out_entry_stat->data_size(1) - stream_0_size);
1073
1074   // Put stream 0 data in memory.
1075   *stream_0_data = new net::GrowableIOBuffer();
1076   (*stream_0_data)->SetCapacity(stream_0_size);
1077   int file_offset = out_entry_stat->GetOffsetInFile(key_, 0, 0);
1078   File* file = const_cast<File*>(&files_[0]);
1079   int bytes_read =
1080       file->Read(file_offset, (*stream_0_data)->data(), stream_0_size);
1081   if (bytes_read != stream_0_size)
1082     return net::ERR_FAILED;
1083
1084   // Check the CRC32.
1085   uint32 expected_crc32 =
1086       stream_0_size == 0
1087           ? crc32(0, Z_NULL, 0)
1088           : crc32(crc32(0, Z_NULL, 0),
1089                   reinterpret_cast<const Bytef*>((*stream_0_data)->data()),
1090                   stream_0_size);
1091   if (has_crc32 && read_crc32 != expected_crc32) {
1092     DVLOG(1) << "EOF record had bad crc.";
1093     RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_CRC_MISMATCH);
1094     return net::ERR_FAILED;
1095   }
1096   *out_stream_0_crc32 = expected_crc32;
1097   RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_SUCCESS);
1098   return net::OK;
1099 }
1100
1101 int SimpleSynchronousEntry::GetEOFRecordData(int index,
1102                                              const SimpleEntryStat& entry_stat,
1103                                              bool* out_has_crc32,
1104                                              uint32* out_crc32,
1105                                              int* out_data_size) const {
1106   SimpleFileEOF eof_record;
1107   int file_offset = entry_stat.GetEOFOffsetInFile(key_, index);
1108   int file_index = GetFileIndexFromStreamIndex(index);
1109   File* file = const_cast<File*>(&files_[file_index]);
1110   if (file->Read(file_offset, reinterpret_cast<char*>(&eof_record),
1111                  sizeof(eof_record)) !=
1112       sizeof(eof_record)) {
1113     RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_READ_FAILURE);
1114     return net::ERR_CACHE_CHECKSUM_READ_FAILURE;
1115   }
1116
1117   if (eof_record.final_magic_number != kSimpleFinalMagicNumber) {
1118     RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_MAGIC_NUMBER_MISMATCH);
1119     DVLOG(1) << "EOF record had bad magic number.";
1120     return net::ERR_CACHE_CHECKSUM_READ_FAILURE;
1121   }
1122
1123   *out_has_crc32 = (eof_record.flags & SimpleFileEOF::FLAG_HAS_CRC32) ==
1124                    SimpleFileEOF::FLAG_HAS_CRC32;
1125   *out_crc32 = eof_record.data_crc32;
1126   *out_data_size = eof_record.stream_size;
1127   SIMPLE_CACHE_UMA(BOOLEAN, "SyncCheckEOFHasCrc", cache_type_, *out_has_crc32);
1128   return net::OK;
1129 }
1130
1131 void SimpleSynchronousEntry::Doom() const {
1132   DeleteFilesForEntryHash(path_, entry_hash_);
1133 }
1134
1135 // static
1136 bool SimpleSynchronousEntry::DeleteFileForEntryHash(
1137     const FilePath& path,
1138     const uint64 entry_hash,
1139     const int file_index) {
1140   FilePath to_delete = path.AppendASCII(
1141       GetFilenameFromEntryHashAndFileIndex(entry_hash, file_index));
1142   return base::DeleteFile(to_delete, false);
1143 }
1144
1145 // static
1146 bool SimpleSynchronousEntry::DeleteFilesForEntryHash(
1147     const FilePath& path,
1148     const uint64 entry_hash) {
1149   bool result = true;
1150   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
1151     if (!DeleteFileForEntryHash(path, entry_hash, i) && !CanOmitEmptyFile(i))
1152       result = false;
1153   }
1154   FilePath to_delete = path.AppendASCII(
1155       GetSparseFilenameFromEntryHash(entry_hash));
1156   base::DeleteFile(to_delete, false);
1157   return result;
1158 }
1159
1160 void SimpleSynchronousEntry::RecordSyncCreateResult(CreateEntryResult result,
1161                                                     bool had_index) {
1162   DCHECK_GT(CREATE_ENTRY_MAX, result);
1163   SIMPLE_CACHE_UMA(ENUMERATION,
1164                    "SyncCreateResult", cache_type_, result, CREATE_ENTRY_MAX);
1165   if (had_index) {
1166     SIMPLE_CACHE_UMA(ENUMERATION,
1167                      "SyncCreateResult_WithIndex", cache_type_,
1168                      result, CREATE_ENTRY_MAX);
1169   } else {
1170     SIMPLE_CACHE_UMA(ENUMERATION,
1171                      "SyncCreateResult_WithoutIndex", cache_type_,
1172                      result, CREATE_ENTRY_MAX);
1173   }
1174 }
1175
1176 FilePath SimpleSynchronousEntry::GetFilenameFromFileIndex(int file_index) {
1177   return path_.AppendASCII(
1178       GetFilenameFromEntryHashAndFileIndex(entry_hash_, file_index));
1179 }
1180
1181 bool SimpleSynchronousEntry::OpenSparseFileIfExists(
1182     int32* out_sparse_data_size) {
1183   DCHECK(!sparse_file_open());
1184
1185   FilePath filename = path_.AppendASCII(
1186       GetSparseFilenameFromEntryHash(entry_hash_));
1187   int flags = File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE;
1188   sparse_file_.Initialize(filename, flags);
1189   if (sparse_file_.IsValid())
1190     return ScanSparseFile(out_sparse_data_size);
1191
1192   return sparse_file_.error_details() == File::FILE_ERROR_NOT_FOUND;
1193 }
1194
1195 bool SimpleSynchronousEntry::CreateSparseFile() {
1196   DCHECK(!sparse_file_open());
1197
1198   FilePath filename = path_.AppendASCII(
1199       GetSparseFilenameFromEntryHash(entry_hash_));
1200   int flags = File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE;
1201   sparse_file_.Initialize(filename, flags);
1202   if (!sparse_file_.IsValid())
1203     return false;
1204
1205   return InitializeSparseFile();
1206 }
1207
1208 void SimpleSynchronousEntry::CloseSparseFile() {
1209   DCHECK(sparse_file_open());
1210   sparse_file_.Close();
1211 }
1212
1213 bool SimpleSynchronousEntry::TruncateSparseFile() {
1214   DCHECK(sparse_file_open());
1215
1216   int64 header_and_key_length = sizeof(SimpleFileHeader) + key_.size();
1217   if (!sparse_file_.SetLength(header_and_key_length)) {
1218     DLOG(WARNING) << "Could not truncate sparse file";
1219     return false;
1220   }
1221
1222   sparse_ranges_.clear();
1223
1224   return true;
1225 }
1226
1227 bool SimpleSynchronousEntry::InitializeSparseFile() {
1228   DCHECK(sparse_file_open());
1229
1230   SimpleFileHeader header;
1231   header.initial_magic_number = kSimpleInitialMagicNumber;
1232   header.version = kSimpleVersion;
1233   header.key_length = key_.size();
1234   header.key_hash = base::Hash(key_);
1235
1236   int header_write_result =
1237       sparse_file_.Write(0, reinterpret_cast<char*>(&header), sizeof(header));
1238   if (header_write_result != sizeof(header)) {
1239     DLOG(WARNING) << "Could not write sparse file header";
1240     return false;
1241   }
1242
1243   int key_write_result = sparse_file_.Write(sizeof(header), key_.data(),
1244                                             key_.size());
1245   if (key_write_result != implicit_cast<int>(key_.size())) {
1246     DLOG(WARNING) << "Could not write sparse file key";
1247     return false;
1248   }
1249
1250   sparse_ranges_.clear();
1251   sparse_tail_offset_ = sizeof(header) + key_.size();
1252
1253   return true;
1254 }
1255
1256 bool SimpleSynchronousEntry::ScanSparseFile(int32* out_sparse_data_size) {
1257   DCHECK(sparse_file_open());
1258
1259   int32 sparse_data_size = 0;
1260
1261   SimpleFileHeader header;
1262   int header_read_result =
1263       sparse_file_.Read(0, reinterpret_cast<char*>(&header), sizeof(header));
1264   if (header_read_result != sizeof(header)) {
1265     DLOG(WARNING) << "Could not read header from sparse file.";
1266     return false;
1267   }
1268
1269   if (header.initial_magic_number != kSimpleInitialMagicNumber) {
1270     DLOG(WARNING) << "Sparse file magic number did not match.";
1271     return false;
1272   }
1273
1274   if (header.version != kSimpleVersion) {
1275     DLOG(WARNING) << "Sparse file unreadable version.";
1276     return false;
1277   }
1278
1279   sparse_ranges_.clear();
1280
1281   int64 range_header_offset = sizeof(header) + key_.size();
1282   while (1) {
1283     SimpleFileSparseRangeHeader range_header;
1284     int range_header_read_result =
1285         sparse_file_.Read(range_header_offset,
1286                           reinterpret_cast<char*>(&range_header),
1287                           sizeof(range_header));
1288     if (range_header_read_result == 0)
1289       break;
1290     if (range_header_read_result != sizeof(range_header)) {
1291       DLOG(WARNING) << "Could not read sparse range header.";
1292       return false;
1293     }
1294
1295     if (range_header.sparse_range_magic_number !=
1296         kSimpleSparseRangeMagicNumber) {
1297       DLOG(WARNING) << "Invalid sparse range header magic number.";
1298       return false;
1299     }
1300
1301     SparseRange range;
1302     range.offset = range_header.offset;
1303     range.length = range_header.length;
1304     range.data_crc32 = range_header.data_crc32;
1305     range.file_offset = range_header_offset + sizeof(range_header);
1306     sparse_ranges_.insert(std::make_pair(range.offset, range));
1307
1308     range_header_offset += sizeof(range_header) + range.length;
1309
1310     DCHECK_LE(sparse_data_size, sparse_data_size + range.length);
1311     sparse_data_size += range.length;
1312   }
1313
1314   *out_sparse_data_size = sparse_data_size;
1315   sparse_tail_offset_ = range_header_offset;
1316
1317   return true;
1318 }
1319
1320 bool SimpleSynchronousEntry::ReadSparseRange(const SparseRange* range,
1321                                              int offset, int len, char* buf) {
1322   DCHECK(range);
1323   DCHECK(buf);
1324   DCHECK_GE(range->length, offset);
1325   DCHECK_GE(range->length, offset + len);
1326
1327   int bytes_read = sparse_file_.Read(range->file_offset + offset, buf, len);
1328   if (bytes_read < len) {
1329     DLOG(WARNING) << "Could not read sparse range.";
1330     return false;
1331   }
1332
1333   // If we read the whole range and we have a crc32, check it.
1334   if (offset == 0 && len == range->length && range->data_crc32 != 0) {
1335     uint32 actual_crc32 = crc32(crc32(0L, Z_NULL, 0),
1336                                 reinterpret_cast<const Bytef*>(buf),
1337                                 len);
1338     if (actual_crc32 != range->data_crc32) {
1339       DLOG(WARNING) << "Sparse range crc32 mismatch.";
1340       return false;
1341     }
1342   }
1343   // TODO(ttuttle): Incremental crc32 calculation?
1344
1345   return true;
1346 }
1347
1348 bool SimpleSynchronousEntry::WriteSparseRange(SparseRange* range,
1349                                               int offset, int len,
1350                                               const char* buf) {
1351   DCHECK(range);
1352   DCHECK(buf);
1353   DCHECK_GE(range->length, offset);
1354   DCHECK_GE(range->length, offset + len);
1355
1356   uint32 new_crc32 = 0;
1357   if (offset == 0 && len == range->length) {
1358     new_crc32 = crc32(crc32(0L, Z_NULL, 0),
1359                       reinterpret_cast<const Bytef*>(buf),
1360                       len);
1361   }
1362
1363   if (new_crc32 != range->data_crc32) {
1364     range->data_crc32 = new_crc32;
1365
1366     SimpleFileSparseRangeHeader header;
1367     header.sparse_range_magic_number = kSimpleSparseRangeMagicNumber;
1368     header.offset = range->offset;
1369     header.length = range->length;
1370     header.data_crc32 = range->data_crc32;
1371
1372     int bytes_written = sparse_file_.Write(range->file_offset - sizeof(header),
1373                                            reinterpret_cast<char*>(&header),
1374                                            sizeof(header));
1375     if (bytes_written != implicit_cast<int>(sizeof(header))) {
1376       DLOG(WARNING) << "Could not rewrite sparse range header.";
1377       return false;
1378     }
1379   }
1380
1381   int bytes_written = sparse_file_.Write(range->file_offset + offset, buf, len);
1382   if (bytes_written < len) {
1383     DLOG(WARNING) << "Could not write sparse range.";
1384     return false;
1385   }
1386
1387   return true;
1388 }
1389
1390 bool SimpleSynchronousEntry::AppendSparseRange(int64 offset,
1391                                                int len,
1392                                                const char* buf) {
1393   DCHECK_LE(0, offset);
1394   DCHECK_LT(0, len);
1395   DCHECK(buf);
1396
1397   uint32 data_crc32 = crc32(crc32(0L, Z_NULL, 0),
1398                             reinterpret_cast<const Bytef*>(buf),
1399                             len);
1400
1401   SimpleFileSparseRangeHeader header;
1402   header.sparse_range_magic_number = kSimpleSparseRangeMagicNumber;
1403   header.offset = offset;
1404   header.length = len;
1405   header.data_crc32 = data_crc32;
1406
1407   int bytes_written = sparse_file_.Write(sparse_tail_offset_,
1408                                          reinterpret_cast<char*>(&header),
1409                                          sizeof(header));
1410   if (bytes_written != implicit_cast<int>(sizeof(header))) {
1411     DLOG(WARNING) << "Could not append sparse range header.";
1412     return false;
1413   }
1414   sparse_tail_offset_ += bytes_written;
1415
1416   bytes_written = sparse_file_.Write(sparse_tail_offset_, buf, len);
1417   if (bytes_written < len) {
1418     DLOG(WARNING) << "Could not append sparse range data.";
1419     return false;
1420   }
1421   int64 data_file_offset = sparse_tail_offset_;
1422   sparse_tail_offset_ += bytes_written;
1423
1424   SparseRange range;
1425   range.offset = offset;
1426   range.length = len;
1427   range.data_crc32 = data_crc32;
1428   range.file_offset = data_file_offset;
1429   sparse_ranges_.insert(std::make_pair(offset, range));
1430
1431   return true;
1432 }
1433
1434 }  // namespace disk_cache