Revert 91690 - Implement QM::GetOriginsModifiedSince for browser data deleter support

webkit/quota/quota_manager.cc

 // 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.
 
 #include "webkit/quota/quota_manager.h"
 
 #include <algorithm>
 #include <deque>
 #include <set>
 
@@ skipping 467 matching lines @@
     manager()->DidInitializeTemporaryGlobalQuota(temporary_storage_quota_);
   }
 
  private:
   FilePath profile_path_;
   bool is_incognito_;
   bool need_initialize_origins_;
   int64 temporary_storage_quota_;
 };
 
-class QuotaManager::UpdateTemporaryGlobalQuotaTask
+class QuotaManager::TemporaryGlobalQuotaUpdateTask
     : public QuotaManager::DatabaseTaskBase {
  public:
-  UpdateTemporaryGlobalQuotaTask(
+  TemporaryGlobalQuotaUpdateTask(
       QuotaManager* manager,
       int64 new_quota,
       QuotaCallback* callback)
       : DatabaseTaskBase(manager),
         new_quota_(new_quota),
         callback_(callback) {
     DCHECK_GE(new_quota, 0);
   }
 
  protected:
@@ skipping 10 matching lines @@
     if (!db_disabled()) {
       manager()->temporary_global_quota_ = new_quota_;
     }
   }
 
  private:
   int64 new_quota_;
   scoped_ptr<QuotaCallback> callback_;
 };
 
-class QuotaManager::GetPersistentHostQuotaTask
+class QuotaManager::PersistentHostQuotaQueryTask
     : public QuotaManager::DatabaseTaskBase {
  public:
-  GetPersistentHostQuotaTask(
+  PersistentHostQuotaQueryTask(
       QuotaManager* manager,
       const std::string& host,
       HostQuotaCallback* callback)
       : DatabaseTaskBase(manager),
         host_(host),
         quota_(-1),
         callback_(callback) {
   }
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->GetHostQuota(host_, kStorageTypePersistent, &quota_))
       quota_ = 0;
   }
   virtual void DatabaseTaskCompleted() OVERRIDE {
     callback_->Run(kQuotaStatusOk,
                    host_, kStorageTypePersistent, quota_);
   }
  private:
   std::string host_;
   int64 quota_;
   scoped_ptr<HostQuotaCallback> callback_;
 };
 
-class QuotaManager::UpdatePersistentHostQuotaTask
+class QuotaManager::PersistentHostQuotaUpdateTask
     : public QuotaManager::DatabaseTaskBase {
  public:
-  UpdatePersistentHostQuotaTask(
+  PersistentHostQuotaUpdateTask(
       QuotaManager* manager,
       const std::string& host,
       int new_quota,
       HostQuotaCallback* callback)
       : DatabaseTaskBase(manager),
         host_(host),
         new_quota_(new_quota),
         callback_(callback) {
     DCHECK_GE(new_quota_, 0);
   }
@@ skipping 63 matching lines @@
   }
 
  private:
   StorageType type_;
   std::set<GURL> exceptions_;
   scoped_ptr<GetLRUOriginCallback> callback_;
   scoped_refptr<SpecialStoragePolicy> special_storage_policy_;
   GURL url_;
 };
 
