IndexedDB: Fix coding style issues c/o cpplint.py

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 354 matching lines @@
   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);
+        &transaction1, 1, 1, m_key1, &m_value1, &handles, &record);
     EXPECT_TRUE(s.ok());
     scoped_refptr<TestCallback> callback(new TestCallback());
     EXPECT_TRUE(transaction1.CommitPhaseOne(callback).ok());
     EXPECT_TRUE(callback->called);
     EXPECT_TRUE(callback->succeeded);
     EXPECT_TRUE(transaction1.CommitPhaseTwo().ok());
   }
 
   {
     IndexedDBBackingStore::Transaction transaction2(backing_store_);
@@ skipping 14 matching lines @@
 TEST_F(IndexedDBBackingStoreTest, PutGetConsistencyWithBlobs) {
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_);
     transaction1.Begin();
     ScopedVector<webkit_blob::BlobDataHandle> handles;
     IndexedDBBackingStore::RecordIdentifier record;
     EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                           1,
                                           1,
                                           m_key3,
-                                          m_value3,
+                                          &m_value3,
                                           &handles,
                                           &record).ok());
     scoped_refptr<TestCallback> callback(new TestCallback());
     EXPECT_TRUE(transaction1.CommitPhaseOne(callback).ok());
     task_runner_->RunUntilIdle();
     EXPECT_TRUE(CheckBlobWrites());
     EXPECT_TRUE(callback->called);
     EXPECT_TRUE(callback->succeeded);
     EXPECT_TRUE(transaction1.CommitPhaseTwo().ok());
   }
@@ skipping 64 matching lines @@
       IndexedDBValue value2 = IndexedDBValue("value2", blob_info2);
       IndexedDBValue value3 = IndexedDBValue("value3", blob_info3);
       IndexedDBBackingStore::Transaction transaction1(backing_store_);
       transaction1.Begin();
       ScopedVector<webkit_blob::BlobDataHandle> handles;
       IndexedDBBackingStore::RecordIdentifier record;
       EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                             1,
                                             i + 1,
                                             key0,
-                                            value0,
+                                            &value0,
                                             &handles,
                                             &record).ok());
       EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                             1,
                                             i + 1,
                                             key1,
-                                            value1,
+                                            &value1,
                                             &handles,
                                             &record).ok());
       EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                             1,
                                             i + 1,
                                             key2,
-                                            value2,
+                                            &value2,
                                             &handles,
                                             &record).ok());
       EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                             1,
                                             i + 1,
                                             key3,
-                                            value3,
+                                            &value3,
                                             &handles,
                                             &record).ok());
       scoped_refptr<TestCallback> callback(new TestCallback());
       EXPECT_TRUE(transaction1.CommitPhaseOne(callback).ok());
       task_runner_->RunUntilIdle();
       EXPECT_TRUE(callback->called);
       EXPECT_TRUE(callback->succeeded);
       EXPECT_TRUE(transaction1.CommitPhaseTwo().ok());
     }
 
@@ skipping 48 matching lines @@
       IndexedDBValue value2 = IndexedDBValue("value2", blob_info2);
       IndexedDBValue value3 = IndexedDBValue("value3", blob_info3);
       IndexedDBBackingStore::Transaction transaction1(backing_store_);
       transaction1.Begin();
       ScopedVector<webkit_blob::BlobDataHandle> handles;
       IndexedDBBackingStore::RecordIdentifier record;
       EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                             1,
                                             i + 1,
                                             key0,
-                                            value0,
+                                            &value0,
                                             &handles,
                                             &record).ok());
       EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                             1,
                                             i + 1,
                                             key1,
-                                            value1,
+                                            &value1,
                                             &handles,
                                             &record).ok());
       EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                             1,
                                             i + 1,
                                             key2,
-                                            value2,
+                                            &value2,
                                             &handles,
                                             &record).ok());
       EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                             1,
                                             i + 1,
                                             key3,
