Appcache::OnCorruptionDetected handling

webkit/browser/appcache/appcache_disk_cache.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 "webkit/browser/appcache/appcache_disk_cache.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 31 matching lines @@
   ~CreateBackendCallbackShim() {
   }
 
   AppCacheDiskCache* appcache_diskcache_;  // Unowned pointer.
 };
 
 // An implementation of AppCacheDiskCacheInterface::Entry that's a thin
 // wrapper around disk_cache::Entry.
 class AppCacheDiskCache::EntryImpl : public Entry {
  public:
-  explicit EntryImpl(disk_cache::Entry* disk_cache_entry)
-      : disk_cache_entry_(disk_cache_entry) {
+  EntryImpl(disk_cache::Entry* disk_cache_entry,
+            AppCacheDiskCache* owner )
+      : disk_cache_entry_(disk_cache_entry), owner_(owner) {
     DCHECK(disk_cache_entry);
+    DCHECK(owner);
+    owner_->AddOpenEntry(this);
   }
 
   // Entry implementation.
   virtual int Read(int index, int64 offset, net::IOBuffer* buf, int buf_len,
                    const net::CompletionCallback& callback) OVERRIDE {
     if (offset < 0 || offset > kint32max)
       return net::ERR_INVALID_ARGUMENT;
+    if (!disk_cache_entry_)
+      return net::ERR_ABORTED;
     return disk_cache_entry_->ReadData(
         index, static_cast<int>(offset), buf, buf_len, callback);
   }
 
   virtual int Write(int index, int64 offset, net::IOBuffer* buf, int buf_len,
                     const net::CompletionCallback& callback) OVERRIDE {
     if (offset < 0 || offset > kint32max)
       return net::ERR_INVALID_ARGUMENT;
+    if (!disk_cache_entry_)
+      return net::ERR_ABORTED;
     const bool kTruncate = true;
     return disk_cache_entry_->WriteData(
         index, static_cast<int>(offset), buf, buf_len, callback, kTruncate);
   }
 
   virtual int64 GetSize(int index) OVERRIDE {
-    return disk_cache_entry_->GetDataSize(index);
+    return disk_cache_entry_? disk_cache_entry_->GetDataSize(index) : 0L;

[jsbell, 2014/01/24 21:13:44]

nit: space between _ and ?

[michaeln, 2014/01/28 22:12:16]

Done.

   }
 
   virtual void Close() OVERRIDE {
-    disk_cache_entry_->Close();
+    if (disk_cache_entry_)
+      disk_cache_entry_->Close();
     delete this;
   }
 
+  void Abandon() {
+    owner_ = NULL;
+    disk_cache_entry_->Close();
+    disk_cache_entry_ = NULL;
+  }
+
  private:
+  virtual ~EntryImpl() {
+    if (owner_)
+      owner_->RemoveOpenEntry(this);
+  }
+
   disk_cache::Entry* disk_cache_entry_;
+  AppCacheDiskCache* owner_;
 };
 
 // Separate object to hold state for each Create, Delete, or Doom call
 // while the call is in-flight and to produce an EntryImpl upon completion.
 class AppCacheDiskCache::ActiveCall {
  public:
   explicit ActiveCall(AppCacheDiskCache* owner)
       : entry_(NULL),
         owner_(owner),
         entry_ptr_(NULL) {
@@ skipping 26 matching lines @@
   int HandleImmediateReturnValue(int rv, Entry** entry,
                                  const net::CompletionCallback& callback) {
     if (rv == net::ERR_IO_PENDING) {
       // OnAsyncCompletion will be called later.
       callback_ = callback;
       entry_ = entry;
       owner_->AddActiveCall(this);
       return net::ERR_IO_PENDING;
     }
     if (rv == net::OK && entry)
-      *entry = new EntryImpl(entry_ptr_);
+      *entry = new EntryImpl(entry_ptr_, owner_);
     delete this;
     return rv;
   }
 
   void OnAsyncCompletion(int rv) {
     owner_->RemoveActiveCall(this);
     if (rv == net::OK && entry_)
-      *entry_ = new EntryImpl(entry_ptr_);
+      *entry_ = new EntryImpl(entry_ptr_, owner_);
     callback_.Run(rv);
     callback_.Reset();
     delete this;
   }
 
   Entry** entry_;
   net::CompletionCallback callback_;
   AppCacheDiskCache* owner_;
   disk_cache::Entry* entry_ptr_;
 };
 
 AppCacheDiskCache::AppCacheDiskCache()
     : is_disabled_(false) {
 }
 
 AppCacheDiskCache::~AppCacheDiskCache() {
-  if (create_backend_callback_.get()) {
-    create_backend_callback_->Cancel();
-    create_backend_callback_ = NULL;
-    OnCreateBackendComplete(net::ERR_ABORTED);
-  }
-  disk_cache_.reset();
-  STLDeleteElements(&active_calls_);
+  Disable();
 }
 
 int AppCacheDiskCache::InitWithDiskBackend(
     const base::FilePath& disk_cache_directory, int disk_cache_size, bool force,
     base::MessageLoopProxy* cache_thread,
     const net::CompletionCallback& callback) {
   return Init(net::APP_CACHE, disk_cache_directory,
               disk_cache_size, force, cache_thread, callback);
 }
 
 int AppCacheDiskCache::InitWithMemBackend(
     int mem_cache_size, const net::CompletionCallback& callback) {
   return Init(net::MEMORY_CACHE, base::FilePath(), mem_cache_size, false, NULL,
               callback);
 }
 
 void AppCacheDiskCache::Disable() {
   if (is_disabled_)
     return;
 
   is_disabled_ = true;
 
   if (create_backend_callback_.get()) {
     create_backend_callback_->Cancel();
     create_backend_callback_ = NULL;
     OnCreateBackendComplete(net::ERR_ABORTED);
   }
+
+  // We need to close open file handles in order to reinitalize the
+  // appcache system on the fly. File handles held in both entries and in
+  // the main disk_cache::Backend class need to be released.
+  for (OpenEntries::const_iterator iter = open_entries_.begin();
+       iter != open_entries_.end(); ++iter) {
+    (*iter)->Abandon();
+  }
+  open_entries_.clear();
+  disk_cache_.reset();
+  STLDeleteElements(&active_calls_);
 }
 
 int AppCacheDiskCache::CreateEntry(int64 key, Entry** entry,
                                    const net::CompletionCallback& callback) {
   DCHECK(entry);
   DCHECK(!callback.is_null());
   if (is_disabled_)
     return net::ERR_ABORTED;
 
   if (is_initializing()) {
@@ skipping 116 matching lines @@
         NOTREACHED();
         break;
     }
     if (rv != net::ERR_IO_PENDING)
       iter->callback.Run(rv);
   }
   pending_calls_.clear();
 }
 
 }  // namespace appcache