IndexedDB: Make IndexedDBDatabaseError non-RefCounted

BUG=234278
R=alecflett@chromium.org

Review URL: https://chromiumcodereview.appspot.com/15927032

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@204080 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/indexed_db/indexed_db_callbacks_wrapper.cc

@@ -29,11 +29,10 @@ IndexedDBCallbacksWrapper::IndexedDBCallbacksWrapper(
 
 IndexedDBCallbacksWrapper::~IndexedDBCallbacksWrapper() {}
 
-void IndexedDBCallbacksWrapper::OnError(
-    scoped_refptr<IndexedDBDatabaseError> error) {
+void IndexedDBCallbacksWrapper::OnError(const IndexedDBDatabaseError& error) {
   DCHECK(callbacks_);
   callbacks_->onError(
-      WebKit::WebIDBDatabaseError(error->code(), error->message()));
+      WebKit::WebIDBDatabaseError(error.code(), error.message()));
   callbacks_.reset();
 }
 

content/browser/indexed_db/indexed_db_callbacks_wrapper.h

@@ -34,7 +34,7 @@ class CONTENT_EXPORT IndexedDBCallbacksWrapper
     return make_scoped_refptr(new IndexedDBCallbacksWrapper(callbacks));
   }
 
-  virtual void OnError(scoped_refptr<IndexedDBDatabaseError> error);
+  virtual void OnError(const IndexedDBDatabaseError& error);
   // From IDBFactory.webkitGetDatabaseNames()
   virtual void OnSuccess(const std::vector<string16>& string);
   // From IDBObjectStore/IDBIndex.openCursor(),

content/browser/indexed_db/indexed_db_database.h