-                                            value3,
+                                            &value3,
                                             &handles,
                                             &record).ok());
       scoped_refptr<TestCallback> callback(new TestCallback());
       EXPECT_TRUE(transaction1.CommitPhaseOne(callback).ok());
       task_runner_->RunUntilIdle();
       EXPECT_TRUE(callback->called);
       EXPECT_TRUE(callback->succeeded);
       EXPECT_TRUE(transaction1.CommitPhaseTwo().ok());
     }
 
@@ skipping 17 matching lines @@
 TEST_F(IndexedDBBackingStoreTest, LiveBlobJournal) {
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_);
     transaction1.Begin();
     ScopedVector<webkit_blob::BlobDataHandle> handles;
     IndexedDBBackingStore::RecordIdentifier record;
     EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                           1,
                                           1,
                                           m_key3,
-                                          m_value3,
+                                          &m_value3,
                                           &handles,
                                           &record).ok());
     scoped_refptr<TestCallback> callback(new TestCallback());
     EXPECT_TRUE(transaction1.CommitPhaseOne(callback).ok());
     task_runner_->RunUntilIdle();
     EXPECT_TRUE(CheckBlobWrites());
     EXPECT_TRUE(callback->called);
     EXPECT_TRUE(callback->succeeded);
     EXPECT_TRUE(transaction1.CommitPhaseTwo().ok());
   }
@@ skipping 58 matching lines @@
   EncodeIDBKey(index_key, &index_key_raw);
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_);
     transaction1.Begin();
     ScopedVector<webkit_blob::BlobDataHandle> handles;
     IndexedDBBackingStore::RecordIdentifier record;
     leveldb::Status s = backing_store_->PutRecord(&transaction1,
                                                   high_database_id,
                                                   high_object_store_id,
                                                   m_key1,
-                                                  m_value1,
+                                                  &m_value1,
                                                   &handles,
                                                   &record);
     EXPECT_TRUE(s.ok());
 
     s = backing_store_->PutIndexDataForRecord(&transaction1,
                                               high_database_id,
                                               high_object_store_id,
                                               invalid_high_index_id,
                                               index_key,
                                               record);
@@ skipping 68 matching lines @@
 
   IndexedDBBackingStore::Transaction transaction1(backing_store_);
   transaction1.Begin();
 
   ScopedVector<webkit_blob::BlobDataHandle> handles;
   IndexedDBBackingStore::RecordIdentifier record;
   leveldb::Status s = backing_store_->PutRecord(&transaction1,
                                                 database_id,
                                                 KeyPrefix::kInvalidId,
                                                 m_key1,
-                                                m_value1,
+                                                &m_value1,
                                                 &handles,
                                                 &record);
   EXPECT_FALSE(s.ok());
   s = backing_store_->PutRecord(
-      &transaction1, database_id, 0, m_key1, m_value1, &handles, &record);
+      &transaction1, database_id, 0, m_key1, &m_value1, &handles, &record);
   EXPECT_FALSE(s.ok());
   s = backing_store_->PutRecord(&transaction1,
                                 KeyPrefix::kInvalidId,
                                 object_store_id,
                                 m_key1,
-                                m_value1,
+                                &m_value1,
                                 &handles,
                                 &record);
   EXPECT_FALSE(s.ok());
   s = backing_store_->PutRecord(
-      &transaction1, 0, object_store_id, m_key1, m_value1, &handles, &record);
+      &transaction1, 0, object_store_id, m_key1, &m_value1, &handles, &record);
   EXPECT_FALSE(s.ok());
 
   s = backing_store_->GetRecord(
       &transaction1, database_id, KeyPrefix::kInvalidId, m_key1, &result_value);
   EXPECT_FALSE(s.ok());
   s = backing_store_->GetRecord(
       &transaction1, database_id, 0, m_key1, &result_value);
   EXPECT_FALSE(s.ok());
   s = backing_store_->GetRecord(&transaction1,
                                 KeyPrefix::kInvalidId,
@@ skipping 122 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