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

content/browser/indexed_db/indexed_db_database.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_database.h"
 
 #include <math.h>
 
 #include <limits>
 #include <memory>
@@ skipping 20 matching lines @@
 #include "content/browser/indexed_db/indexed_db_return_value.h"
 #include "content/browser/indexed_db/indexed_db_tracing.h"
 #include "content/browser/indexed_db/indexed_db_transaction.h"
 #include "content/browser/indexed_db/indexed_db_value.h"
 #include "content/common/indexed_db/indexed_db_constants.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 #include "content/common/indexed_db/indexed_db_key_range.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseException.h"
 #include "third_party/leveldatabase/env_chromium.h"
+#include "url/origin.h"
 
 using base::ASCIIToUTF16;
 using base::Int64ToString16;
 using blink::WebIDBKeyTypeNumber;
 
 namespace content {
 
 namespace {
 
 // Used for WebCore.IndexedDB.Schema.ObjectStore.KeyPathType and
@@ skipping 289 matching lines @@
                                         object_store_metadata.name,
                                         object_store_metadata.key_path,
                                         object_store_metadata.auto_increment);
   if (!s.ok()) {
     IndexedDBDatabaseError error(
         blink::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16("Internal error creating object store '") +
             object_store_metadata.name + ASCIIToUTF16("'."));
     transaction->Abort(error);
     if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                             error);
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     return;
   }
 
   AddObjectStore(object_store_metadata, object_store_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::CreateObjectStoreAbortOperation,
                  this,
                  object_store_id));
 }
 
@@ skipping 109 matching lines @@
                                   object_store_id,
                                   index_id);
   if (!s.ok()) {
     base::string16 error_string =
         ASCIIToUTF16("Internal error deleting index '") +
         index_metadata.name + ASCIIToUTF16("'.");
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  error_string);
     transaction->Abort(error);
     if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                             error);
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     return;
   }
 
   RemoveIndex(object_store_id, index_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::DeleteIndexAbortOperation,
                  this,
                  object_store_id,
                  index_metadata));
 }
@@ skipping 137 matching lines @@
           *key_range,
           blink::WebIDBCursorDirectionNext,
           &s);
     }
 
     if (!s.ok()) {
       DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error deleting data in range");
       if (s.IsCorruption()) {
-        factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                               error);
+        factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
       }
     }
 
     if (!backing_store_cursor) {
       callbacks->OnSuccess();
       return;
     }
 
     key = &backing_store_cursor->key();
   }
 
   std::unique_ptr<IndexedDBKey> primary_key;
   if (index_id == IndexedDBIndexMetadata::kInvalidId) {
     // Object Store Retrieval Operation
     IndexedDBReturnValue value;
     s = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                   id(),
                                   object_store_id,
                                   *key,
                                   &value);
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error in GetRecord.");
       callbacks->OnError(error);
 
       if (s.IsCorruption())
-        factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                               error);
+        factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
       return;
     }
 
     if (value.empty()) {
       callbacks->OnSuccess();
       return;
     }
 
     if (object_store_metadata.auto_increment &&
         !object_store_metadata.key_path.IsNull()) {
@@ skipping 11 matching lines @@
       id(),
       object_store_id,
       index_id,
       *key,
       &primary_key);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetPrimaryKeyViaIndex.");
     callbacks->OnError(error);
     if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                             error);
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     return;
   }
   if (!primary_key) {
     callbacks->OnSuccess();
     return;
   }
   if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
     // Index Value Retrieval Operation
     callbacks->OnSuccess(*primary_key);
     return;
   }
 
   // Index Referenced Value Retrieval Operation
   IndexedDBReturnValue value;
   s = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                 id(),
                                 object_store_id,
                                 *primary_key,
                                 &value);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetRecord.");
     callbacks->OnError(error);
     if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                             error);
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     return;
   }
 
   if (value.empty()) {
     callbacks->OnSuccess();
     return;
   }
   if (object_store_metadata.auto_increment &&
       !object_store_metadata.key_path.IsNull()) {
     value.primary_key = *primary_key;
@@ skipping 50 matching lines @@
           index_id, *key_range, blink::WebIDBCursorDirectionNext, &s);
     }
   }
 
   if (!s.ok()) {
     DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetAllOperation");
     callbacks->OnError(error);
     if (s.IsCorruption()) {
-      factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                             error);
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
     return;
   }
 
   std::vector<IndexedDBKey> found_keys;
   std::vector<IndexedDBReturnValue> found_values;
   if (!cursor) {
     // Doesn't matter if key or value array here - will be empty array when it
     // hits JavaScript.
     callbacks->OnSuccessArray(&found_values, object_store_metadata.key_path);
@@ skipping 12 matching lines @@
       cursor_valid = cursor->Continue(&s);
     } else {
       cursor_valid = cursor->FirstSeek(&s);
       did_first_seek = true;
     }
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error in GetAllOperation.");
       callbacks->OnError(error);
       if (s.IsCorruption())
-        factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                               error);
+        factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
       return;
     }
 
     if (!cursor_valid)
       break;
 
     IndexedDBReturnValue return_value;
     IndexedDBKey return_key;
 
     if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
@@ skipping 153 matching lines @@
         id(),
         params->object_store_id,
         *key,
         &record_identifier,
         &found);
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error checking key existence.");
       params->callbacks->OnError(error);
       if (s.IsCorruption())
-        factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                               error);
+        factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
       return;
     }
     if (found) {
       params->callbacks->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionConstraintError,
                                  "Key already exists in the object store."));
       return;
     }
   }
 
@@ skipping 31 matching lines @@
                                 *key,
                                 &params->value,
                                 &params->handles,
                                 &record_identifier);
   if (!s.ok()) {
     IndexedDBDatabaseError error(
         blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error performing put/add.");
     params->callbacks->OnError(error);
     if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                             error);
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     return;
   }
   {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.UpdateIndexes", "txn.id",
                transaction->id());
     for (size_t i = 0; i < index_writers.size(); ++i) {
       IndexWriter* index_writer = index_writers[i];
       index_writer->WriteIndexKeys(record_identifier, backing_store_.get(),
                                    transaction->BackingStoreTransaction(), id(),
                                    params->object_store_id);
     }
   }
 
   if (object_store.auto_increment &&
       params->put_mode != blink::WebIDBPutModeCursorUpdate &&
       key->type() == WebIDBKeyTypeNumber) {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.AutoIncrement", "txn.id",
                transaction->id());
     leveldb::Status s = UpdateKeyGenerator(backing_store_.get(),
                                            transaction,
                                            id(),
                                            params->object_store_id,
                                            *key,
                                            !key_was_generated);
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error updating key generator.");
       params->callbacks->OnError(error);
       if (s.IsCorruption())
-        factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                               error);
+        factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
       return;
     }
   }
   {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.Callbacks", "txn.id",
                transaction->id());
     params->callbacks->OnSuccess(*key);
   }
 }
 
@@ skipping 16 matching lines @@
       metadata_.id,
       object_store_id,
       *primary_key,
       &record_identifier,
       &found);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error setting index keys.");
     transaction->Abort(error);
     if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                             error);
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     return;
   }
   if (!found) {
     transaction->Abort(IndexedDBDatabaseError(
         blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error setting index keys for object store."));
     return;
   }
 
   ScopedVector<IndexWriter> index_writers;
@@ skipping 157 matching lines @@
           params->direction,
           &s);
     }
   }
 
   if (!s.ok()) {
     DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error opening cursor operation");
     if (s.IsCorruption()) {
-      factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                             error);
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
   }
 
   if (!backing_store_cursor) {
     // Why is Success being called?
     params->callbacks->OnSuccess(nullptr);
     return;
   }
 
   scoped_refptr<IndexedDBCursor> cursor =
@@ skipping 51 matching lines @@
         index_id,
         *key_range,
         blink::WebIDBCursorDirectionNext,
         &s);
   }
   if (!s.ok()) {
     DLOG(ERROR) << "Unable perform count operation: " << s.ToString();
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error performing count operation");
     if (s.IsCorruption()) {
-      factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                             error);
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
   }
   if (!backing_store_cursor) {
     callbacks->OnSuccess(count);
     return;
   }
 
   do {
     ++count;
   } while (backing_store_cursor->Continue(&s));