-class QuotaManager::DeleteOriginInfo
+class QuotaManager::OriginDeletionDatabaseTask
     : public QuotaManager::DatabaseTaskBase {
  public:
-  DeleteOriginInfo(
+  OriginDeletionDatabaseTask(
       QuotaManager* manager,
       const GURL& origin,
       StorageType type)
       : DatabaseTaskBase(manager),
         origin_(origin),
         type_(type) {}
 
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
-    if (!database()->DeleteOriginInfo(origin_, type_)) {
+    if (!database()->DeleteOriginLastAccessTime(origin_, type_)) {
       set_db_disabled(true);
     }
   }
   virtual void DatabaseTaskCompleted() OVERRIDE {}
 
  private:
   GURL origin_;
   StorageType type_;
 };
 
-class QuotaManager::InitializeTemporaryOriginsInfoTask
+class QuotaManager::TemporaryOriginsRegistrationTask
     : public QuotaManager::DatabaseTaskBase {
  public:
-  InitializeTemporaryOriginsInfoTask(
+  TemporaryOriginsRegistrationTask(
       QuotaManager* manager,
       UsageTracker* temporary_usage_tracker)
       : DatabaseTaskBase(manager),
         has_registered_origins_(false) {
     DCHECK(temporary_usage_tracker);
     temporary_usage_tracker->GetCachedOrigins(&origins_);
   }
 
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->IsOriginDatabaseBootstrapped()) {
       // Register existing origins with 0 last time access.
-      if (!database()->RegisterInitialOriginInfo(
-              origins_, kStorageTypeTemporary)) {
+      if (!database()->RegisterOrigins(origins_,
+                                       kStorageTypeTemporary,
+                                       base::Time::FromInternalValue(0))) {
         set_db_disabled(true);
       } else {
         has_registered_origins_ = true;
         database()->SetOriginDatabaseBootstrapped(true);
       }
     }
   }
   virtual void DatabaseTaskCompleted() OVERRIDE {
     if (has_registered_origins_)
       manager()->StartEviction();
@@ skipping 16 matching lines @@
         space_(-1),
         callback_(callback) {}
   virtual ~AvailableSpaceQueryTask() {}
 
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
     space_ = base::SysInfo::AmountOfFreeDiskSpace(profile_path_);
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_->Run(kQuotaErrorAbort, -1);
+    callback_->Run(kQuotaErrorAbort, space_);
   }
 
   virtual void Completed() OVERRIDE {
     callback_->Run(kQuotaStatusOk, space_);
   }
 
  private:
   FilePath profile_path_;
   int64 space_;
   scoped_ptr<AvailableSpaceCallback> callback_;
 };
 
-class QuotaManager::UpdateAccesTimeTask
+class QuotaManager::OriginAccessRecordDatabaseTask
     : public QuotaManager::DatabaseTaskBase {
  public:
-  UpdateAccesTimeTask(
+  OriginAccessRecordDatabaseTask(
       QuotaManager* manager,
       const GURL& origin,
       StorageType type,
       base::Time accessed_time)
       : DatabaseTaskBase(manager),
         origin_(origin),
         type_(type),
         accessed_time_(accessed_time) {}
 
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->SetOriginLastAccessTime(origin_, type_, accessed_time_)) {
       set_db_disabled(true);
     }
   }
   virtual void DatabaseTaskCompleted() OVERRIDE {}
 
  private:
   GURL origin_;
   StorageType type_;
   base::Time accessed_time_;
 };
 
