IndexedDB: Sprinkle DISALLOW_COPY_AND_ASSIGN where appropriate

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/callback.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
@@ skipping 22 matching lines @@
  public:
   virtual int Compare(const base::StringPiece& a,
                       const base::StringPiece& b) const OVERRIDE {
     return content::Compare(a, b, false /*index_keys*/);
   }
   virtual const char* Name() const OVERRIDE { return "idb_cmp1"; }
 };
 
 class DefaultLevelDBFactory : public LevelDBFactory {
  public:
+  DefaultLevelDBFactory() {}
   virtual leveldb::Status OpenLevelDB(const base::FilePath& file_name,
                                       const LevelDBComparator* comparator,
                                       scoped_ptr<LevelDBDatabase>* db,
                                       bool* is_disk_full) OVERRIDE {
     return LevelDBDatabase::Open(file_name, comparator, db, is_disk_full);
   }
   virtual leveldb::Status DestroyLevelDB(
       const base::FilePath& file_name) OVERRIDE {
     return LevelDBDatabase::Destroy(file_name);
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DefaultLevelDBFactory);
 };
 
 class TestableIndexedDBBackingStore : public IndexedDBBackingStore {
  public:
   static scoped_refptr<TestableIndexedDBBackingStore> Open(
       IndexedDBFactory* indexed_db_factory,
       const GURL& origin_url,
       const base::FilePath& path_base,
       net::URLRequestContext* request_context,
       LevelDBFactory* leveldb_factory,
@@ skipping 90 matching lines @@
                               blob_path,
                               request_context,
                               db.Pass(),
                               comparator.Pass(),
                               task_runner),
         database_id_(0) {}
 
   int64 database_id_;
   std::vector<Transaction::WriteDescriptor> writes_;
   std::vector<int64> removals_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestableIndexedDBBackingStore);
 };
 
 class TestIDBFactory : public IndexedDBFactory {
  public:
   TestIDBFactory(IndexedDBContextImpl* idb_context)
       : IndexedDBFactory(idb_context) {}
 
   scoped_refptr<TestableIndexedDBBackingStore> OpenBackingStoreForTest(
       const GURL& origin,
       net::URLRequestContext* url_request_context) {
@@ skipping 24 matching lines @@
       bool* disk_full,
       bool first_time) OVERRIDE {
     DefaultLevelDBFactory leveldb_factory;
     return TestableIndexedDBBackingStore::Open(this,
                                                origin_url,
                                                data_directory,
                                                request_context,
                                                &leveldb_factory,
                                                context()->TaskRunner());
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestIDBFactory);
 };
 
 class IndexedDBBackingStoreTest : public testing::Test {
  public:
   IndexedDBBackingStoreTest() {}
   virtual void SetUp() {
     const GURL origin("http://localhost:81");
     task_runner_ = new base::TestSimpleTaskRunner();
     special_storage_policy_ = new MockSpecialStoragePolicy();
     special_storage_policy_->SetAllUnlimited(true);
@@ skipping 119 matching lines @@
   TestCallback() : called(false), succeeded(false) {}
   virtual void Run(bool succeeded_in) OVERRIDE {
     called = true;
     succeeded = succeeded_in;
   }
   bool called;
   bool succeeded;
 
  protected:
   virtual ~TestCallback() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestCallback);
 };
 
 TEST_F(IndexedDBBackingStoreTest, PutGetConsistency) {
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_);
     transaction1.Begin();
     ScopedVector<webkit_blob::BlobDataHandle> handles;
     IndexedDBBackingStore::RecordIdentifier record;
     leveldb::Status s = backing_store_->PutRecord(
         &transaction1, 1, 1, m_key1, m_value1, &handles, &record);
@@ skipping 585 matching lines @@
     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);
   }
 }
 
 }  // namespace
 
 }  // namespace content