@@ -47,7 +47,7 @@ class IndexedDBDatabase : public base::RefCounted<IndexedDBDatabase> {
   virtual void Commit(int64 transaction_id) = 0;
   virtual void Abort(int64 transaction_id) = 0;
   virtual void Abort(int64 transaction_id,
-                     scoped_refptr<IndexedDBDatabaseError> error) = 0;
+                     const IndexedDBDatabaseError& error) = 0;
 
   virtual void CreateIndex(int64 transaction_id,
                            int64 object_store_id,

content/browser/indexed_db/indexed_db_database_callbacks_wrapper.cc

@@ -26,12 +26,12 @@ void IndexedDBDatabaseCallbacksWrapper::OnVersionChange(int64 old_version,
 
 void IndexedDBDatabaseCallbacksWrapper::OnAbort(
     int64 transaction_id,
-    scoped_refptr<IndexedDBDatabaseError> error) {
+    const IndexedDBDatabaseError& error) {
   if (!callbacks_)
     return;
   callbacks_->onAbort(
       transaction_id,
-      WebKit::WebIDBDatabaseError(error->code(), error->message()));
+      WebKit::WebIDBDatabaseError(error.code(), error.message()));
 }
 void IndexedDBDatabaseCallbacksWrapper::OnComplete(int64 transaction_id) {
   if (!callbacks_)

content/browser/indexed_db/indexed_db_database_callbacks_wrapper.h

@@ -27,7 +27,7 @@ class CONTENT_EXPORT IndexedDBDatabaseCallbacksWrapper
   virtual void OnVersionChange(int64 old_version, int64 new_version);
 
   virtual void OnAbort(int64 transaction_id,
-                       scoped_refptr<IndexedDBDatabaseError> error);
+                       const IndexedDBDatabaseError& error);
   virtual void OnComplete(int64 transaction_id);
 
  protected:

content/browser/indexed_db/indexed_db_database_error.h

@@ -6,34 +6,26 @@
 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_ERROR_H_
 
 #include "base/basictypes.h"
-#include "base/logging.h"
-#include "base/memory/ref_counted.h"
 #include "base/string16.h"
+#include "base/strings/utf_string_conversions.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseError.h"
 
 namespace content {
 
-class IndexedDBDatabaseError : public base::RefCounted<IndexedDBDatabaseError> {
+class IndexedDBDatabaseError {
  public:
-  static scoped_refptr<IndexedDBDatabaseError> Create(uint16 code,
-                                                      const string16& message) {
-    // TODO(jsbell): Assert that this is a valid WebIDBDatabaseException code.
-    return make_scoped_refptr(new IndexedDBDatabaseError(code, message));
-  }
-  static scoped_refptr<IndexedDBDatabaseError> Create(
-      const WebKit::WebIDBDatabaseError& other) {
-    return make_scoped_refptr(
-        new IndexedDBDatabaseError(other.code(), other.message()));
-  }
+  IndexedDBDatabaseError(uint16 code, const char* message)
+      : code_(code), message_(ASCIIToUTF16(message)) {}
+  IndexedDBDatabaseError(uint16 code, const string16& message)
+      : code_(code), message_(message) {}
+  IndexedDBDatabaseError(const WebKit::WebIDBDatabaseError& other)
+      : code_(other.code()), message_(other.message()) {}
+  ~IndexedDBDatabaseError() {}
 
   uint16 code() const { return code_; }
   const string16& message() const { return message_; }
 
  private:
-  IndexedDBDatabaseError(uint16 code, const string16& message)
-      : code_(code), message_(message) {}
-  ~IndexedDBDatabaseError() {}
-  friend class base::RefCounted<IndexedDBDatabaseError>;
   const uint16 code_;
   const string16 message_;
 };

content/browser/indexed_db/indexed_db_database_impl.cc

@@ -549,14 +549,10 @@ void CreateObjectStoreOperation::Perform(IndexedDBTransaction* transaction) {
           object_store_metadata_.name,
           object_store_metadata_.key_path,
           object_store_metadata_.auto_increment)) {
-    string16 error_string =
+    transaction->Abort(IndexedDBDatabaseError(
+        WebKit::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16("Internal error creating object store '") +
-        object_store_metadata_.name + ASCIIToUTF16("'.");
-
-    scoped_refptr<IndexedDBDatabaseError> error =
-        IndexedDBDatabaseError::Create(
-            WebKit::WebIDBDatabaseExceptionUnknownError, error_string);
-    transaction->Abort(error);
+        object_store_metadata_.name + ASCIIToUTF16("'.")));
     return;
   }
 }
@@ -625,7 +621,7 @@ void CreateIndexOperation::Perform(IndexedDBTransaction* transaction) {
                                    index_metadata_.multi_entry)) {
     string16 error_string = ASCIIToUTF16("Internal error creating index '") +
                             index_metadata_.name + ASCIIToUTF16("'.");
-    transaction->Abort(IndexedDBDatabaseError::Create(
+    transaction->Abort(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError, error_string));
     return;
   }
@@ -672,10 +668,8 @@ void DeleteIndexOperation::Perform(IndexedDBTransaction* transaction) {
   if (!ok) {
     string16 error_string = ASCIIToUTF16("Internal error deleting index '") +
                             index_metadata_.name + ASCIIToUTF16("'.");
-    scoped_refptr<IndexedDBDatabaseError> error =
-        IndexedDBDatabaseError::Create(
-            WebKit::WebIDBDatabaseExceptionUnknownError, error_string);
-    transaction->Abort(error);
+    transaction->Abort(IndexedDBDatabaseError(
+        WebKit::WebIDBDatabaseExceptionUnknownError, error_string));
   }
 }
 
@@ -703,7 +697,7 @@ void IndexedDBDatabaseImpl::Abort(int64 transaction_id) {
 }
 
 void IndexedDBDatabaseImpl::Abort(int64 transaction_id,
-                                  scoped_refptr<IndexedDBDatabaseError> error) {
+                                  const IndexedDBDatabaseError& error) {
   // If the transaction is unknown, then it has already been aborted by the
   // backend before this call so it is safe to ignore it.
   if (transactions_.find(transaction_id) != transactions_.end())
@@ -791,9 +785,9 @@ void GetOperation::Perform(IndexedDBTransaction* transaction) {
                                    *key,
                                    value);
     if (!ok) {
-      callbacks_->OnError(IndexedDBDatabaseError::Create(
+      callbacks_->OnError(IndexedDBDatabaseError(
           WebKit::WebIDBDatabaseExceptionUnknownError,
-          ASCIIToUTF16("Internal error in get_record.")));
+          "Internal error in get_record."));
       return;
     }
 
@@ -820,9 +814,9 @@ void GetOperation::Perform(IndexedDBTransaction* transaction) {
       *key,
       &primary_key);
   if (!ok) {
-    callbacks_->OnError(IndexedDBDatabaseError::Create(
+    callbacks_->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
-        ASCIIToUTF16("Internal error in get_primary_key_via_index.")));
+        "Internal error in get_primary_key_via_index."));
     return;
   }
   if (!primary_key) {
@@ -843,9 +837,9 @@ void GetOperation::Perform(IndexedDBTransaction* transaction) {
                                  *primary_key,
                                  value);
   if (!ok) {
-    callbacks_->OnError(IndexedDBDatabaseError::Create(
-        WebKit::WebIDBDatabaseExceptionUnknownError,
-        ASCIIToUTF16("Internal error in get_record.")));
+    callbacks_->OnError(
+        IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+                               "Internal error in get_record."));
     return;
   }
 
@@ -947,9 +941,9 @@ void PutOperation::Perform(IndexedDBTransaction* transaction) {
         backing_store_, transaction, database_id_, object_store_.id);
     key_was_generated = true;
     if (!auto_inc_key->IsValid()) {
-      callbacks_->OnError(IndexedDBDatabaseError::Create(
+      callbacks_->OnError(IndexedDBDatabaseError(
           WebKit::WebIDBDatabaseExceptionConstraintError,
-          ASCIIToUTF16("Maximum key generator value reached.")));
+          "Maximum key generator value reached."));
       return;
     }
     key = auto_inc_key.Pass();
@@ -970,15 +964,15 @@ void PutOperation::Perform(IndexedDBTransaction* transaction) {
         &record_identifier,
         found);
     if (!ok) {
-      callbacks_->OnError(IndexedDBDatabaseError::Create(
+      callbacks_->OnError(IndexedDBDatabaseError(
           WebKit::WebIDBDatabaseExceptionUnknownError,
-          ASCIIToUTF16("Internal error checking key existence.")));
+          "Internal error checking key existence."));
       return;
     }
     if (found) {
-      callbacks_->OnError(IndexedDBDatabaseError::Create(
+      callbacks_->OnError(IndexedDBDatabaseError(
           WebKit::WebIDBDatabaseExceptionConstraintError,
-          ASCIIToUTF16("Key already exists in the object store.")));
+          "Key already exists in the object store."));
       return;
     }
   }
@@ -999,14 +993,13 @@ void PutOperation::Perform(IndexedDBTransaction* transaction) {
                                                  &error_message,
                                                  &obeys_constraints);
   if (!backing_store_success) {
-    callbacks_->OnError(IndexedDBDatabaseError::Create(
+    callbacks_->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
-        ASCIIToUTF16(
-            "Internal error: backing store error updating index keys.")));
+        "Internal error: backing store error updating index keys."));
     return;
   }
   if (!obeys_constraints) {
-    callbacks_->OnError(IndexedDBDatabaseError::Create(
+    callbacks_->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionConstraintError, error_message));
     return;
   }
@@ -1021,10 +1014,9 @@ void PutOperation::Perform(IndexedDBTransaction* transaction) {
                                 value_,
                                 &record_identifier);
   if (!backing_store_success) {
-    callbacks_->OnError(IndexedDBDatabaseError::Create(
+    callbacks_->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
-        ASCIIToUTF16(
-            "Internal error: backing store error performing put/add.")));
+        "Internal error: backing store error performing put/add."));
     return;
   }
 
