[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;
     }
   }
 
   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_;
   storage_->last_deletable_response_rowid_ = last_deletable_response_rowid_;
 
   if (!storage_->is_disabled()) {
     storage_->usage_map_.swap(usage_map_);
-    const base::TimeDelta kDelay = base::TimeDelta::FromMinutes(5);
+    const base::TimeDelta k5Minutes = base::TimeDelta::FromMinutes(5);

[cmumford, 2015/02/17 19:26:39]

My preference would be to have a name that describes it's purpose, and not it's
value. kDelay is preferable to my eye.

[michaeln, 2015/02/17 19:46:26]

Done.

     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AppCacheStorageImpl::DelayedStartDeletingUnusedResponses,
                    storage_->weak_factory_.GetWeakPtr()),
-        kDelay);
+        k5Minutes);
   }
 
   if (storage_->service()->quota_client())
     storage_->service()->quota_client()->NotifyAppCacheReady();
 }
 
 // DisableDatabaseTask -------
 
 class AppCacheStorageImpl::DisableDatabaseTask : public DatabaseTask {
  public:
@@ skipping 21 matching lines @@
   void RunCompleted() override;
 
  protected:
   ~GetAllInfoTask() override {}
 
  private:
   scoped_refptr<AppCacheInfoCollection> info_collection_;
 };
 
 void AppCacheStorageImpl::GetAllInfoTask::Run() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("AppCacheStorageImpl::GetAllInfoTask"));
   std::set<GURL> origins;
   database_->FindOriginsWithGroups(&origins);
   for (std::set<GURL>::const_iterator origin = origins.begin();
        origin != origins.end(); ++origin) {
     AppCacheInfoVector& infos =
         info_collection_->infos_by_origin[*origin];
     std::vector<AppCacheDatabase::GroupRecord> groups;
     database_->FindGroupsForOrigin(*origin, &groups);
     for (std::vector<AppCacheDatabase::GroupRecord>::const_iterator
          group = groups.begin();
@@ skipping 135 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 78 matching lines @@
     if (status == storage::kQuotaStatusOk)
       space_available_ = std::max(static_cast<int64>(0), quota - usage);
     else
       space_available_ = 0;
     storage_->pending_quota_queries_.erase(this);
     Schedule();
   }
 }
 
 void AppCacheStorageImpl::StoreGroupAndCacheTask::Run() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "AppCacheStorageImpl::StoreGroupAndCacheTask"));
   DCHECK(!success_);
   sql::Connection* connection = database_->db_connection();
   if (!connection)
     return;
 
   sql::Transaction transaction(connection);
   if (!transaction.Begin())
     return;
 
   int64 old_origin_usage = database_->GetOriginUsage(group_record_.origin);
 
   AppCacheDatabase::GroupRecord existing_group;
   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 163 matching lines @@
 
  protected:
   ~MarkEntryAsForeignTask() override {}
 
  private:
   int64 cache_id_;
   GURL entry_url_;
 };
 
 void AppCacheStorageImpl::MarkEntryAsForeignTask::Run() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "AppCacheStorageImpl::MarkEntryAsForeignTask"));
   database_->AddEntryFlags(entry_url_, cache_id_, AppCacheEntry::FOREIGN);
 }
 
 void AppCacheStorageImpl::MarkEntryAsForeignTask::RunCompleted() {
   DCHECK(storage_->pending_foreign_markings_.front().first == entry_url_ &&
          storage_->pending_foreign_markings_.front().second == cache_id_);
   storage_->pending_foreign_markings_.pop_front();
 }
 
 // MakeGroupObsoleteTask -------
@@ skipping 28 matching lines @@
     int response_code)
     : DatabaseTask(storage),
       group_(group),
       group_id_(group->group_id()),
       origin_(group->manifest_url().GetOrigin()),
       success_(false),
       response_code_(response_code),
       new_origin_usage_(-1) {}
 
 void AppCacheStorageImpl::MakeGroupObsoleteTask::Run() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "AppCacheStorageImpl::MakeGroupObsoleteTask"));
   DCHECK(!success_);
   sql::Connection* connection = database_->db_connection();
   if (!connection)
     return;
 
   sql::Transaction transaction(connection);
   if (!transaction.Begin())
     return;
 
   AppCacheDatabase::GroupRecord group_record;
@@ skipping 51 matching lines @@
 
  protected:
   ~GetDeletableResponseIdsTask() override {}
 
  private:
   int64 max_rowid_;
   std::vector<int64> response_ids_;
 };
 
 void AppCacheStorageImpl::GetDeletableResponseIdsTask::Run() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "AppCacheStorageImpl::GetDeletableResponseIdsTask"));
   const int kSqlLimit = 1000;
   database_->GetDeletableResponseIds(&response_ids_, max_rowid_, kSqlLimit);
   // TODO(michaeln): retrieve group_ids too
 }
 
 void AppCacheStorageImpl::GetDeletableResponseIdsTask::RunCompleted() {
   if (!response_ids_.empty())
     storage_->StartDeletingResponses(response_ids_);
 }
 
 // InsertDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::InsertDeletableResponseIdsTask
     : public DatabaseTask {
  public:
   explicit InsertDeletableResponseIdsTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
 
   // DatabaseTask:
   void Run() override;
 
   std::vector<int64> response_ids_;
 
  protected:
   ~InsertDeletableResponseIdsTask() override {}
 };
 
 void AppCacheStorageImpl::InsertDeletableResponseIdsTask::Run() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "AppCacheStorageImpl::InsertDeletableResponseIdsTask"));
   database_->InsertDeletableResponseIds(response_ids_);
   // TODO(michaeln): store group_ids too
 }
 
 // DeleteDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::DeleteDeletableResponseIdsTask
     : public DatabaseTask {
  public:
   explicit DeleteDeletableResponseIdsTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
 
   // DatabaseTask:
   void Run() override;
 
   std::vector<int64> response_ids_;
 
  protected:
   ~DeleteDeletableResponseIdsTask() override {}
 };
 
 void AppCacheStorageImpl::DeleteDeletableResponseIdsTask::Run() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "AppCacheStorageImpl::DeleteDeletableResponseIdsTask"));
   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::UpdateGroupLastAccessTimeTask"));
+  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 {
+    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 k10Millis = base::TimeDelta::FromMilliseconds(10);
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&AppCacheStorageImpl::DeleteOneResponse,
                  weak_factory_.GetWeakPtr()),
-      kDelay);
+      k10Millis);
   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 int k10Minutes = 10;
+  lazy_commit_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromMinutes(k10Minutes),
+      base::Bind(&AppCacheStorageImpl::OnCommitLastAccessTimes,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void AppCacheStorageImpl::OnCommitLastAccessTimes() {
+  lazy_commit_timer_.Stop();
+  if (is_disabled())
+    return;
+  scoped_refptr<DatabaseTask> task(new CommitLastAccessTimesTask(this));
+  task->Schedule();
+}

[cmumford, 2015/02/17 19:26:39]

Space

[michaeln, 2015/02/17 19:46:26]

Done.

 }  // namespace content