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

content/browser/indexed_db/indexed_db_backing_store.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 <algorithm>
 #include <utility>
 
 #include "base/files/file_path.h"
@@ skipping 35 matching lines @@
 #include "storage/common/database/database_identifier.h"
 #include "storage/common/fileapi/file_system_mount_option.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBTypes.h"
 #include "third_party/WebKit/public/web/WebSerializedScriptValueVersion.h"
 #include "third_party/leveldatabase/env_chromium.h"
 
 using base::FilePath;
 using base::StringPiece;
 using std::string;
 using storage::FileWriterDelegate;
+using url::Origin;
 
 namespace content {
 
 namespace {
 
 FilePath GetBlobDirectoryName(const FilePath& path_base, int64_t database_id) {
   return path_base.AppendASCII(base::StringPrintf("%" PRIx64, database_id));
 }
 
 FilePath GetBlobDirectoryNameForKey(const FilePath& path_base,
@@ skipping 13 matching lines @@
   return path;
 }
 
 bool MakeIDBBlobDirectory(const FilePath& path_base,
                           int64_t database_id,
                           int64_t key) {
   FilePath path = GetBlobDirectoryNameForKey(path_base, database_id, key);
   return base::CreateDirectory(path);
 }
 
-static std::string ComputeOriginIdentifier(const GURL& origin_url) {
-  return storage::GetIdentifierFromOrigin(origin_url) + "@1";
+static std::string ComputeOriginIdentifier(const Origin& origin) {
+  return storage::GetIdentifierFromOrigin(GURL(origin.Serialize())) + "@1";
 }
 
-static FilePath ComputeCorruptionFileName(const GURL& origin_url) {
-  return IndexedDBContextImpl::GetLevelDBFileName(origin_url)
-      .Append(FILE_PATH_LITERAL("corruption_info.json"));
+static FilePath ComputeCorruptionFileName(const Origin& origin) {
+  return IndexedDBContextImpl::GetLevelDBFileName(origin).Append(
+      FILE_PATH_LITERAL("corruption_info.json"));
 }
 
 }  // namespace
 
 static const int64_t kKeyGeneratorInitialNumber =
     1;  // From the IndexedDB specification.
 
 enum IndexedDBBackingStoreErrorSource {
   // 0 - 2 are no longer used.
   FIND_KEY_IN_INDEX = 3,
@@ skipping 632 matching lines @@
       ret.push_back(IndexedDBBlobInfo(type, static_cast<uint64_t>(size), key));
     }
   }
   output->swap(ret);
 
   return true;
 }
 
 IndexedDBBackingStore::IndexedDBBackingStore(
     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)
     : indexed_db_factory_(indexed_db_factory),
-      origin_url_(origin_url),
+      origin_(origin),
       blob_path_(blob_path),
-      origin_identifier_(ComputeOriginIdentifier(origin_url)),
+      origin_identifier_(ComputeOriginIdentifier(origin)),
       request_context_(request_context),
       task_runner_(task_runner),
       db_(std::move(db)),
       comparator_(std::move(comparator)),
       active_blob_registry_(this),
       committing_transaction_count_(0) {}
 
 IndexedDBBackingStore::~IndexedDBBackingStore() {
   if (!blob_path_.empty() && !child_process_ids_granted_.empty()) {
     ChildProcessSecurityPolicyImpl* policy =
@@ skipping 40 matching lines @@
   INDEXED_DB_BACKING_STORE_OPEN_ORIGIN_TOO_LONG,
   INDEXED_DB_BACKING_STORE_OPEN_NO_RECOVERY,
   INDEXED_DB_BACKING_STORE_OPEN_FAILED_PRIOR_CORRUPTION,
   INDEXED_DB_BACKING_STORE_OPEN_FAILED_CLEANUP_JOURNAL_ERROR,
   INDEXED_DB_BACKING_STORE_OPEN_MAX,
 };
 
 // static
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::Open(
     IndexedDBFactory* indexed_db_factory,
-    const GURL& origin_url,
+    const Origin& origin,
     const base::FilePath& path_base,
     net::URLRequestContext* request_context,
     blink::WebIDBDataLoss* data_loss,
     std::string* data_loss_message,
     bool* disk_full,
     base::SequencedTaskRunner* task_runner,
     bool clean_journal,
     leveldb::Status* status) {
   *data_loss = blink::WebIDBDataLossNone;
   DefaultLevelDBFactory leveldb_factory;
-  return IndexedDBBackingStore::Open(indexed_db_factory,
-                                     origin_url,
-                                     path_base,
-                                     request_context,
-                                     data_loss,
-                                     data_loss_message,
-                                     disk_full,
-                                     &leveldb_factory,
-                                     task_runner,
-                                     clean_journal,
-                                     status);
+  return IndexedDBBackingStore::Open(
+      indexed_db_factory, origin, path_base, request_context, data_loss,
+      data_loss_message, disk_full, &leveldb_factory, task_runner,
+      clean_journal, status);
 }
 
-static std::string OriginToCustomHistogramSuffix(const GURL& origin_url) {
-  if (origin_url.host() == "docs.google.com")
+static std::string OriginToCustomHistogramSuffix(const Origin& origin) {
+  if (origin.host() == "docs.google.com")
     return ".Docs";
   return std::string();
 }
 
 static void HistogramOpenStatus(IndexedDBBackingStoreOpenResult result,
-                                const GURL& origin_url) {
+                                const Origin& origin) {
   UMA_HISTOGRAM_ENUMERATION("WebCore.IndexedDB.BackingStore.OpenStatus",
                             result,
                             INDEXED_DB_BACKING_STORE_OPEN_MAX);
-  const std::string suffix = OriginToCustomHistogramSuffix(origin_url);
+  const std::string suffix = OriginToCustomHistogramSuffix(origin);
   // Data from the WebCore.IndexedDB.BackingStore.OpenStatus histogram is used
   // to generate a graph. So as not to alter the meaning of that graph,
   // continue to collect all stats there (above) but also now collect docs stats
   // separately (below).
   if (!suffix.empty()) {
     base::LinearHistogram::FactoryGet(
         "WebCore.IndexedDB.BackingStore.OpenStatus" + suffix,
         1,
         INDEXED_DB_BACKING_STORE_OPEN_MAX,
         INDEXED_DB_BACKING_STORE_OPEN_MAX + 1,
@@ skipping 26 matching lines @@
         min,
         max,
         num_buckets);
     return true;
   }
   return false;
 }
 
 leveldb::Status IndexedDBBackingStore::DestroyBackingStore(
     const base::FilePath& path_base,
-    const GURL& origin_url) {
+    const Origin& origin) {
   const base::FilePath file_path =
-      path_base.Append(IndexedDBContextImpl::GetLevelDBFileName(origin_url));
+      path_base.Append(IndexedDBContextImpl::GetLevelDBFileName(origin));
   DefaultLevelDBFactory leveldb_factory;
   return leveldb_factory.DestroyLevelDB(file_path);
 }
 
 bool IndexedDBBackingStore::ReadCorruptionInfo(const base::FilePath& path_base,
-                                               const GURL& origin_url,
+                                               const Origin& origin,
                                                std::string* message) {
   const base::FilePath info_path =
-      path_base.Append(ComputeCorruptionFileName(origin_url));
+      path_base.Append(ComputeCorruptionFileName(origin));
 
   if (IsPathTooLong(info_path))
     return false;
 
   const int64_t max_json_len = 4096;
   int64_t file_size(0);
   if (!GetFileSize(info_path, &file_size) || file_size > max_json_len)
     return false;
   if (!file_size) {
     NOTREACHED();
@@ skipping 17 matching lines @@
     file.Close();
   }
 
   base::DeleteFile(info_path, false);
 
   return success;
 }
 
 bool IndexedDBBackingStore::RecordCorruptionInfo(
     const base::FilePath& path_base,
-    const GURL& origin_url,
+    const Origin& origin,
     const std::string& message) {
   const base::FilePath info_path =
-      path_base.Append(ComputeCorruptionFileName(origin_url));
+      path_base.Append(ComputeCorruptionFileName(origin));
   if (IsPathTooLong(info_path))
     return false;
 
   base::DictionaryValue root_dict;
   root_dict.SetString("message", message);
   std::string output_js;
   base::JSONWriter::Write(root_dict, &output_js);
 
   base::File file(info_path,
                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
   if (!file.IsValid())
     return false;
   int written = file.Write(0, output_js.c_str(), output_js.length());
   return size_t(written) == output_js.length();
 }
 
 // static
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::Open(
     IndexedDBFactory* indexed_db_factory,
-    const GURL& origin_url,
+    const Origin& origin,
     const base::FilePath& path_base,
     net::URLRequestContext* request_context,
     blink::WebIDBDataLoss* data_loss,
     std::string* data_loss_message,
     bool* is_disk_full,
     LevelDBFactory* leveldb_factory,
     base::SequencedTaskRunner* task_runner,
     bool clean_journal,
     leveldb::Status* status) {
   IDB_TRACE("IndexedDBBackingStore::Open");
   DCHECK(!path_base.empty());
   *data_loss = blink::WebIDBDataLossNone;
   *data_loss_message = "";
   *is_disk_full = false;
 
   *status = leveldb::Status::OK();
 
   std::unique_ptr<LevelDBComparator> comparator(new Comparator());
 
   if (!base::IsStringASCII(path_base.AsUTF8Unsafe())) {
     HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_ATTEMPT_NON_ASCII,
-                        origin_url);
+                        origin);
   }
   if (!base::CreateDirectory(path_base)) {
     *status =
         leveldb::Status::IOError("Unable to create IndexedDB database path");
     LOG(ERROR) << status->ToString() << ": \"" << path_base.AsUTF8Unsafe()
                << "\"";
-    HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_FAILED_DIRECTORY,
-                        origin_url);
+    HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_FAILED_DIRECTORY, origin);
     return scoped_refptr<IndexedDBBackingStore>();
   }
 
   const FilePath file_path =
-      path_base.Append(IndexedDBContextImpl::GetLevelDBFileName(origin_url));
+      path_base.Append(IndexedDBContextImpl::GetLevelDBFileName(origin));
   const FilePath blob_path =
-      path_base.Append(IndexedDBContextImpl::GetBlobStoreFileName(origin_url));
+      path_base.Append(IndexedDBContextImpl::GetBlobStoreFileName(origin));
 
   if (IsPathTooLong(file_path)) {
     *status = leveldb::Status::IOError("File path too long");
-    HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_ORIGIN_TOO_LONG,
-                        origin_url);
+    HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_ORIGIN_TOO_LONG, origin);
     return scoped_refptr<IndexedDBBackingStore>();
   }
 
   std::unique_ptr<LevelDBDatabase> db;
   *status = leveldb_factory->OpenLevelDB(
       file_path, comparator.get(), &db, is_disk_full);
 
   DCHECK(!db == !status->ok());
   if (!status->ok()) {
     if (leveldb_env::IndicatesDiskFull(*status)) {
       *is_disk_full = true;
     } else if (status->IsCorruption()) {
       *data_loss = blink::WebIDBDataLossTotal;
       *data_loss_message = leveldb_env::GetCorruptionMessage(*status);
     }
   }
 
   bool is_schema_known = false;
   if (db) {
     std::string corruption_message;
-    if (ReadCorruptionInfo(path_base, origin_url, &corruption_message)) {
+    if (ReadCorruptionInfo(path_base, origin, &corruption_message)) {
       LOG(ERROR) << "IndexedDB recovering from a corrupted (and deleted) "
                     "database.";
       HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_FAILED_PRIOR_CORRUPTION,
-                          origin_url);
+                          origin);
       db.reset();
       *data_loss = blink::WebIDBDataLossTotal;
       *data_loss_message =
           "IndexedDB (database was corrupt): " + corruption_message;
     } else if (!IsSchemaKnown(db.get(), &is_schema_known)) {
       LOG(ERROR) << "IndexedDB had IO error checking schema, treating it as "
                     "failure to open";
       HistogramOpenStatus(
           INDEXED_DB_BACKING_STORE_OPEN_FAILED_IO_ERROR_CHECKING_SCHEMA,
-          origin_url);
+          origin);
       db.reset();
       *data_loss = blink::WebIDBDataLossTotal;
       *data_loss_message = "I/O error checking schema";
     } else if (!is_schema_known) {
       LOG(ERROR) << "IndexedDB backing store had unknown schema, treating it "
                     "as failure to open";
       HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_FAILED_UNKNOWN_SCHEMA,
-                          origin_url);
+                          origin);
       db.reset();
       *data_loss = blink::WebIDBDataLossTotal;
       *data_loss_message = "Unknown schema";
     }
   }
 
   DCHECK(status->ok() || !is_schema_known || status->IsIOError() ||
          status->IsCorruption());
 
   if (db) {
-    HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_SUCCESS, origin_url);
+    HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_SUCCESS, origin);
   } else if (status->IsIOError()) {
     LOG(ERROR) << "Unable to open backing store, not trying to recover - "
                << status->ToString();
-    HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_NO_RECOVERY, origin_url);
+    HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_NO_RECOVERY, origin);
     return scoped_refptr<IndexedDBBackingStore>();
   } else {
     DCHECK(!is_schema_known || status->IsCorruption());
     LOG(ERROR) << "IndexedDB backing store open failed, attempting cleanup";
     *status = leveldb_factory->DestroyLevelDB(file_path);
     if (!status->ok()) {
       LOG(ERROR) << "IndexedDB backing store cleanup failed";
       HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_CLEANUP_DESTROY_FAILED,
-                          origin_url);
+                          origin);
       return scoped_refptr<IndexedDBBackingStore>();
     }
 
     LOG(ERROR) << "IndexedDB backing store cleanup succeeded, reopening";
     *status =
         leveldb_factory->OpenLevelDB(file_path, comparator.get(), &db, NULL);
     if (!status->ok()) {
       DCHECK(!db);
       LOG(ERROR) << "IndexedDB backing store reopen after recovery failed";
       HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_CLEANUP_REOPEN_FAILED,
-                          origin_url);
+                          origin);
       return scoped_refptr<IndexedDBBackingStore>();
     }
     HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_CLEANUP_REOPEN_SUCCESS,
