IndexedDB: Coding conventions and cleanup

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 303 matching lines @@
     IndexedDBIndexMetadata index = object_store.indexes[index_id];
     EXPECT_EQ(index_name, index.name);
     EXPECT_EQ(index_key_path, index.key_path);
     EXPECT_EQ(unique, index.unique);
     EXPECT_EQ(multi_entry, index.multi_entry);
   }
 }
 
 class MockIDBFactory : public IndexedDBFactory {
  public:
-  static scoped_refptr<MockIDBFactory> Create() {
-    return make_scoped_refptr(new MockIDBFactory());
-  }
-
   scoped_refptr<IndexedDBBackingStore> TestOpenBackingStore(
       const GURL& origin,
       const base::FilePath& data_directory) {
     WebKit::WebIDBCallbacks::DataLoss data_loss =
         WebKit::WebIDBCallbacks::DataLossNone;
     scoped_refptr<IndexedDBBackingStore> backing_store =
         OpenBackingStore(webkit_database::GetIdentifierFromOrigin(origin),
                          data_directory,
                          &data_loss);
     EXPECT_EQ(WebKit::WebIDBCallbacks::DataLossNone, data_loss);
     return backing_store;
   }
 
  private:
   virtual ~MockIDBFactory() {}
 };
 
 TEST(IndexedDBFactoryTest, BackingStoreLifetime) {
   GURL origin1("http://localhost:81");
   GURL origin2("http://localhost:82");
 
-  scoped_refptr<MockIDBFactory> factory = MockIDBFactory::Create();
+  scoped_refptr<MockIDBFactory> factory = new MockIDBFactory();
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
   scoped_refptr<IndexedDBBackingStore> disk_store1 =
       factory->TestOpenBackingStore(origin1, temp_directory.path());
   EXPECT_TRUE(disk_store1->HasOneRef());
 
   scoped_refptr<IndexedDBBackingStore> disk_store2 =
       factory->TestOpenBackingStore(origin1, temp_directory.path());
   EXPECT_EQ(disk_store1.get(), disk_store2.get());
   EXPECT_FALSE(disk_store2->HasOneRef());
 
   scoped_refptr<IndexedDBBackingStore> disk_store3 =
       factory->TestOpenBackingStore(origin2, temp_directory.path());
   EXPECT_TRUE(disk_store3->HasOneRef());
   EXPECT_FALSE(disk_store1->HasOneRef());
 
   disk_store2 = NULL;
   EXPECT_TRUE(disk_store1->HasOneRef());
 }
 
 TEST(IndexedDBFactoryTest, MemoryBackingStoreLifetime) {
   GURL origin1("http://localhost:81");
   GURL origin2("http://localhost:82");
 
-  scoped_refptr<MockIDBFactory> factory = MockIDBFactory::Create();
+  scoped_refptr<MockIDBFactory> factory = new MockIDBFactory();
   scoped_refptr<IndexedDBBackingStore> mem_store1 =
       factory->TestOpenBackingStore(origin1, base::FilePath());
   EXPECT_FALSE(mem_store1->HasOneRef());  // mem_store1 and factory
 
   scoped_refptr<IndexedDBBackingStore> mem_store2 =
       factory->TestOpenBackingStore(origin1, base::FilePath());
   EXPECT_EQ(mem_store1.get(), mem_store2.get());
   EXPECT_FALSE(mem_store1->HasOneRef());  // mem_store1, 2 and factory
   EXPECT_FALSE(mem_store2->HasOneRef());  // mem_store1, 2 and factory
 
   scoped_refptr<IndexedDBBackingStore> mem_store3 =
       factory->TestOpenBackingStore(origin2, base::FilePath());
   EXPECT_FALSE(mem_store1->HasOneRef());  // mem_store1, 2 and factory
   EXPECT_FALSE(mem_store3->HasOneRef());  // mem_store3 and factory
 
   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) {
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
   const base::FilePath base_path = temp_directory.path();
-  scoped_refptr<MockIDBFactory> factory = MockIDBFactory::Create();
+  scoped_refptr<MockIDBFactory> factory = new MockIDBFactory();
 
   int limit = file_util::GetMaximumPathComponentLength(base_path);
   EXPECT_GT(limit, 0);
 
   std::string origin(limit + 1, 'x');
   GURL too_long_origin("http://" + origin + ":81/");
   scoped_refptr<IndexedDBBackingStore> diskStore1 =
       factory->TestOpenBackingStore(too_long_origin, base_path);
   EXPECT_FALSE(diskStore1);
 
   GURL ok_origin("http://someorigin.com:82/");
   scoped_refptr<IndexedDBBackingStore> diskStore2 =
       factory->TestOpenBackingStore(ok_origin, base_path);
   EXPECT_TRUE(diskStore2);
 }
 
 }  // namespace
 
 }  // namespace content