IndexedDB: Remove unnecessary scoped_refptr<T>::get() calls

content/browser/indexed_db/indexed_db_backing_store_unittest.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/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
@@ skipping 40 matching lines @@
   IndexedDBKey m_key1;
   IndexedDBKey m_key2;
   IndexedDBKey m_key3;
   std::vector<char> m_value1;
   std::vector<char> m_value2;
   std::vector<char> m_value3;
 };
 
 TEST_F(IndexedDBBackingStoreTest, PutGetConsistency) {
   {
-    IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
+    IndexedDBBackingStore::Transaction transaction1(backing_store_);
     transaction1.Begin();
     IndexedDBBackingStore::RecordIdentifier record;
     bool ok = backing_store_->PutRecord(
         &transaction1, 1, 1, m_key1, m_value1, &record);
     EXPECT_TRUE(ok);
     transaction1.Commit();
   }
 
   {
-    IndexedDBBackingStore::Transaction transaction2(backing_store_.get());
+    IndexedDBBackingStore::Transaction transaction2(backing_store_);
     transaction2.Begin();
     std::vector<char> result_value;
     bool ok =
         backing_store_->GetRecord(&transaction2, 1, 1, m_key1, &result_value);
     transaction2.Commit();
     EXPECT_TRUE(ok);
     EXPECT_EQ(m_value1, result_value);
   }
 }
 
 // Make sure that using very high ( more than 32 bit ) values for database_id
 // and object_store_id still work.
 TEST_F(IndexedDBBackingStoreTest, HighIds) {
   const int64 high_database_id = 1ULL << 35;
   const int64 high_object_store_id = 1ULL << 39;
   // index_ids are capped at 32 bits for storage purposes.
   const int64 high_index_id = 1ULL << 29;
 
   const int64 invalid_high_index_id = 1ULL << 37;
 
   const IndexedDBKey& index_key = m_key2;
   std::vector<char> index_key_raw;
   EncodeIDBKey(index_key, &index_key_raw);
   {
-    IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
+    IndexedDBBackingStore::Transaction transaction1(backing_store_);
     transaction1.Begin();
     IndexedDBBackingStore::RecordIdentifier record;
     bool ok = backing_store_->PutRecord(&transaction1,
                                         high_database_id,
                                         high_object_store_id,
                                         m_key1,
                                         m_value1,
                                         &record);
     EXPECT_TRUE(ok);
 
@@ skipping 11 matching lines @@
                                                high_index_id,
                                                index_key,
                                                record);
     EXPECT_TRUE(ok);
 
     ok = transaction1.Commit();
     EXPECT_TRUE(ok);
   }
 
   {
-    IndexedDBBackingStore::Transaction transaction2(backing_store_.get());
+    IndexedDBBackingStore::Transaction transaction2(backing_store_);
     transaction2.Begin();
     std::vector<char> result_value;
     bool ok = backing_store_->GetRecord(&transaction2,
                                         high_database_id,
                                         high_object_store_id,
                                         m_key1,
                                         &result_value);
     EXPECT_TRUE(ok);
     EXPECT_EQ(m_value1, result_value);
 
@@ skipping 23 matching lines @@
 // Make sure that other invalid ids do not crash.
 TEST_F(IndexedDBBackingStoreTest, InvalidIds) {
   // valid ids for use when testing invalid ids
   const int64 database_id = 1;
   const int64 object_store_id = 1;
   const int64 index_id = kMinimumIndexId;
   const int64 invalid_low_index_id = 19;  // index_ids must be > kMinimumIndexId
 
   std::vector<char> result_value;
 
-  IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
+  IndexedDBBackingStore::Transaction transaction1(backing_store_);
   transaction1.Begin();
 
   IndexedDBBackingStore::RecordIdentifier record;
   bool ok = backing_store_->PutRecord(&transaction1,
                                       database_id,
                                       KeyPrefix::kInvalidId,
                                       m_key1,
                                       m_value1,
                                       &record);
   EXPECT_FALSE(ok);
@@ skipping 79 matching lines @@
   const bool unique = true;
   const bool multi_entry = true;
   const IndexedDBKeyPath index_key_path(ASCIIToUTF16("index_key"));
 
   {
     bool ok = backing_store_->CreateIDBDatabaseMetaData(
         database_name, version, int_version, &database_id);
     EXPECT_TRUE(ok);
     EXPECT_GT(database_id, 0);
 
-    IndexedDBBackingStore::Transaction transaction(backing_store_.get());
+    IndexedDBBackingStore::Transaction transaction(backing_store_);
     transaction.Begin();
 
     ok = backing_store_->CreateObjectStore(&transaction,
                                            database_id,
                                            object_store_id,
                                            object_store_name,
                                            object_store_key_path,
                                            auto_increment);
     EXPECT_TRUE(ok);
 
@@ skipping 116 matching lines @@
 
   factory = NULL;
   EXPECT_FALSE(mem_store1->HasOneRef());  // mem_store1 and 2
   EXPECT_FALSE(mem_store2->HasOneRef());  // mem_store1 and 2
   EXPECT_TRUE(mem_store3->HasOneRef());
 
   mem_store2 = NULL;
   EXPECT_TRUE(mem_store1->HasOneRef());
 }
 
-TEST(IndexedDBFactoryTest, RejectLongOrigins)
-{
+TEST(IndexedDBFactoryTest, RejectLongOrigins) {
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
   const base::FilePath base_path = temp_directory.path();
   scoped_refptr<MockIDBFactory> factory = MockIDBFactory::Create();
 
   int limit = file_util::GetMaximumPathComponentLength(base_path);
   EXPECT_GT(limit, 0);
 
   std::string origin(limit + 1, 'x');
   WebSecurityOrigin too_long_origin =
       WebSecurityOrigin::createFromString(WebKit::WebString::fromUTF8(
           std::string("http://" + origin + ":81/").c_str()));
   scoped_refptr<IndexedDBBackingStore> diskStore1 =
       factory->TestOpenBackingStore(too_long_origin, base_path);
-  EXPECT_FALSE(diskStore1.get());
+  EXPECT_FALSE(diskStore1);
 
   WebSecurityOrigin ok_origin =
       WebSecurityOrigin::createFromString("http://someorigin.com:82/");
   scoped_refptr<IndexedDBBackingStore> diskStore2 =
       factory->TestOpenBackingStore(ok_origin, base_path);
-  EXPECT_TRUE(diskStore2.get());
+  EXPECT_TRUE(diskStore2);
 }
 
 }  // namespace
 
 }  // namespace content