[appcache] Don't write during startup.

content/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 "content/browser/appcache/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_database.h"
 #include "content/browser/appcache/appcache_entry.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_histograms.h"
 #include "content/browser/appcache/appcache_quota_client.h"
 #include "content/browser/appcache/appcache_response.h"
@@ skipping 251 matching lines @@
   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() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("AppCacheStorageImpl::InitTask"));
   // If there is no sql database, ensure there is no disk cache either.
   if (!db_file_path_.empty() &&
       !base::PathExists(db_file_path_) &&
       base::DirectoryExists(disk_cache_directory_)) {
     base::DeleteFile(disk_cache_directory_, true);
     if (base::DirectoryExists(disk_cache_directory_)) {
       database_->Disable();  // This triggers OnFatalError handling.
       return;
     }
   }
@@ skipping 207 matching lines @@
 
  protected:
   ~CacheLoadTask() override {}
 
  private:
   int64 cache_id_;
   bool success_;
 };
 
 void AppCacheStorageImpl::CacheLoadTask::Run() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("AppCacheStorageImpl::CacheLoadTask"));
   success_ =
       database_->FindCache(cache_id_, &cache_record_) &&
       database_->FindGroup(cache_record_.group_id, &group_record_) &&
       FindRelatedCacheRecords(cache_id_);
 
   if (success_)
-    database_->UpdateGroupLastAccessTime(group_record_.group_id,
-                                         base::Time::Now());
+    database_->LazyUpdateLastAccessTime(group_record_.group_id,
+                                        base::Time::Now());
 }
 
 void AppCacheStorageImpl::CacheLoadTask::RunCompleted() {
   storage_->pending_cache_loads_.erase(cache_id_);
   scoped_refptr<AppCache> cache;
   scoped_refptr<AppCacheGroup> group;
   if (success_ && !storage_->is_disabled()) {
+    storage_->LazilyCommitLastAccessTimes();
     DCHECK(cache_record_.cache_id == cache_id_);
     CreateCacheAndGroupFromRecords(&cache, &group);
   }
   FOR_EACH_DELEGATE(delegates_, OnCacheLoaded(cache.get(), cache_id_));
 }
 
 // GroupLoadTask -------
 
 class AppCacheStorageImpl::GroupLoadTask : public StoreOrLoadTask {
  public:
   GroupLoadTask(GURL manifest_url, AppCacheStorageImpl* storage)
       : StoreOrLoadTask(storage), manifest_url_(manifest_url),
         success_(false) {}
 
   // DatabaseTask:
   void Run() override;
   void RunCompleted() override;
 
  protected:
   ~GroupLoadTask() override {}
 
  private:
   GURL manifest_url_;
   bool success_;
 };
 
 void AppCacheStorageImpl::GroupLoadTask::Run() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("AppCacheStorageImpl::GroupLoadTask"));
   success_ =
       database_->FindGroupForManifestUrl(manifest_url_, &group_record_) &&
       database_->FindCacheForGroup(group_record_.group_id, &cache_record_) &&
       FindRelatedCacheRecords(cache_record_.cache_id);
 
   if (success_)
