IndexedDB: Coding conventions and cleanup

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 <set>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
 #include "content/browser/indexed_db/indexed_db_connection.h"
 #include "content/browser/indexed_db/indexed_db_cursor.h"
 #include "content/browser/indexed_db/indexed_db_factory.h"
@@ skipping 427 matching lines @@
 class IndexedDBDatabase::PendingDeleteCall {
  public:
   explicit PendingDeleteCall(scoped_refptr<IndexedDBCallbacks> callbacks)
       : callbacks_(callbacks) {}
   scoped_refptr<IndexedDBCallbacks> Callbacks() { return callbacks_; }
 
  private:
   scoped_refptr<IndexedDBCallbacks> callbacks_;
 };
 
 scoped_refptr<IndexedDBDatabase> IndexedDBDatabase::Create(

[jsbell, 2013/07/13 00:18:32]

I did not touch this Create() static method because...

     const string16& name,
     IndexedDBBackingStore* database,
     IndexedDBFactory* factory,
     const string16& unique_identifier) {
   scoped_refptr<IndexedDBDatabase> backend =
       new IndexedDBDatabase(name, database, factory, unique_identifier);
   if (!backend->OpenInternal())

[jsbell, 2013/07/13 00:18:32]

... of this test which, which causes the Create() to return null. The idiom here
is usually x = new foo(); if (!x->init()) { ... } but I wanted to save that for
another CL.

     return 0;
   return backend;
 }
 
 namespace {
 const base::string16::value_type kNoStringVersion[] = {0};
 
 template <typename T, typename U>
 bool Contains(const T& container, const U& item) {
   return container.find(item) != container.end();
@@ skipping 106 matching lines @@
   return true;
 }
 
 bool IndexedDBDatabase::ValidateObjectStoreIdAndIndexId(int64 object_store_id,
                                                         int64 index_id) const {
   if (!ValidateObjectStoreId(object_store_id))
     return false;
   const IndexedDBObjectStoreMetadata& object_store_metadata =
       metadata_.object_stores.find(object_store_id)->second;
   if (!Contains(object_store_metadata.indexes, index_id)) {
-      DLOG(ERROR) << "Invalid index_id";
+    DLOG(ERROR) << "Invalid index_id";
     return false;
   }
   return true;
 }
 
 bool IndexedDBDatabase::ValidateObjectStoreIdAndOptionalIndexId(
     int64 object_store_id,
     int64 index_id) const {
   if (!ValidateObjectStoreId(object_store_id))
     return false;
@@ skipping 715 matching lines @@
           *key_range_,
           direction_);
     }
   }
 
   if (!backing_store_cursor) {
     callbacks_->OnSuccess(static_cast<std::string*>(NULL));
     return;
   }
 
-  IndexedDBDatabase::TaskType task_type(
-      static_cast<IndexedDBDatabase::TaskType>(task_type_));
-  scoped_refptr<IndexedDBCursor> cursor = IndexedDBCursor::Create(
-      backing_store_cursor.Pass(), cursor_type_, task_type, transaction);
+  scoped_refptr<IndexedDBCursor> cursor = new IndexedDBCursor(
+      backing_store_cursor.Pass(), cursor_type_, task_type_, transaction);
   callbacks_->OnSuccess(
       cursor, cursor->key(), cursor->primary_key(), cursor->Value());
 }
 
 void IndexedDBDatabase::Count(int64 transaction_id,
                               int64 object_store_id,
                               int64 index_id,
                               scoped_ptr<IndexedDBKeyRange> key_range,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE("IndexedDBDatabase::Count");
@@ skipping 140 matching lines @@
   int64 database_id = database_->id();
   int64 old_version = database_->metadata_.int_version;
   DCHECK_GT(version_, old_version);
   database_->metadata_.int_version = version_;
   if (!database_->backing_store_->UpdateIDBDatabaseIntVersion(
           transaction->BackingStoreTransaction(),
           database_id,
           database_->metadata_.int_version)) {
     IndexedDBDatabaseError error(
         WebKit::WebIDBDatabaseExceptionUnknownError,
-        ASCIIToUTF16("Internal error writing data to stable storage when "
-                     "updating version."));
+        ASCIIToUTF16(
+            "Internal error writing data to stable storage when "
+            "updating version."));
     callbacks_->OnError(error);
     transaction->Abort(error);
     return;
   }
   DCHECK(!database_->pending_second_half_open_);
 
   database_->pending_second_half_open_.reset(new PendingSuccessCall(
       callbacks_, connection_.get(), transaction_id_, version_));
   callbacks_->OnUpgradeNeeded(
       old_version, connection_.Pass(), database_->metadata(), data_loss_);
@@ skipping 106 matching lines @@
 }
 
 void IndexedDBDatabase::CreateTransaction(
     int64 transaction_id,
     IndexedDBConnection* connection,
     const std::vector<int64>& object_store_ids,
     uint16 mode) {
 
   DCHECK(connections_.has(connection));
 
-  scoped_refptr<IndexedDBTransaction> transaction =
-      IndexedDBTransaction::Create(
-          transaction_id,
-          connection->callbacks(),
-          object_store_ids,
-          static_cast<indexed_db::TransactionMode>(mode),
-          this);
+  scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction(
+      transaction_id,
+      connection->callbacks(),
+      std::set<int64>(object_store_ids.begin(), object_store_ids.end()),
+      static_cast<indexed_db::TransactionMode>(mode),
+      this);
   DCHECK(transactions_.find(transaction_id) == transactions_.end());
   transactions_[transaction_id] = transaction;
 }
 
 bool IndexedDBDatabase::IsOpenConnectionBlocked() const {
   return !pending_delete_calls_.empty() ||
          running_version_change_transaction_ ||
          pending_run_version_change_transaction_call_;
 }
 
@@ skipping 292 matching lines @@
 
 void IndexedDBDatabase::VersionChangeAbortOperation::Perform(
     IndexedDBTransaction* transaction) {
   IDB_TRACE("VersionChangeAbortOperation");
   DCHECK(!transaction);
   database_->metadata_.version = previous_version_;
   database_->metadata_.int_version = previous_int_version_;
 }
 
 }  // namespace content