-class QuotaManager::UpdateModifiedTimeTask
-    : public QuotaManager::DatabaseTaskBase {
- public:
-  UpdateModifiedTimeTask(
-      QuotaManager* manager,
-      const GURL& origin,
-      StorageType type,
-      base::Time modified_time)
-      : DatabaseTaskBase(manager),
-        origin_(origin),
-        type_(type),
-        modified_time_(modified_time) {}
-
- protected:
-  virtual void RunOnTargetThread() OVERRIDE {
-    if (!database()->SetOriginLastModifiedTime(
-            origin_, type_, modified_time_)) {
-      set_db_disabled(true);
-    }
-  }
-  virtual void DatabaseTaskCompleted() OVERRIDE {}
-
- private:
-  GURL origin_;
-  StorageType type_;
-  base::Time modified_time_;
-};
-
-class QuotaManager::GetModifiedSinceTask
-    : public QuotaManager::DatabaseTaskBase {
- public:
-  GetModifiedSinceTask(
-      QuotaManager* manager,
-      StorageType type,
-      base::Time modified_since,
-      GetOriginsCallback* callback)
-      : DatabaseTaskBase(manager),
-        type_(type),
-        modified_since_(modified_since),
-        callback_(callback) {}
-
- protected:
-  virtual void RunOnTargetThread() OVERRIDE {
-    if (!database()->GetOriginsModifiedSince(
-            type_, &origins_, modified_since_)) {
-      set_db_disabled(true);
-    }
-  }
-
-  virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_->Run(origins_);
-  }
-
-  virtual void Aborted() OVERRIDE {
-    callback_->Run(std::set<GURL>());
-  }
-
- private:
-  StorageType type_;
-  base::Time modified_since_;
-  std::set<GURL> origins_;
-  scoped_ptr<GetOriginsCallback> callback_;
-};
-
 class QuotaManager::DumpQuotaTableTask
     : public QuotaManager::DatabaseTaskBase {
  private:
   typedef QuotaManager::DumpQuotaTableTask self_type;
   typedef QuotaManager::DumpQuotaTableCallback Callback;
   typedef QuotaManager::QuotaTableEntry TableEntry;
   typedef QuotaManager::QuotaTableEntries TableEntries;
   typedef QuotaDatabase::QuotaTableCallback TableCallback;
 
  public:
   DumpQuotaTableTask(
       QuotaManager* manager,
       Callback* callback)
       : DatabaseTaskBase(manager),
         callback_(callback) {
   }
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->DumpQuotaTable(
             new TableCallback(
                 base::Bind(&self_type::AppendEntry, this))))
       set_db_disabled(true);
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_->Run(TableEntries());
+    callback_->Run(entries_);
   }
 
   virtual void DatabaseTaskCompleted() OVERRIDE {
     callback_->Run(entries_);
   }
 
  private:
   bool AppendEntry(const TableEntry& entry) {
     entries_.push_back(entry);
     return true;
   }
 
   scoped_ptr<Callback> callback_;
   TableEntries entries_;
 };
 
