Convert storage/browser/fileapi/quota to use url::Origin

Update the code directory to use the dedicated Origin type instead of URL.
The next step would be storage/browser/fileapi.

Bug: 598424
Change-Id: I5dab8c9b7c097eb163d7565149b577f73850381d
Reviewed-on: https://chromium-review.googlesource.com/1128796Reviewed-by: Joshua Bell <jsbell@chromium.org>
Reviewed-by: Bill Budge <bbudge@chromium.org>
Commit-Queue: Joshua Bell <jsbell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#574202}

content/browser/renderer_host/pepper/quota_reservation_unittest.cc

@@ -21,6 +21,7 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "storage/browser/fileapi/quota/quota_reservation.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/origin.h"
 
 using storage::QuotaReservationManager;
 
@@ -44,7 +45,7 @@ class FakeBackend : public QuotaReservationManager::QuotaBackend {
   ~FakeBackend() override {}
 
   void ReserveQuota(
-      const GURL& origin,
+      const url::Origin& origin,
       storage::FileSystemType type,
       int64_t delta,
       const QuotaReservationManager::ReserveQuotaCallback& callback) override {
@@ -53,17 +54,17 @@ class FakeBackend : public QuotaReservationManager::QuotaBackend {
                                   base::File::FILE_OK, delta));
   }
 