-                        origin_url);
+                        origin);
   }
 
   base::trace_event::MemoryDumpManager::GetInstance()
       ->RegisterDumpProviderWithSequencedTaskRunner(
           db.get(), "IndexedDBBackingStore", task_runner,
           base::trace_event::MemoryDumpProvider::Options());
 
   scoped_refptr<IndexedDBBackingStore> backing_store =
-      Create(indexed_db_factory, origin_url, blob_path, request_context,
+      Create(indexed_db_factory, origin, blob_path, request_context,
              std::move(db), std::move(comparator), task_runner, status);
 
   if (clean_journal && backing_store.get()) {
     *status = backing_store->CleanUpBlobJournal(LiveBlobJournalKey::Encode());
     if (!status->ok()) {
       HistogramOpenStatus(
-          INDEXED_DB_BACKING_STORE_OPEN_FAILED_CLEANUP_JOURNAL_ERROR,
-          origin_url);
+          INDEXED_DB_BACKING_STORE_OPEN_FAILED_CLEANUP_JOURNAL_ERROR, origin);
       return scoped_refptr<IndexedDBBackingStore>();
     }
   }
   return backing_store;
 }
 
 // static
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::OpenInMemory(
-    const GURL& origin_url,
+    const Origin& origin,
     base::SequencedTaskRunner* task_runner,
     leveldb::Status* status) {
   DefaultLevelDBFactory leveldb_factory;
-  return IndexedDBBackingStore::OpenInMemory(
-      origin_url, &leveldb_factory, task_runner, status);
+  return IndexedDBBackingStore::OpenInMemory(origin, &leveldb_factory,
+                                             task_runner, status);
 }
 
 // static
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::OpenInMemory(
-    const GURL& origin_url,
+    const Origin& origin,
     LevelDBFactory* leveldb_factory,
     base::SequencedTaskRunner* task_runner,
     leveldb::Status* status) {
   IDB_TRACE("IndexedDBBackingStore::OpenInMemory");
 
   std::unique_ptr<LevelDBComparator> comparator(new Comparator());
   std::unique_ptr<LevelDBDatabase> db =
       LevelDBDatabase::OpenInMemory(comparator.get());
   if (!db) {
     LOG(ERROR) << "LevelDBDatabase::OpenInMemory failed.";
-    HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_MEMORY_FAILED,
-                        origin_url);
+    HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_MEMORY_FAILED, origin);
     return scoped_refptr<IndexedDBBackingStore>();
   }
