Disk cache v3 ref2

net/disk_cache/backend_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/disk_cache/backend_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 266 matching lines @@
   // the id cannot be zero, because that value is used as "not dirty".
   // Increasing the value once per second gives us many years before we start
   // having collisions.
   data_->header.this_id++;
   if (!data_->header.this_id)
     data_->header.this_id++;
 
   bool previous_crash = (data_->header.crash != 0);
   data_->header.crash = 1;
 
-  if (!block_files_.Init(create_files))
+  if (!block_files_.Init(create_files, kFirstAdditionalBlockFile))
     return net::ERR_FAILED;
 
   // We want to minimize the changes to cache for an AppCache.
   if (cache_type() == net::APP_CACHE) {
     DCHECK(!new_eviction_);
     read_only_ = true;
   } else if (cache_type() == net::SHADER_CACHE) {
     DCHECK(!new_eviction_);
   }
 
@@ skipping 839 matching lines @@
     LOG(ERROR) << "Number of entries mismatch";
 #if !defined(NET_BUILD_STRESS_CACHE)
     return ERR_NUM_ENTRIES_MISMATCH;
 #endif
   }
 
   return CheckAllEntries();
 }
 
 void BackendImpl::FlushIndex() {
-  if (index_.get() && !disabled_)
+  if (index_ && !disabled_)
     index_->Flush();
 }
 
 // ------------------------------------------------------------------------
 
 net::CacheType BackendImpl::GetCacheType() const {
   return cache_type_;
 }
 
 int32 BackendImpl::GetEntryCount() const {
-  if (!index_.get() || disabled_)
+  if (!index_ || disabled_)
     return 0;
   // num_entries includes entries already evicted.
   int32 not_deleted = data_->header.num_entries -
                       data_->header.lru.sizes[Rankings::DELETED];
 
   if (not_deleted < 0) {
     NOTREACHED();
     not_deleted = 0;
   }
 
@@ skipping 398 matching lines @@
     int error = NewEntry(address, &tmp);
     cache_entry.swap(&tmp);
 
     if (error || cache_entry->dirty()) {
       // This entry is dirty on disk (it was not properly closed): we cannot
       // trust it.
       Addr child(0);
       if (!error)
         child.set_value(cache_entry->GetNextAddress());
 
-      if (parent_entry.get()) {
+      if (parent_entry) {
         parent_entry->SetNextAddress(child);
         parent_entry = NULL;
       } else {
         data_->table[hash & mask_] = child.value();
       }
 
       Trace("MatchEntry dirty %d 0x%x 0x%x", find_parent, entry_addr.value(),
             address.value());
 
       if (!error) {
@@ skipping 20 matching lines @@
         Trace("Entry not on the index 0x%x", address.value());
         *match_error = true;
         parent_entry = NULL;
       }
       break;
     }
     if (!cache_entry->Update())
       cache_entry = NULL;
     parent_entry = cache_entry;
     cache_entry = NULL;
-    if (!parent_entry.get())
+    if (!parent_entry)
       break;
 
     address.set_value(parent_entry->GetNextAddress());
   }
 
-  if (parent_entry.get() && (!find_parent || !found))
+  if (parent_entry && (!find_parent || !found))
     parent_entry = NULL;
 
-  if (find_parent && entry_addr.is_initialized() && !cache_entry.get()) {
+  if (find_parent && entry_addr.is_initialized() && !cache_entry) {
     *match_error = true;
     parent_entry = NULL;
   }
 
-  if (cache_entry.get() && (find_parent || !found))
+  if (cache_entry && (find_parent || !found))
     cache_entry = NULL;
 
   find_parent ? parent_entry.swap(&tmp) : cache_entry.swap(&tmp);
   FlushIndex();
   return tmp;
 }
 
 // This is the actual implementation for OpenNextEntry and OpenPrevEntry.
 EntryImpl* BackendImpl::OpenFollowingEntry(bool forward, void** iter) {
   if (disabled_)
@@ skipping 469 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache