[appcache] Don't write during startup.

content/browser/appcache/appcache_storage_impl.h

 // Copyright (c) 2011 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 CONTENT_BROWSER_APPCACHE_APPCACHE_STORAGE_IMPL_H_
 #define CONTENT_BROWSER_APPCACHE_APPCACHE_STORAGE_IMPL_H_
 
 #include <deque>
 #include <map>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
+#include "base/timer/timer.h"
 #include "content/browser/appcache/appcache_database.h"
 #include "content/browser/appcache/appcache_disk_cache.h"
 #include "content/browser/appcache/appcache_storage.h"
 #include "content/common/content_export.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace content {
@@ skipping 52 matching lines @@
   class StoreOrLoadTask;
   class CacheLoadTask;
   class GroupLoadTask;
   class StoreGroupAndCacheTask;
   class FindMainResponseTask;
   class MarkEntryAsForeignTask;
   class MakeGroupObsoleteTask;
   class GetDeletableResponseIdsTask;
   class InsertDeletableResponseIdsTask;
   class DeleteDeletableResponseIdsTask;
-  class UpdateGroupLastAccessTimeTask;
+  class LazyUpdateLastAccessTimeTask;
+  class CommitLastAccessTimesTask;
 
   typedef std::deque<DatabaseTask*> DatabaseTaskQueue;
   typedef std::map<int64, CacheLoadTask*> PendingCacheLoads;
   typedef std::map<GURL, GroupLoadTask*> PendingGroupLoads;
   typedef std::deque<std::pair<GURL, int64> > PendingForeignMarkings;
   typedef std::set<StoreGroupAndCacheTask*> PendingQuotaQueries;
 
   bool IsInitTaskComplete() {
     return last_cache_id_ != AppCacheStorage::kUnitializedId;
   }
 
   CacheLoadTask* GetPendingCacheLoadTask(int64 cache_id);
   GroupLoadTask* GetPendingGroupLoadTask(const GURL& manifest_url);
   void GetPendingForeignMarkingsForCache(
       int64 cache_id, std::vector<GURL>* urls);
 
   void ScheduleSimpleTask(const base::Closure& task);
   void RunOnePendingSimpleTask();
 
   void DelayedStartDeletingUnusedResponses();
   void StartDeletingResponses(const std::vector<int64>& response_ids);
   void ScheduleDeleteOneResponse();
   void DeleteOneResponse();
-
   void OnDeletedOneResponse(int rv);
   void OnDiskCacheInitialized(int rv);
   void DeleteAndStartOver();
   void DeleteAndStartOverPart2();
   void CallScheduleReinitialize();
+  void LazilyCommitLastAccessTimes();

[dmurph, 2015/02/20 00:04:45]

Can you put a comment saying the magnitude of time it will take? And that it's
batching calling in that time period? 

+  void OnCommitLastAccessTimes();
 
   // Sometimes we can respond without having to query the database.
   bool FindResponseForMainRequestInGroup(
       AppCacheGroup* group,  const GURL& url, Delegate* delegate);
   void DeliverShortCircuitedFindMainResponse(
       const GURL& url,
       const AppCacheEntry& found_entry,
       scoped_refptr<AppCacheGroup> group,
       scoped_refptr<AppCache> newest_cache,
       scoped_refptr<DelegateReference> delegate_ref);
@@ skipping 31 matching lines @@
   int64 last_deletable_response_rowid_;
 
   // Created on the IO thread, but only used on the DB thread.
   AppCacheDatabase* database_;
 
   // Set if we discover a fatal error like a corrupt SQL database or
   // disk cache and cannot continue.
   bool is_disabled_;
 
   scoped_ptr<AppCacheDiskCache> disk_cache_;
+  base::OneShotTimer<AppCacheStorageImpl> lazy_commit_timer_;
 
   // Used to short-circuit certain operations without having to schedule
   // any tasks on the background database thread.
   std::deque<base::Closure> pending_simple_tasks_;
   base::WeakPtrFactory<AppCacheStorageImpl> weak_factory_;
 
   friend class content::AppCacheStorageImplTest;
   friend class content::ChromeAppCacheServiceTest;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_STORAGE_IMPL_H_