-  HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_MEMORY_SUCCESS, origin_url);
+  HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_MEMORY_SUCCESS, origin);
   base::trace_event::MemoryDumpManager::GetInstance()
       ->RegisterDumpProviderWithSequencedTaskRunner(
           db.get(), "IndexedDBBackingStore", task_runner,
           base::trace_event::MemoryDumpProvider::Options());
 
-  return Create(NULL /* indexed_db_factory */, origin_url, base::FilePath(),
+  return Create(NULL /* indexed_db_factory */, origin, base::FilePath(),
                 NULL /* request_context */, std::move(db),
                 std::move(comparator), task_runner, status);
 }
 
 // static
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::Create(
     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,
     leveldb::Status* status) {
   // TODO(jsbell): Handle comparator name changes.
   scoped_refptr<IndexedDBBackingStore> backing_store(new IndexedDBBackingStore(
-      indexed_db_factory, origin_url, blob_path, request_context, std::move(db),
+      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<IndexedDBBackingStore>();
 
   return backing_store;
 }
 
 void IndexedDBBackingStore::GrantChildProcessPermissions(int child_process_id) {
   if (!child_process_ids_granted_.count(child_process_id)) {
@@ skipping 3292 matching lines @@
 
 IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
     const WriteDescriptor& other) = default;
 IndexedDBBackingStore::Transaction::WriteDescriptor::~WriteDescriptor() =
     default;
 IndexedDBBackingStore::Transaction::WriteDescriptor&
     IndexedDBBackingStore::Transaction::WriteDescriptor::
     operator=(const WriteDescriptor& other) = default;
 
 }  // namespace content