Appcache::OnCorruptionDetected handling

webkit/browser/appcache/appcache_service.h

 // 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.
 
 #ifndef WEBKIT_BROWSER_APPCACHE_APPCACHE_SERVICE_H_
 #define WEBKIT_BROWSER_APPCACHE_APPCACHE_SERVICE_H_
 
 #include <map>
 #include <set>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "webkit/browser/appcache/appcache_storage.h"
 #include "webkit/browser/quota/quota_manager_proxy.h"
 #include "webkit/browser/webkit_storage_browser_export.h"
 #include "webkit/common/appcache/appcache_interfaces.h"
 
 namespace net {
 class URLRequestContext;
 }  // namespace net
@@ skipping 67 matching lines @@
                   base::MessageLoopProxy* cache_thread);
 
   void AddObserver(Observer* observer) {
     observers_.AddObserver(observer);
   }
 
   void RemoveObserver(Observer* observer) {
     observers_.RemoveObserver(observer);
   }
 
-  // For use in a very specific failure mode to reboot the appcache system
+  // For use in catastrophic failure modes to reboot the appcache system
   // without relaunching the browser.
-  void Reinitialize();
+  void ScheduleReinitialize();
 
   // Purges any memory not needed.
   void PurgeMemory() {
     if (storage_)
       storage_->PurgeMemory();
   }
 
   // Determines if a request for 'url' can be satisfied while offline.
   // This method always completes asynchronously.
   void CanHandleMainResourceOffline(const GURL& url,
@@ skipping 79 matching lines @@
 
   AppCacheStorage* storage() const { return storage_.get(); }
 
   // Disables the exit-time deletion of session-only data.
   void set_force_keep_session_state() { force_keep_session_state_ = true; }
   bool force_keep_session_state() const { return force_keep_session_state_; }
 
  protected:
   friend class AppCacheStorageImplTest;
   friend class AppCacheServiceTest;
+  FRIEND_TEST_ALL_PREFIXES(AppCacheServiceTest, ScheduleReinitialize);
 
   class AsyncHelper;
   class CanHandleOfflineHelper;
   class DeleteHelper;
   class DeleteOriginHelper;
   class GetInfoHelper;
   class CheckResponseHelper;
 
   typedef std::set<AsyncHelper*> PendingAsyncHelpers;
   typedef std::map<int, AppCacheBackendImpl*> BackendMap;
 
+  void Reinitialize();
+
   base::FilePath cache_directory_;
   scoped_refptr<base::MessageLoopProxy> db_thread_;
   scoped_refptr<base::MessageLoopProxy> cache_thread_;
   AppCachePolicy* appcache_policy_;
   AppCacheQuotaClient* quota_client_;
   AppCacheExecutableHandlerFactory* handler_factory_;
   scoped_ptr<AppCacheStorage> storage_;
   scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
   scoped_refptr<quota::QuotaManagerProxy> quota_manager_proxy_;
   PendingAsyncHelpers pending_helpers_;
   BackendMap backends_;  // One 'backend' per child process.
   // Context for use during cache updates.
   net::URLRequestContext* request_context_;
   // If true, nothing (not even session-only data) should be deleted on exit.
   bool force_keep_session_state_;
-  bool was_reinitialized_;
+  base::Time last_reinit_time_;
+  base::TimeDelta next_reinit_delay_;
+  base::OneShotTimer<AppCacheService> reinit_timer_;
   ObserverList<Observer> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(AppCacheService);
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_BROWSER_APPCACHE_APPCACHE_SERVICE_H_