-    database_->UpdateGroupLastAccessTime(group_record_.group_id,
-                                         base::Time::Now());
+    database_->LazyUpdateLastAccessTime(group_record_.group_id,
+                                        base::Time::Now());
 }
 
 void AppCacheStorageImpl::GroupLoadTask::RunCompleted() {
   storage_->pending_group_loads_.erase(manifest_url_);
   scoped_refptr<AppCacheGroup> group;
   scoped_refptr<AppCache> cache;
   if (!storage_->is_disabled()) {
     if (success_) {
+      storage_->LazilyCommitLastAccessTimes();
       DCHECK(group_record_.manifest_url == manifest_url_);
       CreateCacheAndGroupFromRecords(&cache, &group);
     } else {
       group = storage_->working_set_.GetGroup(manifest_url_);
       if (!group.get()) {
         group =
             new AppCacheGroup(storage_, manifest_url_, storage_->NewGroupId());
       }
     }
   }
@@ skipping 100 matching lines @@
   success_ = database_->FindGroup(group_record_.group_id, &existing_group);
   if (!success_) {
     group_record_.creation_time = base::Time::Now();
     group_record_.last_access_time = base::Time::Now();
     success_ = database_->InsertGroup(&group_record_);
   } else {
     DCHECK(group_record_.group_id == existing_group.group_id);
     DCHECK(group_record_.manifest_url == existing_group.manifest_url);
     DCHECK(group_record_.origin == existing_group.origin);
 
-    database_->UpdateGroupLastAccessTime(group_record_.group_id,
-                                         base::Time::Now());
+    database_->UpdateLastAccessTime(group_record_.group_id,
+                                    base::Time::Now());
 
     AppCacheDatabase::CacheRecord cache;
     if (database_->FindCacheForGroup(group_record_.group_id, &cache)) {
       // Get the set of response ids in the old cache.
       std::set<int64> existing_response_ids;
       database_->FindResponseIdsForCacheAsSet(cache.cache_id,
                                               &existing_response_ids);
 
       // Remove those that remain in the new cache.
       std::vector<AppCacheDatabase::EntryRecord>::const_iterator entry_iter =
@@ skipping 219 matching lines @@
   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() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "AppCacheStorageImpl::FindMainResponseTask"));
   // 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.
   // TODO(michaeln): come up with a 'preferred_manifest_url' in more cases
@@ skipping 335 matching lines @@
   std::vector<int64> response_ids_;
 
  protected:
   ~DeleteDeletableResponseIdsTask() override {}
 };
 
 void AppCacheStorageImpl::DeleteDeletableResponseIdsTask::Run() {
   database_->DeleteDeletableResponseIds(response_ids_);
 }
 
-// UpdateGroupLastAccessTimeTask -------
+// LazyUpdateLastAccessTimeTask -------
 
-class AppCacheStorageImpl::UpdateGroupLastAccessTimeTask
+class AppCacheStorageImpl::LazyUpdateLastAccessTimeTask
     : public DatabaseTask {
  public:
-  UpdateGroupLastAccessTimeTask(
+  LazyUpdateLastAccessTimeTask(
       AppCacheStorageImpl* storage, AppCacheGroup* group, base::Time time)
       : DatabaseTask(storage), group_id_(group->group_id()),
         last_access_time_(time) {
     storage->NotifyStorageAccessed(group->manifest_url().GetOrigin());
   }
 
   // DatabaseTask:
   void Run() override;
+  void RunCompleted() override;
 
  protected:
-  ~UpdateGroupLastAccessTimeTask() override {}
+  ~LazyUpdateLastAccessTimeTask() override {}
 
  private:
   int64 group_id_;
   base::Time last_access_time_;
 };
 
-void AppCacheStorageImpl::UpdateGroupLastAccessTimeTask::Run() {
-  database_->UpdateGroupLastAccessTime(group_id_, last_access_time_);
+void AppCacheStorageImpl::LazyUpdateLastAccessTimeTask::Run() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "AppCacheStorageImpl::LazyUpdateLastAccessTimeTask"));
+  database_->LazyUpdateLastAccessTime(group_id_, last_access_time_);
 }
 
+void AppCacheStorageImpl::LazyUpdateLastAccessTimeTask::RunCompleted() {
+  storage_->LazilyCommitLastAccessTimes();
+}
+
+// CommitLastAccessTimesTask -------
+
+class AppCacheStorageImpl::CommitLastAccessTimesTask
+    : public DatabaseTask {
+ public:
+  CommitLastAccessTimesTask(AppCacheStorageImpl* storage)
+      : DatabaseTask(storage) {}
+
+  // DatabaseTask:
+  void Run() override {
+    tracked_objects::ScopedTracker tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "AppCacheStorageImpl::CommitLastAccessTimesTask"));
+    database_->CommitLazyLastAccessTimes();
+  }
+
+ protected:
+  ~CommitLastAccessTimesTask() override {}
+};
 
 // AppCacheStorageImpl ---------------------------------------------------
 
 AppCacheStorageImpl::AppCacheStorageImpl(AppCacheServiceImpl* service)
     : AppCacheStorage(service),
       is_incognito_(false),
       is_response_deletion_scheduled_(false),
       did_start_deleting_responses_(false),
       last_deletable_response_rowid_(0),
       database_(NULL),