@@ skipping 36 matching lines @@
                                   id(),
                                   object_store_id,
                                   *key_range);
   if (!s.ok()) {
     base::string16 error_string =
         ASCIIToUTF16("Internal error deleting data in range");
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  error_string);
     transaction->Abort(error);
     if (s.IsCorruption()) {
-      factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                             error);
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
     return;
   }
   callbacks->OnSuccess();
 }
 
 void IndexedDBDatabase::Clear(int64_t transaction_id,
                               int64_t object_store_id,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::Clear", "txn.id", transaction_id);
@@ skipping 14 matching lines @@
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::ClearOperation", "txn.id", transaction->id());
   leveldb::Status s = backing_store_->ClearObjectStore(
       transaction->BackingStoreTransaction(), id(), object_store_id);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error clearing object store");
     callbacks->OnError(error);
     if (s.IsCorruption()) {
-      factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                             error);
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
     return;
   }
   callbacks->OnSuccess();
 }
 
 void IndexedDBDatabase::DeleteObjectStoreOperation(
     int64_t object_store_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::DeleteObjectStoreOperation",
              "txn.id",
              transaction->id());
 
   const IndexedDBObjectStoreMetadata object_store_metadata =
       metadata_.object_stores[object_store_id];
   leveldb::Status s =
       backing_store_->DeleteObjectStore(transaction->BackingStoreTransaction(),
                                         transaction->database()->id(),
                                         object_store_id);
   if (!s.ok()) {
     base::string16 error_string =
         ASCIIToUTF16("Internal error deleting object store '") +
         object_store_metadata.name + ASCIIToUTF16("'.");
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  error_string);
     transaction->Abort(error);
     if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
-                                             error);
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     return;
   }
 
   RemoveObjectStore(object_store_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::DeleteObjectStoreAbortOperation,
                  this,
                  object_store_metadata));
 }
 
@@ skipping 58 matching lines @@
 
     // Connection queue is now unblocked.
     ProcessPendingCalls();
   }
 }
 
 void IndexedDBDatabase::TransactionCommitFailed(const leveldb::Status& status) {
   if (status.IsCorruption()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Error committing transaction");
-    factory_->HandleBackingStoreCorruption(backing_store_->origin_url(), error);
+    factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
   } else {
-    factory_->HandleBackingStoreFailure(backing_store_->origin_url());
+    factory_->HandleBackingStoreFailure(backing_store_->origin());
   }
 }
 
 size_t IndexedDBDatabase::ConnectionCount() const {
   // This does not include pending open calls, as those should not block version
   // changes and deletes.
   return connections_.size();
 }
 
 size_t IndexedDBDatabase::PendingOpenCount() const {
@@ skipping 256 matching lines @@
 void IndexedDBDatabase::DeleteDatabaseFinal(
     scoped_refptr<IndexedDBCallbacks> callbacks) {
   DCHECK(!IsDeleteDatabaseBlocked());
   DCHECK(backing_store_.get());
   leveldb::Status s = backing_store_->DeleteDatabase(metadata_.name);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error deleting database.");
     callbacks->OnError(error);
     if (s.IsCorruption()) {
-      GURL origin_url = backing_store_->origin_url();
+      url::Origin origin = backing_store_->origin();
       backing_store_ = NULL;
-      factory_->HandleBackingStoreCorruption(origin_url, error);
+      factory_->HandleBackingStoreCorruption(origin, error);
     }
     return;
   }
   int64_t old_version = metadata_.version;
   metadata_.id = kInvalidId;
   metadata_.version = IndexedDBDatabaseMetadata::NO_VERSION;
   metadata_.object_stores.clear();
   callbacks->OnSuccess(old_version);
   factory_->DatabaseDeleted(identifier_);
 }
@@ skipping 49 matching lines @@
                                "The connection was closed."));
     pending_second_half_open_.reset();
   }
 
   ProcessPendingCalls();
 
   // TODO(jsbell): Add a test for the pending_open_calls_ cases below.
   if (!ConnectionCount() && !pending_open_calls_.size() &&
       !pending_delete_calls_.size()) {
     DCHECK(transactions_.empty());
-
-    const GURL origin_url = backing_store_->origin_url();
     backing_store_ = NULL;
-
     factory_->ReleaseDatabase(identifier_, forced);
   }
 }
 
 void IndexedDBDatabase::CreateObjectStoreAbortOperation(
     int64_t object_store_id,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::CreateObjectStoreAbortOperation");
   RemoveObjectStore(object_store_id);
@@ skipping 10 matching lines @@
 
 void IndexedDBDatabase::VersionChangeAbortOperation(
     int64_t previous_version,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   metadata_.version = previous_version;
 }
 
 }  // namespace content