[Quota] Lower quota for ephemeral mode (ie. session only)

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 197 matching lines @@
 }
 
 }  // namespace
 
 class QuotaManager::UsageAndQuotaHelper : public QuotaTask {
  public:
   UsageAndQuotaHelper(QuotaManager* manager,
                       const GURL& origin,
                       StorageType type,
                       bool is_unlimited,
+                      bool is_session_only,
                       bool is_incognito,
                       const UsageAndQuotaCallback& callback)
       : QuotaTask(manager),
         origin_(origin),
         callback_(callback),
         type_(type),
         is_unlimited_(is_unlimited),
+        is_session_only_(is_session_only),
         is_incognito_(is_incognito),
         weak_factory_(this) {}
 
  protected:
   void Run() override {
     // Start the async process of gathering the info we need.
     // Gather 4 pieces of info before computing an answer:
     // settings, device_storage_capacity, host_usage, and host_quota.
     base::Closure barrier = base::BarrierClosure(
         4, base::Bind(&UsageAndQuotaHelper::OnBarrierComplete,
@@ skipping 58 matching lines @@
  private:
   QuotaManager* manager() const {
     return static_cast<QuotaManager*>(observer());
   }
 
   void OnGotSettings(const base::Closure& barrier_closure,
                      const QuotaSettings& settings) {
     settings_ = settings;
     barrier_closure.Run();
     if (type_ == kStorageTypeTemporary && !is_unlimited_) {
-      SetDesiredHostQuota(barrier_closure, kQuotaStatusOk,
-                          settings.per_host_quota);
+      int64_t host_quota = is_session_only_
+                               ? settings.session_only_per_host_quota
+                               : settings.per_host_quota;
+      SetDesiredHostQuota(barrier_closure, kQuotaStatusOk, host_quota);
     }
   }
 
   void OnGotCapacity(const base::Closure& barrier_closure,
                      int64_t total_space,
                      int64_t available_space) {
     total_space_ = total_space;
     available_space_ = available_space;
     barrier_closure.Run();
   }
 
   void OnGotHostUsage(const base::Closure& barrier_closure, int64_t usage) {
     host_usage_ = usage;
     barrier_closure.Run();
   }
 
   void SetDesiredHostQuota(const base::Closure& barrier_closure,
                            QuotaStatusCode status,
                            int64_t quota) {
     desired_host_quota_ = quota;
     barrier_closure.Run();
   }
 
   void OnBarrierComplete() { CallCompleted(); }
 
   GURL origin_;
   QuotaManager::UsageAndQuotaCallback callback_;
   StorageType type_;
   bool is_unlimited_;
+  bool is_session_only_;
   bool is_incognito_;
   int64_t available_space_ = 0;
   int64_t total_space_ = 0;
   int64_t desired_host_quota_ = 0;
   int64_t host_usage_ = 0;
   QuotaSettings settings_;
   base::WeakPtrFactory<UsageAndQuotaHelper> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(UsageAndQuotaHelper);
 };
 
@@ skipping 490 matching lines @@
     const GURL& origin,
     StorageType type,
     const UsageAndQuotaCallback& callback) {
   DCHECK(origin == origin.GetOrigin());
   if (!IsSupportedType(type) ||
       (is_incognito_ && !IsSupportedIncognitoType(type))) {
     callback.Run(kQuotaErrorNotSupported, 0, 0);
     return;
   }
   LazyInitialize();
+
+  bool is_session_only = special_storage_policy_.get() &&

[cmumford, 2017/04/04 16:38:29]

Nit: scoped_refptr has:

explicit operator bool() const { return ptr_ != nullptr; }

so you can omit the ".get()" right?

[michaeln, 2017/04/05 01:20:56]

Done.

+                         special_storage_policy_->IsStorageSessionOnly(origin);
   UsageAndQuotaHelper* helper = new UsageAndQuotaHelper(
-      this, origin, type, IsStorageUnlimited(origin, type), is_incognito_,
-      callback);
+      this, origin, type, IsStorageUnlimited(origin, type), is_session_only,
+      is_incognito_, callback);
   helper->Start();
 }
 
 void QuotaManager::GetUsageAndQuota(const GURL& origin,
                                     StorageType type,
                                     const UsageAndQuotaCallback& callback) {
   DCHECK(origin == origin.GetOrigin());
 
   if (IsStorageUnlimited(origin, type)) {
     // TODO(michaeln): This seems like a non-obvious odd behavior, probably for
@@ skipping 819 matching lines @@
 }
 
 // static
 std::tuple<int64_t, int64_t> QuotaManager::GetVolumeInfo(
     const base::FilePath& path) {
   return std::make_tuple(base::SysInfo::AmountOfTotalDiskSpace(path),
                          base::SysInfo::AmountOfFreeDiskSpace(path));
 }
 
 }  // namespace storage