Appcache::OnCorruptionDetected handling

webkit/browser/appcache/appcache_storage_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 "webkit/browser/appcache/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
@@ skipping 155 matching lines @@
   friend class base::RefCountedThreadSafe<DatabaseTask>;
   virtual ~DatabaseTask() {}
 
   AppCacheStorageImpl* storage_;
   AppCacheDatabase* database_;
   DelegateReferenceVector delegates_;
 
  private:
   void CallRun(base::TimeTicks schedule_time);
   void CallRunCompleted(base::TimeTicks schedule_time);
-  void CallDisableStorage();
+  void OnDisableStorage();
+  void OnCorruptionDetected();
 
   scoped_refptr<base::MessageLoopProxy> io_thread_;
 };
 
 void AppCacheStorageImpl::DatabaseTask::Schedule() {
   DCHECK(storage_);
   DCHECK(io_thread_->BelongsToCurrentThread());
   if (!storage_->database_)
     return;
 
@@ skipping 17 matching lines @@
   AppCacheHistograms::AddTaskQueueTimeSample(
       base::TimeTicks::Now() - schedule_time);
   if (!database_->is_disabled()) {
     base::TimeTicks run_time = base::TimeTicks::Now();
     Run();
     AppCacheHistograms::AddTaskRunTimeSample(
         base::TimeTicks::Now() - run_time);
     if (database_->is_disabled()) {
       io_thread_->PostTask(
           FROM_HERE,
-          base::Bind(&DatabaseTask::CallDisableStorage, this));
+          base::Bind(&DatabaseTask::OnDisableStorage, this));
+    } else if (database_->was_corruption_dectected()) {
+      database_->Disable();
+      io_thread_->PostTask(
+          FROM_HERE,
+          base::Bind(&DatabaseTask::OnCorruptionDetected, this));
     }
   }
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&DatabaseTask::CallRunCompleted, this,
                  base::TimeTicks::Now()));
 }
 
 void AppCacheStorageImpl::DatabaseTask::CallRunCompleted(
     base::TimeTicks schedule_time) {
   AppCacheHistograms::AddCompletionQueueTimeSample(
       base::TimeTicks::Now() - schedule_time);
   if (storage_) {
     DCHECK(io_thread_->BelongsToCurrentThread());
     DCHECK(storage_->scheduled_database_tasks_.front() == this);
     storage_->scheduled_database_tasks_.pop_front();
     base::TimeTicks run_time = base::TimeTicks::Now();
     RunCompleted();
     AppCacheHistograms::AddCompletionRunTimeSample(
         base::TimeTicks::Now() - run_time);
     delegates_.clear();
   }
 }
 
-void AppCacheStorageImpl::DatabaseTask::CallDisableStorage() {
+void AppCacheStorageImpl::DatabaseTask::OnDisableStorage() {
   if (storage_) {
     DCHECK(io_thread_->BelongsToCurrentThread());
     storage_->Disable();
   }
 }
 
+void AppCacheStorageImpl::DatabaseTask::OnCorruptionDetected() {
+  if (storage_) {
+    DCHECK(io_thread_->BelongsToCurrentThread());
+    AppCacheHistograms::CountCorruptionDetected();
+    storage_->Disable();
+    storage_->DeleteAndStartOver();
+  }
+}
+
 // InitTask -------
 
 class AppCacheStorageImpl::InitTask : public DatabaseTask {
  public:
   explicit InitTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage), last_group_id_(0),
         last_cache_id_(0), last_response_id_(0),
-        last_deletable_response_rowid_(0) {}
+        last_deletable_response_rowid_(0) {
+    if (!storage->is_incognito_) {
+      db_file_path_ =
+          storage->cache_directory_.Append(kAppCacheDatabaseName);
+      disk_cache_directory_ =
+          storage->cache_directory_.Append(kDiskCacheDirectoryName);
+    }
+  }
 
   // DatabaseTask:
   virtual void Run() OVERRIDE;
   virtual void RunCompleted() OVERRIDE;
 
  protected:
   virtual ~InitTask() {}
 
  private:
+  base::FilePath db_file_path_;
+  base::FilePath disk_cache_directory_;
   int64 last_group_id_;
   int64 last_cache_id_;
   int64 last_response_id_;
   int64 last_deletable_response_rowid_;
   std::map<GURL, int64> usage_map_;
 };
 
 void AppCacheStorageImpl::InitTask::Run() {
+  if (!db_file_path_.empty()) {
+    // If there is no sql database, ensure there is no disk cache either.
+    if (!base::PathExists(db_file_path_)) {
+      if (base::DirectoryExists(disk_cache_directory_)) {
+        base::DeleteFile(disk_cache_directory_, true);
+        DCHECK(!base::DirectoryExists(disk_cache_directory_));
+      }
+    }
+  }
+
   database_->FindLastStorageIds(
       &last_group_id_, &last_cache_id_, &last_response_id_,
       &last_deletable_response_rowid_);
   database_->GetAllOriginUsage(&usage_map_);
 }
 
 void AppCacheStorageImpl::InitTask::RunCompleted() {
   storage_->last_group_id_ = last_group_id_;
   storage_->last_cache_id_ = last_cache_id_;
   storage_->last_response_id_ = last_response_id_;
@@ skipping 624 matching lines @@
   GURL preferred_manifest_url_;
   std::set<int64> cache_ids_in_use_;
   AppCacheEntry entry_;
   AppCacheEntry fallback_entry_;
   GURL namespace_entry_url_;
   int64 cache_id_;
   int64 group_id_;
   GURL manifest_url_;
 };
 
