[IndexedDB] Refactoring to remove ref ptrs and host transaction ids.

content/browser/indexed_db/indexed_db_factory_unittest.cc

 // Copyright 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 <stdint.h>
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
@@ skipping 409 matching lines @@
   UpgradeNeededCallbacks() {}
 
   void OnSuccess(std::unique_ptr<IndexedDBConnection> connection,
                  const IndexedDBDatabaseMetadata& metadata) override {
     EXPECT_TRUE(connection_.get());
     EXPECT_FALSE(connection.get());
   }
 
   void OnUpgradeNeeded(int64_t old_version,
                        std::unique_ptr<IndexedDBConnection> connection,
+                       IndexedDBTransaction* transaction,
                        const content::IndexedDBDatabaseMetadata& metadata,
                        const IndexedDBDataLossInfo& data_loss_info) override {
+    transaction_ = transaction;
     connection_ = std::move(connection);
   }
 
+  IndexedDBTransaction* transaction() const { return transaction_; }
+
  protected:
   ~UpgradeNeededCallbacks() override {}
 
  private:
+  IndexedDBTransaction* transaction_ = nullptr;
+
   DISALLOW_COPY_AND_ASSIGN(UpgradeNeededCallbacks);
 };
 
 class ErrorCallbacks : public MockIndexedDBCallbacks {
  public:
   ErrorCallbacks() : MockIndexedDBCallbacks(false), saw_error_(false) {}
 
   void OnError(const IndexedDBDatabaseError& error) override {
     saw_error_ = true;
   }
@@ skipping 13 matching lines @@
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   const base::string16 db_name(ASCIIToUTF16("db"));
   const int64_t db_version = 2;
   const int64_t transaction_id = 1;
   scoped_refptr<IndexedDBDatabaseCallbacks> db_callbacks(
       new MockIndexedDBDatabaseCallbacks());
 
   // Open at version 2, then close.
   {
-    scoped_refptr<MockIndexedDBCallbacks> callbacks(
+    scoped_refptr<UpgradeNeededCallbacks> callbacks(
         new UpgradeNeededCallbacks());
     std::unique_ptr<IndexedDBPendingConnection> connection(
         base::MakeUnique<IndexedDBPendingConnection>(
             callbacks, db_callbacks, 0 /* child_process_id */, transaction_id,
             db_version));
     factory()->Open(db_name, std::move(connection),
                     nullptr /* request_context */, origin,
                     temp_directory.GetPath());
     EXPECT_TRUE(factory()->IsDatabaseOpen(origin, db_name));
 
     // Pump the message loop so the upgrade transaction can run.
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(callbacks->connection());
-    callbacks->connection()->database()->Commit(transaction_id);
+    EXPECT_NE(callbacks->transaction(), nullptr);
+    callbacks->connection()->database()->Commit(callbacks->transaction());
 
     callbacks->connection()->Close();
     EXPECT_FALSE(factory()->IsDatabaseOpen(origin, db_name));
   }
 
   // Open at version < 2, which will fail; ensure factory doesn't retain
   // the database object.
   {
     scoped_refptr<ErrorCallbacks> callbacks(new ErrorCallbacks());
     std::unique_ptr<IndexedDBPendingConnection> connection(
         base::MakeUnique<IndexedDBPendingConnection>(
             callbacks, db_callbacks, 0 /* child_process_id */, transaction_id,
             db_version - 1));
     factory()->Open(db_name, std::move(connection),
                     nullptr /* request_context */, origin,
                     temp_directory.GetPath());
     EXPECT_TRUE(callbacks->saw_error());
     EXPECT_FALSE(factory()->IsDatabaseOpen(origin, db_name));
   }
 
   // Terminate all pending-close timers.
   factory()->ForceClose(origin);
 }
 
 }  // namespace content