-class QuotaManager::DumpOriginInfoTableTask
+class QuotaManager::DumpLastAccessTimeTableTask
     : public QuotaManager::DatabaseTaskBase {
  private:
-  typedef QuotaManager::DumpOriginInfoTableTask self_type;
-  typedef QuotaManager::DumpOriginInfoTableCallback Callback;
-  typedef QuotaManager::OriginInfoTableEntry TableEntry;
-  typedef QuotaManager::OriginInfoTableEntries TableEntries;
-  typedef QuotaDatabase::OriginInfoTableCallback TableCallback;
+  typedef QuotaManager::DumpLastAccessTimeTableTask self_type;
+  typedef QuotaManager::DumpLastAccessTimeTableCallback Callback;
+  typedef QuotaManager::LastAccessTimeTableEntry TableEntry;
+  typedef QuotaManager::LastAccessTimeTableEntries TableEntries;
+  typedef QuotaDatabase::LastAccessTimeTableCallback TableCallback;
 
  public:
-  DumpOriginInfoTableTask(
+  DumpLastAccessTimeTableTask(
       QuotaManager* manager,
       Callback* callback)
       : DatabaseTaskBase(manager),
         callback_(callback) {
   }
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
-    if (!database()->DumpOriginInfoTable(
+    if (!database()->DumpLastAccessTimeTable(
             new TableCallback(
                 base::Bind(&self_type::AppendEntry, this))))
       set_db_disabled(true);
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_->Run(TableEntries());
+    callback_->Run(entries_);
   }
 
   virtual void DatabaseTaskCompleted() OVERRIDE {
     callback_->Run(entries_);
   }
 
  private:
   bool AppendEntry(const TableEntry& entry) {
     entries_.push_back(entry);
     return true;
@@ skipping 84 matching lines @@
                                            QuotaCallback* callback) {
   LazyInitialize();
   if (new_quota < 0) {
     callback->Run(kQuotaErrorInvalidModification,
                   kStorageTypeTemporary, -1);
     delete callback;
     return;
   }
 
   if (!db_disabled_) {
-    scoped_refptr<UpdateTemporaryGlobalQuotaTask> task(
-        new UpdateTemporaryGlobalQuotaTask(this, new_quota, callback));
+    scoped_refptr<TemporaryGlobalQuotaUpdateTask> task(
+        new TemporaryGlobalQuotaUpdateTask(this, new_quota, callback));
     task->Start();
   } else {
     callback->Run(kQuotaErrorInvalidAccess,
                   kStorageTypeTemporary, -1);
     delete callback;
   }
 }
 
 void QuotaManager::GetPersistentHostQuota(const std::string& host,
                                           HostQuotaCallback* callback_ptr) {
   scoped_ptr<HostQuotaCallback> callback(callback_ptr);
   LazyInitialize();
   if (host.empty()) {
     // This could happen if we are called on file:///.
     // TODO(kinuko) We may want to respect --allow-file-access-from-files
     // command line switch.
     callback->Run(kQuotaStatusOk, host, kStorageTypePersistent, 0);
     return;
   }
-  scoped_refptr<GetPersistentHostQuotaTask> task(
-      new GetPersistentHostQuotaTask(this, host, callback.release()));
+  scoped_refptr<PersistentHostQuotaQueryTask> task(
+      new PersistentHostQuotaQueryTask(this, host, callback.release()));
   task->Start();
 }
 
 void QuotaManager::SetPersistentHostQuota(const std::string& host,
                                           int64 new_quota,
                                           HostQuotaCallback* callback_ptr) {
   scoped_ptr<HostQuotaCallback> callback(callback_ptr);
   LazyInitialize();
   if (host.empty()) {
     // This could happen if we are called on file:///.
     callback->Run(kQuotaErrorNotSupported, host, kStorageTypePersistent, 0);
     return;
   }
   if (new_quota < 0) {
     callback->Run(kQuotaErrorInvalidModification,
                   host, kStorageTypePersistent, -1);
     return;
   }
 
   if (!db_disabled_) {
-    scoped_refptr<UpdatePersistentHostQuotaTask> task(
-        new UpdatePersistentHostQuotaTask(
+    scoped_refptr<PersistentHostQuotaUpdateTask> task(
+        new PersistentHostQuotaUpdateTask(
             this, host, new_quota, callback.release()));
     task->Start();
   } else {
     callback->Run(kQuotaErrorInvalidAccess,
                   host, kStorageTypePersistent, -1);
   }
 }
 
 void QuotaManager::GetGlobalUsage(
     StorageType type,
@@ skipping 14 matching lines @@
   if (temporary_storage_evictor_.get()) {
     std::map<std::string, int64> stats;
     temporary_storage_evictor_->GetStatistics(&stats);
     for (std::map<std::string, int64>::iterator p = stats.begin();
          p != stats.end();
          ++p)
       (*statistics)[p->first] = base::Int64ToString(p->second);
   }
 }
 
-void QuotaManager::GetOriginsModifiedSince(
-    StorageType type,
-    base::Time modified_since,
-    GetOriginsCallback* callback) {
-  LazyInitialize();
-  make_scoped_refptr(new GetModifiedSinceTask(
-      this, type, modified_since, callback))->Start();
-}
-
 void QuotaManager::LazyInitialize() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   if (database_.get()) {
     // Initialization seems to be done already.
     return;
   }
 
   // Use an empty path to open an in-memory only databse for incognito.
   database_.reset(new QuotaDatabase(is_incognito_ ? FilePath() :
       profile_path_.AppendASCII(kDatabaseName)));
@@ skipping 18 matching lines @@
 
 void QuotaManager::NotifyStorageAccessed(
     QuotaClient::ID client_id,
     const GURL& origin, StorageType type) {
   NotifyStorageAccessedInternal(client_id, origin, type, base::Time::Now());
 }
 
 void QuotaManager::NotifyStorageModified(
     QuotaClient::ID client_id,
     const GURL& origin, StorageType type, int64 delta) {
-  NotifyStorageModifiedInternal(client_id, origin, type, delta,
-                                base::Time::Now());
+  LazyInitialize();
+  GetUsageTracker(type)->UpdateUsageCache(client_id, origin, delta);
 }
 
 void QuotaManager::NotifyOriginInUse(const GURL& origin) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   origins_in_use_[origin]++;
 }
 
 void QuotaManager::NotifyOriginNoLongerInUse(const GURL& origin) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   DCHECK(IsOriginInUse(origin));
@@ skipping 53 matching lines @@
     base::Time accessed_time) {
   LazyInitialize();
   if (type == kStorageTypeTemporary && lru_origin_callback_.get()) {
     // Record the accessed origins while GetLRUOrigin task is runing
     // to filter out them from eviction.
     access_notified_origins_.insert(origin);
   }
 
   if (db_disabled_)
     return;
-  make_scoped_refptr(new UpdateAccesTimeTask(
-      this, origin, type, accessed_time))->Start();
-}
-
-void QuotaManager::NotifyStorageModifiedInternal(
-    QuotaClient::ID client_id,
-    const GURL& origin,
-    StorageType type,
-    int64 delta,
-    base::Time modified_time) {
-  LazyInitialize();
-  GetUsageTracker(type)->UpdateUsageCache(client_id, origin, delta);
-  make_scoped_refptr(new UpdateModifiedTimeTask(
-      this, origin, type, modified_time))->Start();
+  scoped_refptr<OriginAccessRecordDatabaseTask> task(
+      new OriginAccessRecordDatabaseTask(this, origin, type, accessed_time));
+  task->Start();
 }
 
 void QuotaManager::DumpQuotaTable(DumpQuotaTableCallback* callback) {
   make_scoped_refptr(new DumpQuotaTableTask(this, callback))->Start();
 }
 
-void QuotaManager::DumpOriginInfoTable(
-    DumpOriginInfoTableCallback* callback) {
-  make_scoped_refptr(new DumpOriginInfoTableTask(this, callback))->Start();
+void QuotaManager::DumpLastAccessTimeTable(
+    DumpLastAccessTimeTableCallback* callback) {
+  make_scoped_refptr(new DumpLastAccessTimeTableTask(this, callback))->Start();
 }
 
 
 void QuotaManager::DeleteOriginFromDatabase(
     const GURL& origin, StorageType type) {
   LazyInitialize();
   if (db_disabled_)
     return;
-  scoped_refptr<DeleteOriginInfo> task =
-      new DeleteOriginInfo(this, origin, type);
+  scoped_refptr<OriginDeletionDatabaseTask> task =
+      new OriginDeletionDatabaseTask(this, origin, type);
   task->Start();
 }
 
 void QuotaManager::GetLRUOrigin(
     StorageType type,
     GetLRUOriginCallback* callback) {
   LazyInitialize();
   // This must not be called while there's an in-flight task.
   DCHECK(!lru_origin_callback_.get());
   lru_origin_callback_.reset(callback);
@@ skipping 115 matching lines @@
   // for eviction later.)
   temporary_usage_tracker_->GetGlobalUsage(callback_factory_.NewCallback(
       &QuotaManager::DidRunInitialGetTemporaryGlobalUsage));
 }
 
 void QuotaManager::DidRunInitialGetTemporaryGlobalUsage(
     StorageType type, int64 usage_unused, int64 unlimited_usage_unused) {
   DCHECK_EQ(type, kStorageTypeTemporary);
   // This will call the StartEviction() when initial origin registration
   // is completed.
-  scoped_refptr<InitializeTemporaryOriginsInfoTask> task(
-      new InitializeTemporaryOriginsInfoTask(
+  scoped_refptr<TemporaryOriginsRegistrationTask> task(
+      new TemporaryOriginsRegistrationTask(
           this, temporary_usage_tracker_.get()));
   task->Start();
 }
 
 void QuotaManager::DidGetDatabaseLRUOrigin(const GURL& origin) {
   // Make sure the returned origin is (still) not in the origin_in_use_ set
   // and has not been accessed since we posted the task.
   if (origins_in_use_.find(origin) != origins_in_use_.end() ||
       access_notified_origins_.find(origin) != access_notified_origins_.end())
     lru_origin_callback_->Run(GURL());
@@ skipping 83 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::MessageLoopProxy* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota