IndexedDB: Coding conventions and cleanup

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 "base/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_piece.h"
@@ skipping 216 matching lines @@
   return true;
 }
 
 WARN_UNUSED_RESULT static bool SetUpMetadata(
     LevelDBDatabase* db,
     const std::string& origin_identifier) {
   const uint32 latest_known_data_version = kWireVersion;
   const std::string schema_version_key = SchemaVersionKey::Encode();
   const std::string data_version_key = DataVersionKey::Encode();
 
-  scoped_refptr<LevelDBTransaction> transaction =
-      LevelDBTransaction::Create(db);
+  scoped_refptr<LevelDBTransaction> transaction = new LevelDBTransaction(db);
 
   int64 db_schema_version = 0;
   int64 db_data_version = 0;
   bool found = false;
   bool ok =
       GetInt(transaction.get(), schema_version_key, &db_schema_version, &found);
   if (!ok) {
     INTERNAL_READ_ERROR(SET_UP_METADATA);
     return false;
   }
@@ skipping 466 matching lines @@
   if (!ok) {
     INTERNAL_READ_ERROR(GET_IDBDATABASE_METADATA);
     return false;
   }
 
   return true;
 }
 
 WARN_UNUSED_RESULT static bool GetNewDatabaseId(LevelDBDatabase* db,
                                                 int64* new_id) {
-  scoped_refptr<LevelDBTransaction> transaction =
-      LevelDBTransaction::Create(db);
+  scoped_refptr<LevelDBTransaction> transaction = new LevelDBTransaction(db);
 
   *new_id = -1;
   int64 max_database_id = -1;
   bool found = false;
   bool ok = GetInt(
       transaction.get(), MaxDatabaseIdKey::Encode(), &max_database_id, &found);
   if (!ok) {
     INTERNAL_READ_ERROR(GET_NEW_DATABASE_ID);
     return false;
   }
@@ skipping 18 matching lines @@
                                                       int64* row_id) {
   bool ok = GetNewDatabaseId(db_.get(), row_id);
   if (!ok)
     return false;
   DCHECK_GE(*row_id, 0);
 
   if (int_version == IndexedDBDatabaseMetadata::NO_INT_VERSION)
     int_version = IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION;
 
   scoped_refptr<LevelDBTransaction> transaction =
-      LevelDBTransaction::Create(db_.get());
+      new LevelDBTransaction(db_.get());
   PutInt(
       transaction.get(), DatabaseNameKey::Encode(identifier_, name), *row_id);
   PutString(
       transaction.get(),
       DatabaseMetaDataKey::Encode(*row_id, DatabaseMetaDataKey::USER_VERSION),
       version);
   PutVarInt(transaction.get(),
             DatabaseMetaDataKey::Encode(*row_id,
                                         DatabaseMetaDataKey::USER_INT_VERSION),
             int_version);
@@ skipping 1799 matching lines @@
 
 IndexedDBBackingStore::Transaction::Transaction(
     IndexedDBBackingStore* backing_store)
     : backing_store_(backing_store) {}
 
 IndexedDBBackingStore::Transaction::~Transaction() {}
 
 void IndexedDBBackingStore::Transaction::Begin() {
   IDB_TRACE("IndexedDBBackingStore::Transaction::Begin");
   DCHECK(!transaction_.get());
-  transaction_ = LevelDBTransaction::Create(backing_store_->db_.get());
+  transaction_ = new LevelDBTransaction(backing_store_->db_.get());
 }
 
 bool IndexedDBBackingStore::Transaction::Commit() {
   IDB_TRACE("IndexedDBBackingStore::Transaction::Commit");
   DCHECK(transaction_.get());
   bool result = transaction_->Commit();
   transaction_ = NULL;
   if (!result)
     INTERNAL_WRITE_ERROR(TRANSACTION_COMMIT_METHOD);
   return result;
 }
 
 void IndexedDBBackingStore::Transaction::Rollback() {
   IDB_TRACE("IndexedDBBackingStore::Transaction::Rollback");
   DCHECK(transaction_.get());
   transaction_->Rollback();
   transaction_ = NULL;
 }
 
 }  // namespace content