WIP Durable storage, chrome side

storage/browser/quota/quota_manager.cc

 // Copyright 2013 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 "storage/browser/quota/quota_manager.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
@@ skipping 132 matching lines @@
 bool GetLRUOriginOnDBThread(StorageType type,
                             std::set<GURL>* exceptions,
                             SpecialStoragePolicy* policy,
                             GURL* url,
                             QuotaDatabase* database) {
   DCHECK(database);
   database->GetLRUOrigin(type, *exceptions, policy, url);
   return true;
 }
 
+bool GetDurableOnDBThread(const GURL& origin,
+                          bool* durable,
+                          QuotaDatabase* database) {
+  DCHECK(database);
+  return database->GetDurabilityForOrigin(origin, durable);
+}
+
 bool DeleteOriginInfoOnDBThread(const GURL& origin,
                                 StorageType type,
                                 QuotaDatabase* database) {
   DCHECK(database);
   return database->DeleteOriginInfo(origin, type);
 }
 
 bool InitializeTemporaryOriginsInfoOnDBThread(const std::set<GURL>* origins,
                                               QuotaDatabase* database) {
   DCHECK(database);
@@ skipping 546 matching lines @@
 
 class QuotaManager::GetModifiedSinceHelper {
  public:
   bool GetModifiedSinceOnDBThread(StorageType type,
                                   base::Time modified_since,
                                   QuotaDatabase* database) {
     DCHECK(database);
     return database->GetOriginsModifiedSince(type, &origins_, modified_since);
   }
 
+
   void DidGetModifiedSince(const base::WeakPtr<QuotaManager>& manager,
                            const GetOriginsCallback& callback,
                            StorageType type,
                            bool success) {
     if (!manager) {
       // The operation was aborted.
       callback.Run(std::set<GURL>(), type);
       return;
     }
     manager->DidDatabaseWork(success);
@@ skipping 96 matching lines @@
 void QuotaManager::GetUsageAndQuotaForWebApps(
     const GURL& origin,
     StorageType type,
     const GetUsageAndQuotaCallback& callback) {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/477117 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "477117 QuotaManager::GetUsageAndQuotaForWebApps"));
   if (type != kStorageTypeTemporary &&
       type != kStorageTypePersistent &&
+      type != kStorageTypeDurable &&
       type != kStorageTypeSyncable) {
     callback.Run(kQuotaErrorNotSupported, 0, 0);
     return;
   }
 
   DCHECK(origin == origin.GetOrigin());
   LazyInitialize();
 
   bool unlimited = IsStorageUnlimited(origin, type);
   bool can_query_disk_size = CanQueryDiskSize(origin);
@@ skipping 197 matching lines @@
                  weak_factory_.GetWeakPtr(),
                  host,
                  base::Owned(quota_ptr)));
 }
 
 void QuotaManager::SetPersistentHostQuota(const std::string& host,
                                           int64 new_quota,
                                           const QuotaCallback& callback) {
   LazyInitialize();
   if (host.empty()) {
+    LOG(ERROR) << "Calling with kQuotaErrorNotSupported";
     // This could happen if we are called on file:///.
     callback.Run(kQuotaErrorNotSupported, 0);
     return;
   }
 
   if (new_quota < 0) {
     callback.Run(kQuotaErrorInvalidModification, -1);
     return;
   }
 
@@ skipping 74 matching lines @@
   // For syncable storage we should always enforce quota (since the
   // quota must be capped by the server limit).
   if (type == kStorageTypeSyncable)
     return false;
   if (type == kStorageTypeQuotaNotManaged)
     return true;
   return special_storage_policy_.get() &&
          special_storage_policy_->IsStorageUnlimited(origin);
 }
 
+void QuotaManager::GetDurability(const GURL& origin,
+                                 const GetDurabilityCallback& callback) {
+  LazyInitialize();
+  LOG(ERROR) << "Got into QuotaManager::GetDurability";
+
+  // if db is hosed, do something with callback
+
+  bool* is_durable = new bool;
+  PostTaskAndReplyWithResultForDBThread(
+      FROM_HERE,
+      base::Bind(&GetDurableOnDBThread,
+                 origin,
+                 base::Unretained(is_durable)),
+      base::Bind(&QuotaManager::DidGetDurability,
+                 weak_factory_.GetWeakPtr(),
+                 callback,
+                 base::Owned(is_durable)));
+}
+
 void QuotaManager::GetOriginsModifiedSince(StorageType type,
                                            base::Time modified_since,
                                            const GetOriginsCallback& callback) {
   LazyInitialize();
   GetModifiedSinceHelper* helper = new GetModifiedSinceHelper;
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&GetModifiedSinceHelper::GetModifiedSinceOnDBThread,
                  base::Unretained(helper),
                  type,
@@ skipping 106 matching lines @@
   switch (type) {
     case kStorageTypeTemporary:
       return temporary_usage_tracker_.get();
     case kStorageTypePersistent:
       return persistent_usage_tracker_.get();
     case kStorageTypeSyncable:
       return syncable_usage_tracker_.get();
     case kStorageTypeQuotaNotManaged:
       return NULL;
     case kStorageTypeUnknown:
+    case kStorageTypeDurable:
       NOTREACHED();
   }
   return NULL;
 }
 
 void QuotaManager::GetCachedOrigins(
     StorageType type, std::set<GURL>* origins) {
   DCHECK(origins);
   LazyInitialize();
   DCHECK(GetUsageTracker(type));
@@ skipping 317 matching lines @@
 }
 
 void QuotaManager::DidGetAvailableSpace(int64 space) {
   available_space_callbacks_.Run(kQuotaStatusOk, space);
 }
 
 void QuotaManager::DidDatabaseWork(bool success) {
   db_disabled_ = !success;
 }
 
+void QuotaManager::DidGetDurability(const GetDurabilityCallback& callback,
+                                    const bool* durable,
+                                    bool success) {
+  DidDatabaseWork(success);
+  if (!success) {
+    NOTREACHED() << "Add a test for this";
+    callback.Run(kQuotaErrorInvalidAccess, false /*durability*/);
+    return;
+  }
+  callback.Run(kQuotaStatusOk, *durable);
+}
+
 void QuotaManager::DeleteOnCorrectThread() const {
   if (!io_thread_->BelongsToCurrentThread() &&
       io_thread_->DeleteSoon(FROM_HERE, this)) {
     return;
   }
   delete this;
 }
 
 void QuotaManager::PostTaskAndReplyWithResultForDBThread(
     const tracked_objects::Location& from_here,
     const base::Callback<bool(QuotaDatabase*)>& task,
     const base::Callback<void(bool)>& reply) {
   // Deleting manager will post another task to DB thread to delete
   // |database_|, therefore we can be sure that database_ is alive when this
   // task runs.
   base::PostTaskAndReplyWithResult(
       db_thread_.get(),
       from_here,
       base::Bind(task, base::Unretained(database_.get())),
       reply);
 }
 
 }  // namespace storage