-
-
 void AppCacheStorageImpl::FindMainResponseTask::Run() {
   // NOTE: The heuristics around choosing amoungst multiple candidates
   // is underspecified, and just plain not fully understood. This needs
   // to be refined.
 
   // The 'preferred_manifest_url' is the url of the manifest associated
   // with the page that opened or embedded the page being loaded now.
   // We have a strong preference to use resources from that cache.
   // We also have a lesser bias to use resources from caches that are currently
   // being used by other unrelated pages.
@@ skipping 858 matching lines @@
     } else {
       rv = disk_cache_->InitWithDiskBackend(
           cache_directory_.Append(kDiskCacheDirectoryName),
           kMaxDiskCacheSize,
           false,
           cache_thread_.get(),
           base::Bind(&AppCacheStorageImpl::OnDiskCacheInitialized,
                      base::Unretained(this)));
     }
 
-    // We should not keep this reference around.
-    cache_thread_ = NULL;
-
     if (rv != net::ERR_IO_PENDING)
       OnDiskCacheInitialized(rv);
   }
   return disk_cache_.get();
 }
 
 void AppCacheStorageImpl::OnDiskCacheInitialized(int rv) {
   if (rv != net::OK) {
     LOG(ERROR) << "Failed to open the appcache diskcache.";
     AppCacheHistograms::CountInitResult(AppCacheHistograms::DISK_CACHE_ERROR);
 
     // We're unable to open the disk cache, this is a fatal error that we can't
     // really recover from. We handle it by temporarily disabling the appcache
     // deleting the directory on disk and reinitializing the appcache system.
     Disable();
-    if (!is_incognito_ && rv != net::ERR_ABORTED) {
-      VLOG(1) << "Deleting existing appcache data and starting over.";
-      db_thread_->PostTaskAndReply(
-          FROM_HERE,
-          base::Bind(base::IgnoreResult(&base::DeleteFile),
-                     cache_directory_, true),
-          base::Bind(&AppCacheStorageImpl::CallReinitialize,
-                     weak_factory_.GetWeakPtr()));
-    }
+    if (rv != net::ERR_ABORTED)
+      DeleteAndStartOver();
   }
 }
 
-void AppCacheStorageImpl::CallReinitialize() {
-  service_->Reinitialize();
-  // note: 'this' may be deleted during reinit.
+namespace {
+
+void HopThruCacheThread() {
+  // Function body is intentionally empty,
+  // all diskcache file handles should be closed by the
+  // time this function runs.
+}
+
+void DeleteDirectoryHelper(const base::FilePath& dir) {
+  base::DeleteFile(dir, true);
+  DCHECK(!base::DirectoryExists(dir));
+}
+
+}
+
+void AppCacheStorageImpl::DeleteAndStartOver() {
+  DCHECK(is_disabled_);
+  if (!is_incognito_) {
+    VLOG(1) << "Deleting existing appcache data and starting over.";
+    // We can have tasks in flight to close file handles on both the db
+    // and cache threads, we need to allow those tasks to cycle thru
+    // prior to deleting the files and calling reinit.
+    cache_thread_->PostTaskAndReply(
+        FROM_HERE,
+        base::Bind(&HopThruCacheThread),
+        base::Bind(&AppCacheStorageImpl::DeleteAndStartOverPart2,
+                   weak_factory_.GetWeakPtr()));
+  }
+}
+
+void AppCacheStorageImpl::DeleteAndStartOverPart2() {
+  db_thread_->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&DeleteDirectoryHelper, cache_directory_),
+      base::Bind(&AppCacheStorageImpl::CallScheduleReinitialize,
+                  weak_factory_.GetWeakPtr()));
+}
+
+void AppCacheStorageImpl::CallScheduleReinitialize() {
+  service_->ScheduleReinitialize();
+  // note: 'this' may be deleted at this point.
 }
 
 }  // namespace appcache