@@ skipping 67 matching lines @@
   if (is_disabled_) {
     delegate->OnCacheLoaded(NULL, id);
     return;
   }
 
   AppCache* cache = working_set_.GetCache(id);
   if (cache) {
     delegate->OnCacheLoaded(cache, id);
     if (cache->owning_group()) {
       scoped_refptr<DatabaseTask> update_task(
-          new UpdateGroupLastAccessTimeTask(
+          new LazyUpdateLastAccessTimeTask(
               this, cache->owning_group(), base::Time::Now()));
       update_task->Schedule();
     }
     return;
   }
   scoped_refptr<CacheLoadTask> task(GetPendingCacheLoadTask(id));
   if (task.get()) {
     task->AddDelegate(GetOrCreateDelegateReference(delegate));
     return;
   }
   task = new CacheLoadTask(id, this);
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
   pending_cache_loads_[id] = task.get();
 }
 
 void AppCacheStorageImpl::LoadOrCreateGroup(
     const GURL& manifest_url, Delegate* delegate) {
   DCHECK(delegate);
   if (is_disabled_) {
     delegate->OnGroupLoaded(NULL, manifest_url);
     return;
   }
 
   AppCacheGroup* group = working_set_.GetGroup(manifest_url);
   if (group) {
     delegate->OnGroupLoaded(group, manifest_url);
     scoped_refptr<DatabaseTask> update_task(
-        new UpdateGroupLastAccessTimeTask(
+        new LazyUpdateLastAccessTimeTask(
             this, group, base::Time::Now()));
     update_task->Schedule();
     return;
   }
 
   scoped_refptr<GroupLoadTask> task(GetPendingGroupLoadTask(manifest_url));
   if (task.get()) {
     task->AddDelegate(GetOrCreateDelegateReference(delegate));
     return;
   }
@@ skipping 241 matching lines @@
   did_start_deleting_responses_ = true;
   deletable_response_ids_.insert(
       deletable_response_ids_.end(),
       response_ids.begin(), response_ids.end());
   if (!is_response_deletion_scheduled_)
     ScheduleDeleteOneResponse();
 }
 
 void AppCacheStorageImpl::ScheduleDeleteOneResponse() {
   DCHECK(!is_response_deletion_scheduled_);
-  const base::TimeDelta kDelay = base::TimeDelta::FromMilliseconds(10);
+  const base::TimeDelta kBriefDelay = base::TimeDelta::FromMilliseconds(10);
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&AppCacheStorageImpl::DeleteOneResponse,
                  weak_factory_.GetWeakPtr()),
-      kDelay);
+      kBriefDelay);
   is_response_deletion_scheduled_ = true;
 }
 
 void AppCacheStorageImpl::DeleteOneResponse() {
   DCHECK(is_response_deletion_scheduled_);
   DCHECK(!deletable_response_ids_.empty());
 
   if (!disk_cache()) {
     DCHECK(is_disabled_);
     deletable_response_ids_.clear();
@@ skipping 146 matching lines @@
       base::Bind(base::IgnoreResult(&base::DeleteFile), cache_directory_, true),
       base::Bind(&AppCacheStorageImpl::CallScheduleReinitialize,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AppCacheStorageImpl::CallScheduleReinitialize() {
   service_->ScheduleReinitialize();
   // note: 'this' may be deleted at this point.
 }
 
+void AppCacheStorageImpl::LazilyCommitLastAccessTimes() {
+  if (lazy_commit_timer_.IsRunning())
+    return;
+  const base::TimeDelta kDelay = base::TimeDelta::FromMinutes(5);
+  lazy_commit_timer_.Start(
+      FROM_HERE, kDelay,
+      base::Bind(&AppCacheStorageImpl::OnCommitLastAccessTimes,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void AppCacheStorageImpl::OnCommitLastAccessTimes() {

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

This sounds like 'commit last action times' already occurred. perhaps rename to
just CommitLastAccessTimes? Or what about CommitLastAccessTimesFromDelay?

[michaeln, 2015/02/20 20:24:39]

Done.

+  lazy_commit_timer_.Stop();
+  if (is_disabled())
+    return;
+  scoped_refptr<DatabaseTask> task(new CommitLastAccessTimesTask(this));
+  task->Schedule();
+}
+
 }  // namespace content