@@ -1047,9 +1039,9 @@ void PutOperation::Perform(IndexedDBTransaction* transaction) {
                                  key.get(),
                                  !key_was_generated);
     if (!ok) {
-      callbacks_->OnError(IndexedDBDatabaseError::Create(
+      callbacks_->OnError(IndexedDBDatabaseError(
           WebKit::WebIDBDatabaseExceptionUnknownError,
-          ASCIIToUTF16("Internal error updating key generator.")));
+          "Internal error updating key generator."));
       return;
     }
   }
@@ -1084,18 +1076,15 @@ void IndexedDBDatabaseImpl::SetIndexKeys(
                                     &record_identifier,
                                     found);
   if (!ok) {
-    transaction->Abort(IndexedDBDatabaseError::Create(
+    transaction->Abort(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
-        ASCIIToUTF16("Internal error setting index keys.")));
+        "Internal error setting index keys."));
     return;
   }
   if (!found) {
-    scoped_refptr<IndexedDBDatabaseError> error =
-        IndexedDBDatabaseError::Create(
+    transaction->Abort(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
-            ASCIIToUTF16(
         "Internal error setting index keys for object store."));
-    transaction->Abort(error);
     return;
   }
 
@@ -1119,14 +1108,13 @@ void IndexedDBDatabaseImpl::SetIndexKeys(
                                                  &error_message,
                                                  &obeys_constraints);
   if (!backing_store_success) {
-    transaction->Abort(IndexedDBDatabaseError::Create(
+    transaction->Abort(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
-        ASCIIToUTF16(
-            "Internal error: backing store error updating index keys.")));
+        "Internal error: backing store error updating index keys."));
     return;
   }
   if (!obeys_constraints) {
-    transaction->Abort(IndexedDBDatabaseError::Create(
+    transaction->Abort(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionConstraintError, error_message));
     return;
   }
@@ -1332,9 +1320,9 @@ void DeleteRangeOperation::Perform(IndexedDBTransaction* transaction) {
               database_id_,
               object_store_id_,
               backing_store_cursor->record_identifier())) {
-        callbacks_->OnError(IndexedDBDatabaseError::Create(
+        callbacks_->OnError(IndexedDBDatabaseError(
             WebKit::WebIDBDatabaseExceptionUnknownError,
-            ASCIIToUTF16("Internal error deleting data in range")));
+            "Internal error deleting data in range"));
         return;
       }
     } while (backing_store_cursor->ContinueFunction(0));
@@ -1364,9 +1352,9 @@ void ClearOperation::Perform(IndexedDBTransaction* transaction) {
   if (!backing_store_->ClearObjectStore(transaction->BackingStoreTransaction(),
                                         database_id_,
                                         object_store_id_)) {
-    callbacks_->OnError(IndexedDBDatabaseError::Create(
+    callbacks_->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
-        ASCIIToUTF16("Internal error clearing object store")));
+        "Internal error clearing object store"));
     return;
   }
   callbacks_->OnSuccess();
@@ -1382,10 +1370,8 @@ void DeleteObjectStoreOperation::Perform(IndexedDBTransaction* transaction) {
     string16 error_string =
         ASCIIToUTF16("Internal error deleting object store '") +
         object_store_metadata_.name + ASCIIToUTF16("'.");
-    scoped_refptr<IndexedDBDatabaseError> error =
-        IndexedDBDatabaseError::Create(
-            WebKit::WebIDBDatabaseExceptionUnknownError, error_string);
-    transaction->Abort(error);
+    transaction->Abort(IndexedDBDatabaseError(
+        WebKit::WebIDBDatabaseExceptionUnknownError, error_string));
   }
 }
 
