WIP Durable storage, chrome side

content/browser/quota_dispatcher_host.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 "content/browser/quota_dispatcher_host.h"
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "content/common/quota_messages.h"
@@ skipping 65 matching lines @@
         base::Bind(&QueryUsageAndQuotaDispatcher::DidQueryStorageUsageAndQuota,
                    weak_factory_.GetWeakPtr()));
   }
 
  private:
   void DidQueryStorageUsageAndQuota(
       QuotaStatusCode status, int64 usage, int64 quota) {
     if (!dispatcher_host())
       return;
     if (status != storage::kQuotaStatusOk) {
+      LOG(ERROR) << "Sending DidFail";
       dispatcher_host()->Send(new QuotaMsg_DidFail(request_id(), status));
     } else {
       dispatcher_host()->Send(new QuotaMsg_DidQueryStorageUsageAndQuota(
           request_id(), usage, quota));
     }
     Completed();
   }
 
   base::WeakPtrFactory<QueryUsageAndQuotaDispatcher> weak_factory_;
 };
@@ skipping 15 matching lines @@
     // requires int64 values.
     // TODO(nhiroki): The backend should accept uint64 values.
     requested_quota_ = base::saturated_cast<int64>(params_.requested_size);
   }
   ~RequestQuotaDispatcher() override {}
 
   void Start() {
     DCHECK(dispatcher_host());
 
     DCHECK(params_.storage_type == storage::kStorageTypeTemporary ||
-           params_.storage_type == storage::kStorageTypePersistent);
+           params_.storage_type == storage::kStorageTypePersistent ||
+           params_.storage_type == storage::kStorageTypeDurable);
     if (params_.storage_type == storage::kStorageTypePersistent) {
       quota_manager()->GetUsageAndQuotaForWebApps(
           params_.origin_url, params_.storage_type,
           base::Bind(&self_type::DidGetPersistentUsageAndQuota,
                      weak_factory_.GetWeakPtr()));
+    } else if (params_.storage_type == storage::kStorageTypeDurable) {
+      quota_manager()->GetDurability(
+          params_.origin_url,
+          base::Bind(&self_type::DidGetDurable,
+                     weak_factory_.GetWeakPtr()));
     } else {
+      LOG(ERROR) << "Got here A";
       quota_manager()->GetUsageAndQuotaForWebApps(
           params_.origin_url, params_.storage_type,
           base::Bind(&self_type::DidGetTemporaryUsageAndQuota,
                      weak_factory_.GetWeakPtr()));
     }
   }
 
  private:
+
+  void DidGetDurable(QuotaStatusCode status, bool durable) {
+    LOG(ERROR) << "Inside DidGetDurable = " << status << ":" << durable;
+    if (!dispatcher_host())
+      return;
+    if (status != storage::kQuotaStatusOk) {
+      DidFinish(status, 0, 0);
+      return;
+    }
+
+    if (quota_manager()->IsStorageUnlimited(params_.origin_url,
+                                            params_.storage_type)) {
+      // Seems like we can just let it go.
+      DidFinish(storage::kQuotaStatusOk, 0, 0);
+      return;
+    }
+    if (durable) {
+      DidFinish(status, 0, 0);
+      return;
+    }
+    LOG(ERROR) << "Need to ask for permission.";
+  }
+
   void DidGetPersistentUsageAndQuota(QuotaStatusCode status,
                                      int64 usage,
                                      int64 quota) {
     if (!dispatcher_host())
       return;
     if (status != storage::kQuotaStatusOk) {
       DidFinish(status, 0, 0);
       return;
     }
 
     if (quota_manager()->IsStorageUnlimited(params_.origin_url,
                                             params_.storage_type) ||
         requested_quota_ <= quota) {
       // Seems like we can just let it go.
       DidFinish(storage::kQuotaStatusOk, usage, params_.requested_size);
       return;
     }
     current_usage_ = usage;
     current_quota_ = quota;
 
     // Otherwise we need to consult with the permission context and
     // possibly show a prompt.
     DCHECK(permission_context());
+    LOG(ERROR) << "About to RequestQuotaPermission";
     permission_context()->RequestQuotaPermission(params_, render_process_id(),
         base::Bind(&self_type::DidGetPermissionResponse,
                    weak_factory_.GetWeakPtr()));
   }
 
   void DidGetTemporaryUsageAndQuota(QuotaStatusCode status,
                                     int64 usage,
                                     int64 quota) {
     DidFinish(status, usage, std::min(requested_quota_, quota));
   }
@@ skipping 15 matching lines @@
 
   void DidSetHostQuota(QuotaStatusCode status, int64 new_quota) {
     DidFinish(status, current_usage_, new_quota);
   }
 
   void DidFinish(QuotaStatusCode status,
                  int64 usage,
                  int64 granted_quota) {
     if (!dispatcher_host())
       return;
-    DCHECK(dispatcher_host());
     if (status != storage::kQuotaStatusOk) {
+      LOG(ERROR) << "Sending DidFail, status = " << status;
       dispatcher_host()->Send(new QuotaMsg_DidFail(request_id(), status));
     } else {
       dispatcher_host()->Send(new QuotaMsg_DidGrantStorageQuota(
           request_id(), usage, granted_quota));
     }
     Completed();
   }
 
   StorageQuotaParams params_;
   int64 current_usage_;
@@ skipping 31 matching lines @@
     int request_id,
     const GURL& origin,
     StorageType type) {
   QueryUsageAndQuotaDispatcher* dispatcher = new QueryUsageAndQuotaDispatcher(
       weak_factory_.GetWeakPtr(), request_id);
   dispatcher->QueryStorageUsageAndQuota(origin, type);
 }
 
 void QuotaDispatcherHost::OnRequestStorageQuota(
     const StorageQuotaParams& params) {
+  LOG(ERROR)
+      << "Got into QuotaDispatcherHost::OnRequestStorageQuota storage_type = "
+      << params.storage_type;
   if (params.storage_type != storage::kStorageTypeTemporary &&
+      params.storage_type != storage::kStorageTypeDurable &&
       params.storage_type != storage::kStorageTypePersistent) {
     // Unsupported storage types.
+    LOG(ERROR) << "Sending DidFail";
     Send(new QuotaMsg_DidFail(params.request_id,
                               storage::kQuotaErrorNotSupported));
     return;
   }
 
   RequestQuotaDispatcher* dispatcher =
       new RequestQuotaDispatcher(weak_factory_.GetWeakPtr(),
                                  params);
   dispatcher->Start();
 }
 
 }  // namespace content