IndexedDB: Use url::Origin rather than GURL for representing origins

content/browser/indexed_db/indexed_db_backing_store_unittest.cc

 // Copyright (c) 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/indexed_db/indexed_db_backing_store.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 14 matching lines @@
 #include "content/browser/quota/mock_quota_manager_proxy.h"
 #include "content/public/test/mock_special_storage_policy.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/url_request/url_request_test_util.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/quota/special_storage_policy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBTypes.h"
 
 using base::ASCIIToUTF16;
+using url::Origin;
 
 namespace content {
 
 namespace {
 
 class Comparator : public LevelDBComparator {
  public:
   int Compare(const base::StringPiece& a,
               const base::StringPiece& b) const override {
     return content::Compare(a, b, false /*index_keys*/);
@@ skipping 15 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultLevelDBFactory);
 };
 
 class TestableIndexedDBBackingStore : public IndexedDBBackingStore {
  public:
   static scoped_refptr<TestableIndexedDBBackingStore> Open(
       IndexedDBFactory* indexed_db_factory,
-      const GURL& origin_url,
+      const Origin& origin,
       const base::FilePath& path_base,
       net::URLRequestContext* request_context,
       LevelDBFactory* leveldb_factory,
       base::SequencedTaskRunner* task_runner,
       leveldb::Status* status) {
     DCHECK(!path_base.empty());
 
     std::unique_ptr<LevelDBComparator> comparator(new Comparator());
 
     if (!base::CreateDirectory(path_base)) {
       *status = leveldb::Status::IOError("Unable to create base dir");
       return scoped_refptr<TestableIndexedDBBackingStore>();
     }
 
     const base::FilePath file_path = path_base.AppendASCII("test_db_path");
     const base::FilePath blob_path = path_base.AppendASCII("test_blob_path");
 
     std::unique_ptr<LevelDBDatabase> db;
     bool is_disk_full = false;
     *status = leveldb_factory->OpenLevelDB(
         file_path, comparator.get(), &db, &is_disk_full);
 
     if (!db || !status->ok())
       return scoped_refptr<TestableIndexedDBBackingStore>();
 
     scoped_refptr<TestableIndexedDBBackingStore> backing_store(
-        new TestableIndexedDBBackingStore(
-            indexed_db_factory, origin_url, blob_path, request_context,
-            std::move(db), std::move(comparator), task_runner));
+        new TestableIndexedDBBackingStore(indexed_db_factory, origin, blob_path,
+                                          request_context, std::move(db),
+                                          std::move(comparator), task_runner));
 
     *status = backing_store->SetUpMetadata();
     if (!status->ok())
       return scoped_refptr<TestableIndexedDBBackingStore>();
 
     return backing_store;
   }
 
   const std::vector<IndexedDBBackingStore::Transaction::WriteDescriptor>&
   writes() const {
@@ skipping 36 matching lines @@
     return true;
   }
 
   // Timers don't play nicely with unit tests.
   void StartJournalCleaningTimer() override {
     CleanPrimaryJournalIgnoreReturn();
   }
 
  private:
   TestableIndexedDBBackingStore(IndexedDBFactory* indexed_db_factory,
-                                const GURL& origin_url,
+                                const Origin& origin,
                                 const base::FilePath& blob_path,
                                 net::URLRequestContext* request_context,
                                 std::unique_ptr<LevelDBDatabase> db,
                                 std::unique_ptr<LevelDBComparator> comparator,
                                 base::SequencedTaskRunner* task_runner)
       : IndexedDBBackingStore(indexed_db_factory,
-                              origin_url,
+                              origin,
                               blob_path,
                               request_context,
                               std::move(db),
                               std::move(comparator),
                               task_runner),
         database_id_(0) {}
 
   int64_t database_id_;
   std::vector<Transaction::WriteDescriptor> writes_;
 
   // This is modified in an overridden virtual function that is properly const
   // in the real implementation, therefore must be mutable here.
   mutable std::vector<int64_t> removals_;
 
   DISALLOW_COPY_AND_ASSIGN(TestableIndexedDBBackingStore);
 };
 
 class TestIDBFactory : public IndexedDBFactoryImpl {
  public:
   explicit TestIDBFactory(IndexedDBContextImpl* idb_context)
       : IndexedDBFactoryImpl(idb_context) {}
 
   scoped_refptr<TestableIndexedDBBackingStore> OpenBackingStoreForTest(
-      const GURL& origin,
+      const Origin& origin,
       net::URLRequestContext* url_request_context) {
     blink::WebIDBDataLoss data_loss;
     std::string data_loss_reason;
     bool disk_full;
     leveldb::Status status;
     scoped_refptr<IndexedDBBackingStore> backing_store =
         OpenBackingStore(origin,
                          context()->data_path(),
                          url_request_context,
                          &data_loss,
                          &data_loss_reason,
                          &disk_full,
                          &status);
     scoped_refptr<TestableIndexedDBBackingStore> testable_store =
         static_cast<TestableIndexedDBBackingStore*>(backing_store.get());
     return testable_store;
   }
 
  protected:
   ~TestIDBFactory() override {}
 
   scoped_refptr<IndexedDBBackingStore> OpenBackingStoreHelper(
-      const GURL& origin_url,
+      const Origin& origin,
       const base::FilePath& data_directory,
       net::URLRequestContext* request_context,
       blink::WebIDBDataLoss* data_loss,
       std::string* data_loss_message,
       bool* disk_full,
       bool first_time,
       leveldb::Status* status) override {
     DefaultLevelDBFactory leveldb_factory;
-    return TestableIndexedDBBackingStore::Open(this,
-                                               origin_url,
-                                               data_directory,
-                                               request_context,
-                                               &leveldb_factory,
-                                               context()->TaskRunner(),
-                                               status);
+    return TestableIndexedDBBackingStore::Open(
+        this, origin, data_directory, request_context, &leveldb_factory,
+        context()->TaskRunner(), status);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestIDBFactory);
 };
 
 class IndexedDBBackingStoreTest : public testing::Test {
  public:
   IndexedDBBackingStoreTest() {}
   void SetUp() override {
-    const GURL origin("http://localhost:81");
+    const Origin origin(GURL("http://localhost:81"));
     task_runner_ = new base::TestSimpleTaskRunner();
     special_storage_policy_ = new MockSpecialStoragePolicy();
     quota_manager_proxy_ = new MockQuotaManagerProxy(nullptr, nullptr);
     special_storage_policy_->SetAllUnlimited(true);
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     idb_context_ = new IndexedDBContextImpl(
         temp_dir_.path(), special_storage_policy_.get(),
         quota_manager_proxy_.get(), task_runner_.get());
     idb_factory_ = new TestIDBFactory(idb_context_.get());
     backing_store_ =
@@ skipping 797 matching lines @@
 
   std::vector<base::string16> names = backing_store_->GetDatabaseNames(&s);
   EXPECT_TRUE(s.ok());
   EXPECT_EQ(names.size(), 1ULL);
   EXPECT_EQ(names[0], db1_name);
 }
 
 }  // namespace
 
 }  // namespace content