@@ -1400,8 +1386,7 @@ void IndexedDBDatabaseImpl::VersionChangeOperation::Perform(
           transaction->BackingStoreTransaction(),
           database_id,
           database_->metadata_.int_version)) {
-    scoped_refptr<IndexedDBDatabaseError> error =
-        IndexedDBDatabaseError::Create(
+    IndexedDBDatabaseError error(
         WebKit::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16("Internal error writing data to stable storage when "
                      "updating version."));
@@ -1440,11 +1425,10 @@ void IndexedDBDatabaseImpl::TransactionFinishedAndAbortFired(
     IndexedDBTransaction* transaction) {
   if (transaction->mode() == indexed_db::TRANSACTION_VERSION_CHANGE) {
     if (pending_second_half_open_) {
-      pending_second_half_open_->Callbacks()
-          ->OnError(IndexedDBDatabaseError::Create(
+      pending_second_half_open_->Callbacks()->OnError(IndexedDBDatabaseError(
           WebKit::WebIDBDatabaseExceptionAbortError,
-                ASCIIToUTF16("Version change transaction was aborted in "
-                             "upgradeneeded event handler.")));
+          "Version change transaction was aborted in "
+                       "upgradeneeded event handler."));
       pending_second_half_open_.reset();
     }
     ProcessPendingCalls();
@@ -1575,7 +1559,6 @@ void IndexedDBDatabaseImpl::OpenConnection(
                 IndexedDBDatabaseMetadata::NO_INT_VERSION);
     } else {
       string16 message;
-      scoped_refptr<IndexedDBDatabaseError> error;
       if (version == IndexedDBDatabaseMetadata::NO_INT_VERSION)
         message = ASCIIToUTF16(
             "Internal error opening database with no version specified.");
@@ -1583,7 +1566,7 @@ void IndexedDBDatabaseImpl::OpenConnection(
         message =
             ASCIIToUTF16("Internal error opening database with version ") +
             Int64ToString16(version);
-      callbacks->OnError(IndexedDBDatabaseError::Create(
+      callbacks->OnError(IndexedDBDatabaseError(
           WebKit::WebIDBDatabaseExceptionUnknownError, message));
       return;
     }
@@ -1623,7 +1606,7 @@ void IndexedDBDatabaseImpl::OpenConnection(
     return;
   }
   if (version < metadata_.int_version) {
-    callbacks->OnError(IndexedDBDatabaseError::Create(
+    callbacks->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionVersionError,
         ASCIIToUTF16("The requested version (") + Int64ToString16(version) +
             ASCIIToUTF16(") is less than the existing version (") +
@@ -1725,9 +1708,9 @@ void IndexedDBDatabaseImpl::DeleteDatabaseFinal(
   DCHECK(!IsDeleteDatabaseBlocked());
   DCHECK(backing_store_);
   if (!backing_store_->DeleteDatabase(metadata_.name)) {
-    callbacks->OnError(IndexedDBDatabaseError::Create(
+    callbacks->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
-        ASCIIToUTF16("Internal error deleting database.")));
+        "Internal error deleting database."));
     return;
   }
   metadata_.version = kNoStringVersion;
@@ -1754,19 +1737,18 @@ void IndexedDBDatabaseImpl::Close(
          it != end;
          ++it) {
       if (it->second->connection() == callbacks)
-        it->second->Abort(IndexedDBDatabaseError::Create(
-            WebKit::WebIDBDatabaseExceptionUnknownError,
-            ASCIIToUTF16("Connection is closing.")));
+        it->second->Abort(
+            IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+                                   "Connection is closing."));
     }
   }
 
   database_callbacks_set_.erase(callbacks);
   if (pending_second_half_open_ &&
       pending_second_half_open_->DatabaseCallbacks() == callbacks) {
-    pending_second_half_open_->Callbacks()
-        ->OnError(IndexedDBDatabaseError::Create(
-              WebKit::WebIDBDatabaseExceptionAbortError,
-              ASCIIToUTF16("The connection was closed.")));
+    pending_second_half_open_->Callbacks()->OnError(
+        IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionAbortError,
+                               "The connection was closed."));
     pending_second_half_open_.reset();
   }
 

content/browser/indexed_db/indexed_db_database_impl.h

@@ -68,8 +68,8 @@ class CONTENT_EXPORT IndexedDBDatabaseImpl
 
   virtual void Commit(int64 transaction_id) OVERRIDE;
   virtual void Abort(int64 transaction_id) OVERRIDE;
-  virtual void Abort(int64 transaction_id,
-                     scoped_refptr<IndexedDBDatabaseError> error) OVERRIDE;
+  virtual void Abort(int64 transaction_id, const IndexedDBDatabaseError& error)
+      OVERRIDE;
 
   virtual void CreateIndex(int64 transaction_id,
                            int64 object_store_id,

content/browser/indexed_db/indexed_db_database_unittest.cc

@@ -47,7 +47,7 @@ class MockIDBCallbacks : public IndexedDBCallbacksWrapper {
   static scoped_refptr<MockIDBCallbacks> Create() {
     return make_scoped_refptr(new MockIDBCallbacks());
   }
-  virtual void OnError(scoped_refptr<IndexedDBDatabaseError>) OVERRIDE {}
+  virtual void OnError(const IndexedDBDatabaseError& error) OVERRIDE {}
   virtual void OnSuccess(const std::vector<string16>&) OVERRIDE {}
   virtual void OnSuccess(scoped_refptr<IndexedDBCursor> cursor,
                          const IndexedDBKey&,
@@ -87,7 +87,7 @@ class FakeIDBDatabaseCallbacks : public IndexedDBDatabaseCallbacksWrapper {
   virtual void OnVersionChange(int64 old_version, int64 new_version) OVERRIDE {}
   virtual void OnForcedClose() OVERRIDE {}
   virtual void OnAbort(int64 transaction_id,
-                       scoped_refptr<IndexedDBDatabaseError> error) OVERRIDE {}
+                       const IndexedDBDatabaseError& error) OVERRIDE {}
   virtual void OnComplete(int64 transaction_id) OVERRIDE {}
 
  private:
@@ -151,7 +151,7 @@ class MockIDBDatabaseCallbacks : public IndexedDBDatabaseCallbacksWrapper {
   virtual void OnVersionChange(int64 old_version, int64 new_version) OVERRIDE {}
   virtual void OnForcedClose() OVERRIDE {}
   virtual void OnAbort(int64 transaction_id,
-                       scoped_refptr<IndexedDBDatabaseError> error) OVERRIDE {
+                       const IndexedDBDatabaseError& error) OVERRIDE {
     was_abort_called_ = true;
   }
   virtual void OnComplete(int64 transaction_id) OVERRIDE {}
@@ -176,7 +176,7 @@ class WebIDBDatabaseCallbacksImpl : public WebIDBDatabaseCallbacks {
   }
   virtual void onAbort(long long transaction_id,
                        const WebIDBDatabaseError& error) {
-    callbacks_->OnAbort(transaction_id, IndexedDBDatabaseError::Create(error));
+    callbacks_->OnAbort(transaction_id, IndexedDBDatabaseError(error));
   }
   virtual void onComplete(long long transaction_id) {
     callbacks_->OnComplete(transaction_id);

content/browser/indexed_db/indexed_db_factory_impl.cc

@@ -58,10 +58,10 @@ void IndexedDBFactoryImpl::GetDatabaseNames(
   scoped_refptr<IndexedDBBackingStore> backing_store =
       OpenBackingStore(database_identifier, data_directory);
   if (!backing_store) {
-    callbacks->OnError(IndexedDBDatabaseError::Create(
+    callbacks->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
-        ASCIIToUTF16("Internal error opening backing store for "
-                     "indexed_db.webkit_get_database_names.")));
+        "Internal error opening backing store for "
+        "indexed_db.webkit_get_database_names."));
     return;
   }
 
@@ -90,7 +90,7 @@ void IndexedDBFactoryImpl::DeleteDatabase(
   scoped_refptr<IndexedDBBackingStore> backing_store =
       OpenBackingStore(database_identifier, data_directory);
   if (!backing_store) {
-    callbacks->OnError(IndexedDBDatabaseError::Create(
+    callbacks->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16("Internal error opening backing store "
                      "for indexed_db.delete_database.")));
@@ -101,7 +101,7 @@ void IndexedDBFactoryImpl::DeleteDatabase(
       IndexedDBDatabaseImpl::Create(
           name, backing_store.get(), this, unique_identifier);
   if (!database_backend) {
-    callbacks->OnError(IndexedDBDatabaseError::Create(
+    callbacks->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16("Internal error creating database backend for "
                      "indexed_db.delete_database.")));
@@ -168,7 +168,7 @@ void IndexedDBFactoryImpl::Open(
     scoped_refptr<IndexedDBBackingStore> backing_store =
         OpenBackingStore(database_identifier, data_directory);
     if (!backing_store) {
-      callbacks->OnError(IndexedDBDatabaseError::Create(
+      callbacks->OnError(IndexedDBDatabaseError(
           WebKit::WebIDBDatabaseExceptionUnknownError,
           ASCIIToUTF16(
               "Internal error opening backing store for indexedDB.open.")));
@@ -178,7 +178,7 @@ void IndexedDBFactoryImpl::Open(
     database_backend = IndexedDBDatabaseImpl::Create(
         name, backing_store.get(), this, unique_identifier);
     if (!database_backend) {
-      callbacks->OnError(IndexedDBDatabaseError::Create(
+      callbacks->OnError(IndexedDBDatabaseError(
           WebKit::WebIDBDatabaseExceptionUnknownError,
           ASCIIToUTF16(
               "Internal error creating database backend for indexedDB.open.")));

content/browser/indexed_db/indexed_db_transaction.cc

@@ -114,12 +114,11 @@ void IndexedDBTransaction::ScheduleTask(IndexedDBDatabase::TaskType type,
 }
 
 void IndexedDBTransaction::Abort() {
-  Abort(IndexedDBDatabaseError::Create(
-      WebKit::WebIDBDatabaseExceptionUnknownError,
-      ASCIIToUTF16("Internal error (unknown cause)")));
+  Abort(IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+                               "Internal error (unknown cause)"));
 }
 
-void IndexedDBTransaction::Abort(scoped_refptr<IndexedDBDatabaseError> error) {
+void IndexedDBTransaction::Abort(const IndexedDBDatabaseError& error) {
   IDB_TRACE("IndexedDBTransaction::abort");
   if (state_ == FINISHED)
     return;
@@ -255,9 +254,9 @@ void IndexedDBTransaction::Commit() {
   } else {
     callbacks_->OnAbort(
         id_,
-        IndexedDBDatabaseError::Create(
+        IndexedDBDatabaseError(
             WebKit::WebIDBDatabaseExceptionUnknownError,
-            ASCIIToUTF16("Internal error committing transaction.")));
+            "Internal error committing transaction."));
     database_->TransactionFinishedAndAbortFired(this);
   }
 

content/browser/indexed_db/indexed_db_transaction.h

@@ -43,7 +43,7 @@ class IndexedDBTransaction : public base::RefCounted<IndexedDBTransaction> {
     virtual void Perform(IndexedDBTransaction* transaction) = 0;
   };
 
-  void Abort(scoped_refptr<IndexedDBDatabaseError> error);
+  void Abort(const IndexedDBDatabaseError& error);
   void Run();
   indexed_db::TransactionMode mode() const { return mode_; }
   const std::set<int64>& scope() const { return object_store_ids_; }

content/browser/indexed_db/webidbdatabase_impl.cc

@@ -97,8 +97,7 @@ void WebIDBDatabaseImpl::abort(long long transaction_id) {
 void WebIDBDatabaseImpl::abort(long long transaction_id,
                                const WebIDBDatabaseError& error) {
   if (database_backend_)
-    database_backend_->Abort(transaction_id,
-                             IndexedDBDatabaseError::Create(error));
+    database_backend_->Abort(transaction_id, IndexedDBDatabaseError(error));
 }
 
 void WebIDBDatabaseImpl::commit(long long transaction_id) {