-  void ReleaseReservedQuota(const GURL& origin,
+  void ReleaseReservedQuota(const url::Origin& origin,
                             storage::FileSystemType type,
                             int64_t size) override {}
 
-  void CommitQuotaUsage(const GURL& origin,
+  void CommitQuotaUsage(const url::Origin& origin,
                         storage::FileSystemType type,
                         int64_t delta) override {}
 
-  void IncrementDirtyCount(const GURL& origin,
+  void IncrementDirtyCount(const url::Origin& origin,
                            storage::FileSystemType type) override {}
-  void DecrementDirtyCount(const GURL& origin,
+  void DecrementDirtyCount(const url::Origin& origin,
                            storage::FileSystemType type) override {}
 
  private:
@@ -160,7 +161,8 @@ TEST_F(QuotaReservationTest, ReserveQuota) {
   storage::FileSystemType type = kType;
 
   scoped_refptr<storage::QuotaReservation> reservation(
-      reservation_manager()->CreateReservation(origin, type));
+      reservation_manager()->CreateReservation(url::Origin::Create(origin),
+                                               type));
   scoped_refptr<QuotaReservation> test =
       CreateQuotaReservation(reservation, origin, type);
 
@@ -201,7 +203,8 @@ TEST_F(QuotaReservationTest, MultipleFiles) {
   storage::FileSystemType type = kType;
 
   scoped_refptr<storage::QuotaReservation> reservation(
-      reservation_manager()->CreateReservation(origin, type));
+      reservation_manager()->CreateReservation(url::Origin::Create(origin),
+                                               type));
   scoped_refptr<QuotaReservation> test =
       CreateQuotaReservation(reservation, origin, type);
 

storage/browser/fileapi/quota/quota_backend_impl.cc

@@ -35,41 +35,40 @@ QuotaBackendImpl::QuotaBackendImpl(
 
 QuotaBackendImpl::~QuotaBackendImpl() = default;
 
-void QuotaBackendImpl::ReserveQuota(const GURL& origin,
+void QuotaBackendImpl::ReserveQuota(const url::Origin& origin,
                                     FileSystemType type,
                                     int64_t delta,
                                     const ReserveQuotaCallback& callback) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   if (!delta) {
     callback.Run(base::File::FILE_OK, 0);
     return;
   }
   DCHECK(quota_manager_proxy_.get());
   quota_manager_proxy_->GetUsageAndQuota(
-      file_task_runner_.get(), url::Origin::Create(origin),
-      FileSystemTypeToQuotaStorageType(type),
+      file_task_runner_.get(), origin, FileSystemTypeToQuotaStorageType(type),
       base::BindOnce(&QuotaBackendImpl::DidGetUsageAndQuotaForReserveQuota,
                      weak_ptr_factory_.GetWeakPtr(),
                      QuotaReservationInfo(origin, type, delta), callback));
 }
 
-void QuotaBackendImpl::ReleaseReservedQuota(const GURL& origin,
+void QuotaBackendImpl::ReleaseReservedQuota(const url::Origin& origin,
                                             FileSystemType type,
                                             int64_t size) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   DCHECK_LE(0, size);
   if (!size)
     return;
   ReserveQuotaInternal(QuotaReservationInfo(origin, type, -size));
 }
 
-void QuotaBackendImpl::CommitQuotaUsage(const GURL& origin,
+void QuotaBackendImpl::CommitQuotaUsage(const url::Origin& origin,
                                         FileSystemType type,
                                         int64_t delta) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   if (!delta)
     return;
   ReserveQuotaInternal(QuotaReservationInfo(origin, type, delta));
@@ -80,10 +79,10 @@ void QuotaBackendImpl::CommitQuotaUsage(const GURL& origin,
   DCHECK(result);
 }
 
-void QuotaBackendImpl::IncrementDirtyCount(const GURL& origin,
+void QuotaBackendImpl::IncrementDirtyCount(const url::Origin& origin,
                                            FileSystemType type) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   base::FilePath path;
   if (GetUsageCachePath(origin, type, &path) != base::File::FILE_OK)
     return;
@@ -91,10 +90,10 @@ void QuotaBackendImpl::IncrementDirtyCount(const GURL& origin,
   file_system_usage_cache_->IncrementDirty(path);
 }
 
-void QuotaBackendImpl::DecrementDirtyCount(const GURL& origin,
+void QuotaBackendImpl::DecrementDirtyCount(const url::Origin& origin,
                                            FileSystemType type) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   base::FilePath path;
   if (GetUsageCachePath(origin, type, &path) != base::File::FILE_OK)
     return;
@@ -109,7 +108,7 @@ void QuotaBackendImpl::DidGetUsageAndQuotaForReserveQuota(
     int64_t usage,
     int64_t quota) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(info.origin.is_valid());
+  DCHECK(!info.origin.unique());
   DCHECK_LE(0, usage);
   DCHECK_LE(0, quota);
   if (status != blink::mojom::QuotaStatusCode::kOk) {
@@ -139,29 +138,29 @@ void QuotaBackendImpl::DidGetUsageAndQuotaForReserveQuota(
 
 void QuotaBackendImpl::ReserveQuotaInternal(const QuotaReservationInfo& info) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(info.origin.is_valid());
+  DCHECK(!info.origin.unique());
   DCHECK(quota_manager_proxy_.get());
   quota_manager_proxy_->NotifyStorageModified(
-      storage::QuotaClient::kFileSystem, url::Origin::Create(info.origin),
+      storage::QuotaClient::kFileSystem, info.origin,
       FileSystemTypeToQuotaStorageType(info.type), info.delta);
 }
 
 base::File::Error QuotaBackendImpl::GetUsageCachePath(
-    const GURL& origin,
+    const url::Origin& origin,
     FileSystemType type,
     base::FilePath* usage_file_path) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   DCHECK(usage_file_path);
   base::File::Error error = base::File::FILE_OK;
   *usage_file_path =
       SandboxFileSystemBackendDelegate::GetUsageCachePathForOriginAndType(
-          obfuscated_file_util_, origin, type, &error);
+          obfuscated_file_util_, origin.GetURL(), type, &error);
   return error;
 }
 
 QuotaBackendImpl::QuotaReservationInfo::QuotaReservationInfo(
-    const GURL& origin,
+    const url::Origin& origin,
     FileSystemType type,
     int64_t delta)
     : origin(origin), type(type), delta(delta) {}

storage/browser/fileapi/quota/quota_backend_impl.h

@@ -14,6 +14,7 @@
 #include "storage/browser/fileapi/sandbox_file_system_backend_delegate.h"
 #include "storage/browser/storage_browser_export.h"
 #include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
+#include "url/origin.h"
 
 namespace base {
 class SequencedTaskRunner;
@@ -23,14 +24,11 @@ namespace content {
 class QuotaBackendImplTest;
 }
 
-namespace storage {
-class QuotaManagerProxy;
-}
-
 namespace storage {
 
 class FileSystemUsageCache;
 class ObfuscatedFileUtil;
+class QuotaManagerProxy;
 
 // An instance of this class is owned by QuotaReservationManager.
 class STORAGE_EXPORT QuotaBackendImpl
@@ -45,29 +43,31 @@ class STORAGE_EXPORT QuotaBackendImpl
   ~QuotaBackendImpl() override;
 
   // QuotaReservationManager::QuotaBackend overrides.
-  void ReserveQuota(const GURL& origin,
+  void ReserveQuota(const url::Origin& origin,
                     FileSystemType type,
                     int64_t delta,
                     const ReserveQuotaCallback& callback) override;
-  void ReleaseReservedQuota(const GURL& origin,
+  void ReleaseReservedQuota(const url::Origin& origin,
                             FileSystemType type,
                             int64_t size) override;
-  void CommitQuotaUsage(const GURL& origin,
+  void CommitQuotaUsage(const url::Origin& origin,
                         FileSystemType type,
                         int64_t delta) override;
-  void IncrementDirtyCount(const GURL& origin, FileSystemType type) override;
-  void DecrementDirtyCount(const GURL& origin, FileSystemType type) override;
+  void IncrementDirtyCount(const url::Origin& origin,
+                           FileSystemType type) override;
+  void DecrementDirtyCount(const url::Origin& origin,
+                           FileSystemType type) override;
 
  private:
   friend class content::QuotaBackendImplTest;
 
   struct QuotaReservationInfo {
-    QuotaReservationInfo(const GURL& origin,
+    QuotaReservationInfo(const url::Origin& origin,
                          FileSystemType type,
                          int64_t delta);
     ~QuotaReservationInfo();
 
-    GURL origin;
+    url::Origin origin;
     FileSystemType type;
     int64_t delta;
   };
@@ -80,10 +80,9 @@ class STORAGE_EXPORT QuotaBackendImpl
 
   void ReserveQuotaInternal(
       const QuotaReservationInfo& info);
-  base::File::Error GetUsageCachePath(
-      const GURL& origin,
-      FileSystemType type,
-      base::FilePath* usage_file_path);
+  base::File::Error GetUsageCachePath(const url::Origin& origin,
+                                      FileSystemType type,
+                                      base::FilePath* usage_file_path);
 
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
 

storage/browser/fileapi/quota/quota_backend_impl_unittest.cc

@@ -29,7 +29,7 @@ namespace content {
 
 namespace {
 
-const char kOrigin[] = "http://example.com";
+const url::Origin kOrigin(url::Origin::Create(GURL("http://example.com")));
 
 bool DidReserveQuota(bool accepted,
                      base::File::Error* error_out,
@@ -115,16 +115,17 @@ class QuotaBackendImplTest : public testing::Test {
   }
 
  protected:
-  void InitializeForOriginAndType(const GURL& origin,
+  void InitializeForOriginAndType(const url::Origin& origin,
                                   storage::FileSystemType type) {
-    ASSERT_TRUE(file_util_->InitOriginDatabase(origin, true /* create */));
+    ASSERT_TRUE(
+        file_util_->InitOriginDatabase(origin.GetURL(), true /* create */));
     ASSERT_TRUE(file_util_->origin_database_ != NULL);
 
     std::string type_string =
         SandboxFileSystemBackendDelegate::GetTypeString(type);
     base::File::Error error = base::File::FILE_ERROR_FAILED;
     base::FilePath path = file_util_->GetDirectoryForOriginAndType(
-        origin, type_string, true /* create */, &error);
+        origin.GetURL(), type_string, true /* create */, &error);
     ASSERT_EQ(base::File::FILE_OK, error);
 
     ASSERT_TRUE(file_system_usage_cache_.UpdateUsage(
@@ -135,7 +136,7 @@ class QuotaBackendImplTest : public testing::Test {
     return base::ThreadTaskRunnerHandle::Get().get();
   }
 
-  base::FilePath GetUsageCachePath(const GURL& origin,
+  base::FilePath GetUsageCachePath(const url::Origin& origin,
                                    storage::FileSystemType type) {
     base::FilePath path;
     base::File::Error error = backend_->GetUsageCachePath(origin, type, &path);
@@ -158,14 +159,14 @@ class QuotaBackendImplTest : public testing::Test {
 
 TEST_F(QuotaBackendImplTest, ReserveQuota_Basic) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
-  InitializeForOriginAndType(GURL(kOrigin), type);
+  InitializeForOriginAndType(kOrigin, type);
   quota_manager_proxy_->set_quota(10000);
 
   int64_t delta = 0;
 
   const int64_t kDelta1 = 1000;
   base::File::Error error = base::File::FILE_ERROR_FAILED;
-  backend_->ReserveQuota(GURL(kOrigin), type, kDelta1,
+  backend_->ReserveQuota(kOrigin, type, kDelta1,
                          base::Bind(&DidReserveQuota, true, &error, &delta));
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(kDelta1, delta);
@@ -173,7 +174,7 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_Basic) {
 
   const int64_t kDelta2 = -300;
   error = base::File::FILE_ERROR_FAILED;
-  backend_->ReserveQuota(GURL(kOrigin), type, kDelta2,
+  backend_->ReserveQuota(kOrigin, type, kDelta2,
                          base::Bind(&DidReserveQuota, true, &error, &delta));
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(kDelta2, delta);
@@ -184,14 +185,14 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_Basic) {
 
 TEST_F(QuotaBackendImplTest, ReserveQuota_NoSpace) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
-  InitializeForOriginAndType(GURL(kOrigin), type);
+  InitializeForOriginAndType(kOrigin, type);
   quota_manager_proxy_->set_quota(100);
 
   int64_t delta = 0;
 
   const int64_t kDelta = 1000;
   base::File::Error error = base::File::FILE_ERROR_FAILED;
-  backend_->ReserveQuota(GURL(kOrigin), type, kDelta,
+  backend_->ReserveQuota(kOrigin, type, kDelta,
                          base::Bind(&DidReserveQuota, true, &error, &delta));
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(100, delta);
@@ -202,14 +203,14 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_NoSpace) {
 
 TEST_F(QuotaBackendImplTest, ReserveQuota_Revert) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
-  InitializeForOriginAndType(GURL(kOrigin), type);
+  InitializeForOriginAndType(kOrigin, type);
   quota_manager_proxy_->set_quota(10000);
 
   int64_t delta = 0;
 
   const int64_t kDelta = 1000;
   base::File::Error error = base::File::FILE_ERROR_FAILED;
-  backend_->ReserveQuota(GURL(kOrigin), type, kDelta,
+  backend_->ReserveQuota(kOrigin, type, kDelta,
                          base::Bind(&DidReserveQuota, false, &error, &delta));
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(kDelta, delta);
@@ -220,13 +221,13 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_Revert) {
 
 TEST_F(QuotaBackendImplTest, ReleaseReservedQuota) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
-  InitializeForOriginAndType(GURL(kOrigin), type);
+  InitializeForOriginAndType(kOrigin, type);
   const int64_t kInitialUsage = 2000;
   quota_manager_proxy_->set_usage(kInitialUsage);
   quota_manager_proxy_->set_quota(10000);
 
   const int64_t kSize = 1000;
-  backend_->ReleaseReservedQuota(GURL(kOrigin), type, kSize);
+  backend_->ReleaseReservedQuota(kOrigin, type, kSize);
   EXPECT_EQ(kInitialUsage - kSize, quota_manager_proxy_->usage());
 
   EXPECT_EQ(1, quota_manager_proxy_->storage_modified_count());
@@ -234,19 +235,19 @@ TEST_F(QuotaBackendImplTest, ReleaseReservedQuota) {
 
 TEST_F(QuotaBackendImplTest, CommitQuotaUsage) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
-  InitializeForOriginAndType(GURL(kOrigin), type);
+  InitializeForOriginAndType(kOrigin, type);
   quota_manager_proxy_->set_quota(10000);
-  base::FilePath path = GetUsageCachePath(GURL(kOrigin), type);
+  base::FilePath path = GetUsageCachePath(kOrigin, type);
 
   const int64_t kDelta1 = 1000;
-  backend_->CommitQuotaUsage(GURL(kOrigin), type, kDelta1);
+  backend_->CommitQuotaUsage(kOrigin, type, kDelta1);
   EXPECT_EQ(kDelta1, quota_manager_proxy_->usage());
   int64_t usage = 0;
   EXPECT_TRUE(file_system_usage_cache_.GetUsage(path, &usage));
   EXPECT_EQ(kDelta1, usage);
 
   const int64_t kDelta2 = -300;
-  backend_->CommitQuotaUsage(GURL(kOrigin), type, kDelta2);
+  backend_->CommitQuotaUsage(kOrigin, type, kDelta2);
   EXPECT_EQ(kDelta1 + kDelta2, quota_manager_proxy_->usage());
   usage = 0;
   EXPECT_TRUE(file_system_usage_cache_.GetUsage(path, &usage));
@@ -257,15 +258,15 @@ TEST_F(QuotaBackendImplTest, CommitQuotaUsage) {
 
 TEST_F(QuotaBackendImplTest, DirtyCount) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
-  InitializeForOriginAndType(GURL(kOrigin), type);
-  base::FilePath path = GetUsageCachePath(GURL(kOrigin), type);
+  InitializeForOriginAndType(kOrigin, type);
+  base::FilePath path = GetUsageCachePath(kOrigin, type);
 
-  backend_->IncrementDirtyCount(GURL(kOrigin), type);
+  backend_->IncrementDirtyCount(kOrigin, type);
   uint32_t dirty = 0;
   ASSERT_TRUE(file_system_usage_cache_.GetDirty(path, &dirty));
   EXPECT_EQ(1u, dirty);
 
-  backend_->DecrementDirtyCount(GURL(kOrigin), type);
+  backend_->DecrementDirtyCount(kOrigin, type);
   ASSERT_TRUE(file_system_usage_cache_.GetDirty(path, &dirty));
   EXPECT_EQ(0u, dirty);
 }

storage/browser/fileapi/quota/quota_reservation.cc

@@ -67,7 +67,7 @@ QuotaReservationManager* QuotaReservation::reservation_manager() {
   return reservation_buffer_->reservation_manager();
 }
 
-const GURL& QuotaReservation::origin() const {
+const url::Origin& QuotaReservation::origin() const {
   return reservation_buffer_->origin();
 }
 

storage/browser/fileapi/quota/quota_reservation.h

@@ -18,7 +18,9 @@
 #include "storage/browser/storage_browser_export.h"
 #include "storage/common/fileapi/file_system_types.h"
 
-class GURL;
+namespace url {
+class Origin;
+}
 
 namespace storage {
 
@@ -59,7 +61,7 @@ class STORAGE_EXPORT QuotaReservation
   int64_t remaining_quota() const { return remaining_quota_; }
 
   QuotaReservationManager* reservation_manager();
-  const GURL& origin() const;
+  const url::Origin& origin() const;
   FileSystemType type() const;
 
  private:

storage/browser/fileapi/quota/quota_reservation_buffer.cc

@@ -19,13 +19,13 @@ namespace storage {
 
 QuotaReservationBuffer::QuotaReservationBuffer(
     base::WeakPtr<QuotaReservationManager> reservation_manager,
-    const GURL& origin,
+    const url::Origin& origin,
     FileSystemType type)
     : reservation_manager_(reservation_manager),
       origin_(origin),
       type_(type),
       reserved_quota_(0) {
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   DCHECK(sequence_checker_.CalledOnValidSequence());
   reservation_manager_->IncrementDirtyCount(origin, type);
 }
@@ -97,11 +97,11 @@ QuotaReservationBuffer::~QuotaReservationBuffer() {
 // static
 bool QuotaReservationBuffer::DecrementDirtyCount(
     base::WeakPtr<QuotaReservationManager> reservation_manager,
-    const GURL& origin,
+    const url::Origin& origin,
     FileSystemType type,
     base::File::Error error,
     int64_t delta_unused) {
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   if (error == base::File::FILE_OK && reservation_manager) {
     reservation_manager->DecrementDirtyCount(origin, type);
     return true;

storage/browser/fileapi/quota/quota_reservation_buffer.h

@@ -17,7 +17,7 @@
 #include "base/memory/weak_ptr.h"
 #include "storage/browser/storage_browser_export.h"
 #include "storage/common/fileapi/file_system_types.h"
-#include "url/gurl.h"
+#include "url/origin.h"
 
 namespace storage {
 
@@ -37,7 +37,7 @@ class QuotaReservationBuffer : public base::RefCounted<QuotaReservationBuffer> {
  public:
   QuotaReservationBuffer(
       base::WeakPtr<QuotaReservationManager> reservation_manager,
-      const GURL& origin,
+      const url::Origin& origin,
       FileSystemType type);
 
   scoped_refptr<QuotaReservation> CreateReservation();
@@ -52,7 +52,7 @@ class QuotaReservationBuffer : public base::RefCounted<QuotaReservationBuffer> {
     return reservation_manager_.get();
   }
 
-  const GURL& origin() const { return origin_; }
+  const url::Origin& origin() const { return origin_; }
   FileSystemType type() const { return type_; }
 
  private:
@@ -61,7 +61,7 @@ class QuotaReservationBuffer : public base::RefCounted<QuotaReservationBuffer> {
 
   static bool DecrementDirtyCount(
       base::WeakPtr<QuotaReservationManager> reservation_manager,
-      const GURL& origin,
+      const url::Origin& origin,
       FileSystemType type,
       base::File::Error error,
       int64_t delta);
@@ -75,7 +75,7 @@ class QuotaReservationBuffer : public base::RefCounted<QuotaReservationBuffer> {
 
   base::WeakPtr<QuotaReservationManager> reservation_manager_;
 
-  GURL origin_;
+  url::Origin origin_;
   storage::FileSystemType type_;
 
   int64_t reserved_quota_;

storage/browser/fileapi/quota/quota_reservation_manager.cc

@@ -25,46 +25,45 @@ QuotaReservationManager::~QuotaReservationManager() {
 }
 
 void QuotaReservationManager::ReserveQuota(
-    const GURL& origin,
+    const url::Origin& origin,
     FileSystemType type,
     int64_t size,
     const ReserveQuotaCallback& callback) {
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   backend_->ReserveQuota(origin, type, size, callback);
 }
 
-void QuotaReservationManager::ReleaseReservedQuota(const GURL& origin,
+void QuotaReservationManager::ReleaseReservedQuota(const url::Origin& origin,
                                                    FileSystemType type,
                                                    int64_t size) {
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   backend_->ReleaseReservedQuota(origin, type, size);
 }
 
-void QuotaReservationManager::CommitQuotaUsage(const GURL& origin,
+void QuotaReservationManager::CommitQuotaUsage(const url::Origin& origin,
                                                FileSystemType type,
                                                int64_t delta) {
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   backend_->CommitQuotaUsage(origin, type, delta);
 }
 
-void QuotaReservationManager::IncrementDirtyCount(const GURL& origin,
-                                                 FileSystemType type) {
-  DCHECK(origin.is_valid());
+void QuotaReservationManager::IncrementDirtyCount(const url::Origin& origin,
+                                                  FileSystemType type) {
+  DCHECK(!origin.unique());
   backend_->IncrementDirtyCount(origin, type);
 }
 
-void QuotaReservationManager::DecrementDirtyCount(const GURL& origin,
-                                                 FileSystemType type) {
-  DCHECK(origin.is_valid());
+void QuotaReservationManager::DecrementDirtyCount(const url::Origin& origin,
+                                                  FileSystemType type) {
+  DCHECK(!origin.unique());
   backend_->DecrementDirtyCount(origin, type);
 }
 
 scoped_refptr<QuotaReservationBuffer>
-QuotaReservationManager::GetReservationBuffer(
-    const GURL& origin,
-    FileSystemType type) {
+QuotaReservationManager::GetReservationBuffer(const url::Origin& origin,
+                                              FileSystemType type) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   QuotaReservationBuffer** buffer =
       &reservation_buffers_[std::make_pair(origin, type)];
   if (!*buffer) {
@@ -77,16 +76,16 @@ QuotaReservationManager::GetReservationBuffer(
 void QuotaReservationManager::ReleaseReservationBuffer(
     QuotaReservationBuffer* reservation_buffer) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
-  std::pair<GURL, FileSystemType> key(reservation_buffer->origin(),
-                                      reservation_buffer->type());
+  std::pair<url::Origin, FileSystemType> key(reservation_buffer->origin(),
+                                             reservation_buffer->type());
   DCHECK_EQ(reservation_buffers_[key], reservation_buffer);
   reservation_buffers_.erase(key);
 }
 
 scoped_refptr<QuotaReservation> QuotaReservationManager::CreateReservation(
-    const GURL& origin,
+    const url::Origin& origin,
     FileSystemType type) {
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   return GetReservationBuffer(origin, type)->CreateReservation();
 }
 

storage/browser/fileapi/quota/quota_reservation_manager.h

@@ -18,12 +18,15 @@
 #include "base/memory/weak_ptr.h"
 #include "storage/browser/storage_browser_export.h"
 #include "storage/common/fileapi/file_system_types.h"
-#include "url/gurl.h"
 
 namespace content {
 class QuotaReservationManagerTest;
 }
 
+namespace url {
+class Origin;
+}
+
 namespace storage {
 
 class QuotaReservation;
@@ -48,26 +51,26 @@ class STORAGE_EXPORT QuotaReservationManager {
     // Invokes |callback| upon completion with an error code.
     // |callback| should return false if it can't accept the reservation, in
     // that case, the backend should roll back the reservation.
-    virtual void ReserveQuota(const GURL& origin,
+    virtual void ReserveQuota(const url::Origin& origin,
                               FileSystemType type,
                               int64_t delta,
                               const ReserveQuotaCallback& callback) = 0;
 
     // Reclaims |size| of quota for |origin| and |type|.
-    virtual void ReleaseReservedQuota(const GURL& origin,
+    virtual void ReleaseReservedQuota(const url::Origin& origin,
                                       FileSystemType type,
                                       int64_t size) = 0;
 
     // Updates disk usage of |origin| and |type|.
     // Invokes |callback| upon completion with an error code.
-    virtual void CommitQuotaUsage(const GURL& origin,
+    virtual void CommitQuotaUsage(const url::Origin& origin,
                                   FileSystemType type,
                                   int64_t delta) = 0;
 
-    virtual void IncrementDirtyCount(const GURL& origin,
-                                    FileSystemType type) = 0;
-    virtual void DecrementDirtyCount(const GURL& origin,
-                                    FileSystemType type) = 0;
+    virtual void IncrementDirtyCount(const url::Origin& origin,
+                                     FileSystemType type) = 0;
+    virtual void DecrementDirtyCount(const url::Origin& origin,
+                                     FileSystemType type) = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(QuotaBackend);
@@ -78,34 +81,35 @@ class STORAGE_EXPORT QuotaReservationManager {
 
   // The entry point of the quota reservation.  Creates new reservation object
   // for |origin| and |type|.
-  scoped_refptr<QuotaReservation> CreateReservation(
-      const GURL& origin,
-      FileSystemType type);
+  scoped_refptr<QuotaReservation> CreateReservation(const url::Origin& origin,
+                                                    FileSystemType type);
 
  private:
   using ReservationBufferByOriginAndType =
-      std::map<std::pair<GURL, FileSystemType>, QuotaReservationBuffer*>;
+      std::map<std::pair<url::Origin, FileSystemType>, QuotaReservationBuffer*>;
 
   friend class QuotaReservation;
   friend class QuotaReservationBuffer;
   friend class content::QuotaReservationManagerTest;
 
-  void ReserveQuota(const GURL& origin,
+  void ReserveQuota(const url::Origin& origin,
                     FileSystemType type,
                     int64_t delta,
                     const ReserveQuotaCallback& callback);
 
-  void ReleaseReservedQuota(const GURL& origin,
+  void ReleaseReservedQuota(const url::Origin& origin,
                             FileSystemType type,
                             int64_t size);
 
-  void CommitQuotaUsage(const GURL& origin, FileSystemType type, int64_t delta);
+  void CommitQuotaUsage(const url::Origin& origin,
+                        FileSystemType type,
+                        int64_t delta);
 
-  void IncrementDirtyCount(const GURL& origin, FileSystemType type);
-  void DecrementDirtyCount(const GURL& origin, FileSystemType type);
+  void IncrementDirtyCount(const url::Origin& origin, FileSystemType type);
+  void DecrementDirtyCount(const url::Origin& origin, FileSystemType type);
 
   scoped_refptr<QuotaReservationBuffer> GetReservationBuffer(
-      const GURL& origin,
+      const url::Origin& origin,
       FileSystemType type);
   void ReleaseReservationBuffer(QuotaReservationBuffer* reservation_pool);
 

storage/browser/fileapi/quota/quota_reservation_manager_unittest.cc

@@ -22,6 +22,8 @@
 #include "storage/browser/fileapi/quota/quota_reservation.h"
 #include "storage/browser/fileapi/quota/quota_reservation_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+#include "url/origin.h"
 
 using storage::kFileSystemTypeTemporary;
 using storage::OpenFileHandle;
@@ -32,7 +34,7 @@ namespace content {
 
 namespace {
 
-const char kOrigin[] = "http://example.com";
+const url::Origin kOrigin(url::Origin::Create(GURL("http://example.com")));
 const storage::FileSystemType kType = kFileSystemTypeTemporary;
 const int64_t kInitialFileSize = 1;
 
@@ -56,11 +58,11 @@ class FakeBackend : public QuotaReservationManager::QuotaBackend {
       : on_memory_usage_(kInitialFileSize), on_disk_usage_(kInitialFileSize) {}
   ~FakeBackend() override = default;
 
-  void ReserveQuota(const GURL& origin,
+  void ReserveQuota(const url::Origin& origin,
                     storage::FileSystemType type,
                     int64_t delta,
                     const ReserveQuotaCallback& callback) override {
-    EXPECT_EQ(GURL(kOrigin), origin);
+    EXPECT_EQ(kOrigin, origin);
     EXPECT_EQ(kType, type);
     on_memory_usage_ += delta;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ -68,27 +70,27 @@ class FakeBackend : public QuotaReservationManager::QuotaBackend {
                                   base::File::FILE_OK, delta));
   }
 
-  void ReleaseReservedQuota(const GURL& origin,
+  void ReleaseReservedQuota(const url::Origin& origin,
                             storage::FileSystemType type,
                             int64_t size) override {
     EXPECT_LE(0, size);
-    EXPECT_EQ(GURL(kOrigin), origin);
+    EXPECT_EQ(kOrigin, origin);
     EXPECT_EQ(kType, type);
     on_memory_usage_ -= size;
   }
 
-  void CommitQuotaUsage(const GURL& origin,
+  void CommitQuotaUsage(const url::Origin& origin,
                         storage::FileSystemType type,
                         int64_t delta) override {
-    EXPECT_EQ(GURL(kOrigin), origin);
+    EXPECT_EQ(kOrigin, origin);
     EXPECT_EQ(kType, type);
     on_disk_usage_ += delta;
     on_memory_usage_ += delta;
   }
 
-  void IncrementDirtyCount(const GURL& origin,
+  void IncrementDirtyCount(const url::Origin& origin,
                            storage::FileSystemType type) override {}
-  void DecrementDirtyCount(const GURL& origin,
+  void DecrementDirtyCount(const url::Origin& origin,
                            storage::FileSystemType type) override {}
 
   int64_t on_memory_usage() { return on_memory_usage_; }
@@ -219,7 +221,7 @@ class QuotaReservationManagerTest : public testing::Test {
 
 TEST_F(QuotaReservationManagerTest, BasicTest) {
   scoped_refptr<QuotaReservation> reservation =
-      reservation_manager()->CreateReservation(GURL(kOrigin), kType);
+      reservation_manager()->CreateReservation(kOrigin, kType);
 
   {
     RefreshReservation(reservation.get(), 10 + 20 + 3);
@@ -260,7 +262,7 @@ TEST_F(QuotaReservationManagerTest, BasicTest) {
 
 TEST_F(QuotaReservationManagerTest, MultipleWriter) {
   scoped_refptr<QuotaReservation> reservation =
-      reservation_manager()->CreateReservation(GURL(kOrigin), kType);
+      reservation_manager()->CreateReservation(kOrigin, kType);
 
   {
     RefreshReservation(reservation.get(), 10 + 20 + 30 + 40 + 5);
@@ -294,12 +296,12 @@ TEST_F(QuotaReservationManagerTest, MultipleWriter) {
 
 TEST_F(QuotaReservationManagerTest, MultipleClient) {
   scoped_refptr<QuotaReservation> reservation1 =
-      reservation_manager()->CreateReservation(GURL(kOrigin), kType);
+      reservation_manager()->CreateReservation(kOrigin, kType);
   RefreshReservation(reservation1.get(), 10);
   int64_t cached_reserved_quota1 = reservation1->remaining_quota();
 
   scoped_refptr<QuotaReservation> reservation2 =
-      reservation_manager()->CreateReservation(GURL(kOrigin), kType);
+      reservation_manager()->CreateReservation(kOrigin, kType);
   RefreshReservation(reservation2.get(), 20);
   int64_t cached_reserved_quota2 = reservation2->remaining_quota();
 
@@ -340,11 +342,11 @@ TEST_F(QuotaReservationManagerTest, MultipleClient) {
 
 TEST_F(QuotaReservationManagerTest, ClientCrash) {
   scoped_refptr<QuotaReservation> reservation1 =
-      reservation_manager()->CreateReservation(GURL(kOrigin), kType);
+      reservation_manager()->CreateReservation(kOrigin, kType);
   RefreshReservation(reservation1.get(), 15);
 
   scoped_refptr<QuotaReservation> reservation2 =
-      reservation_manager()->CreateReservation(GURL(kOrigin), kType);
+      reservation_manager()->CreateReservation(kOrigin, kType);
   RefreshReservation(reservation2.get(), 20);
 
   {

storage/browser/fileapi/sandbox_file_system_backend_delegate.cc

@@ -443,7 +443,8 @@ SandboxFileSystemBackendDelegate::CreateQuotaReservationOnFileTaskRunner(
     FileSystemType type) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(quota_reservation_manager_);
-  return quota_reservation_manager_->CreateReservation(origin, type);
+  return quota_reservation_manager_->CreateReservation(
+      url::Origin::Create(origin), type);
 }
 
 void SandboxFileSystemBackendDelegate::AddFileUpdateObserver(