IndexedDB: Fix trivial cpplint.py errors

content/child/indexed_db/webidbcursor_impl_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 "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "content/child/indexed_db/indexed_db_dispatcher.h"
 #include "content/child/indexed_db/indexed_db_key_builders.h"
 #include "content/child/indexed_db/webidbcursor_impl.h"
 #include "content/child/thread_safe_sender.h"
@@ skipping 10 matching lines @@
 using blink::WebIDBKey;
 using blink::WebIDBKeyTypeNumber;
 using blink::WebVector;
 
 namespace content {
 
 namespace {
 
 class MockDispatcher : public IndexedDBDispatcher {
  public:
-  MockDispatcher(ThreadSafeSender* thread_safe_sender)
+  explicit MockDispatcher(ThreadSafeSender* thread_safe_sender)
       : IndexedDBDispatcher(thread_safe_sender),
         prefetch_calls_(0),
         last_prefetch_count_(0),
         reset_calls_(0),
         last_used_count_(0),
         advance_calls_(0),
         continue_calls_(0),
         destroyed_cursor_id_(0) {}
 
   virtual void RequestIDBCursorPrefetch(int n,
@@ skipping 54 matching lines @@
 class MockContinueCallbacks : public WebIDBCallbacks {
  public:
   MockContinueCallbacks(IndexedDBKey* key = 0,
                         WebVector<WebBlobInfo>* webBlobInfo = 0)
       : key_(key), webBlobInfo_(webBlobInfo) {}
 
   virtual void onSuccess(const WebIDBKey& key,
                          const WebIDBKey& primaryKey,
                          const WebData& value,
                          const WebVector<WebBlobInfo>& webBlobInfo) OVERRIDE {
-
     if (key_)
       *key_ = IndexedDBKeyBuilder::Build(key);
     if (webBlobInfo_)
       *webBlobInfo_ = webBlobInfo;
   }
 
  private:
   IndexedDBKey* key_;
   WebVector<WebBlobInfo>* webBlobInfo_;
 };
@@ skipping 16 matching lines @@
   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
   scoped_ptr<MockDispatcher> dispatcher_;
 
  private:
   scoped_refptr<IPC::SyncMessageFilter> sync_message_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(WebIDBCursorImplTest);
 };
 
 TEST_F(WebIDBCursorImplTest, PrefetchTest) {
-
   const int64 transaction_id = 1;
   {
     WebIDBCursorImpl cursor(WebIDBCursorImpl::kInvalidCursorId,
                             transaction_id,
                             thread_safe_sender_.get());
 
     // Call continue() until prefetching should kick in.
     int continue_calls = 0;
     EXPECT_EQ(dispatcher_->continue_calls(), 0);
     for (int i = 0; i < WebIDBCursorImpl::kPrefetchContinueThreshold; ++i) {
       cursor.continueFunction(null_key_, new MockContinueCallbacks());
       EXPECT_EQ(++continue_calls, dispatcher_->continue_calls());
       EXPECT_EQ(0, dispatcher_->prefetch_calls());
     }
 
     // Do enough repetitions to verify that the count grows each time,
     // but not so many that the maximum limit is hit.
     const int kPrefetchRepetitions = 5;
 
     int expected_key = 0;
     int last_prefetch_count = 0;
     for (int repetitions = 0; repetitions < kPrefetchRepetitions;
          ++repetitions) {
-
       // Initiate the prefetch
       cursor.continueFunction(null_key_, new MockContinueCallbacks());
       EXPECT_EQ(continue_calls, dispatcher_->continue_calls());
       EXPECT_EQ(repetitions + 1, dispatcher_->prefetch_calls());
 
       // Verify that the requested count has increased since last time.
       int prefetch_count = dispatcher_->last_prefetch_count();
       EXPECT_GT(prefetch_count, last_prefetch_count);
       last_prefetch_count = prefetch_count;
 
@@ skipping 27 matching lines @@
         EXPECT_EQ(expected_key++, key.number());
       }
     }
   }
 
   EXPECT_EQ(dispatcher_->destroyed_cursor_id(),
             WebIDBCursorImpl::kInvalidCursorId);
 }
 
 TEST_F(WebIDBCursorImplTest, AdvancePrefetchTest) {
-
   const int64 transaction_id = 1;
   WebIDBCursorImpl cursor(WebIDBCursorImpl::kInvalidCursorId,
                           transaction_id,
                           thread_safe_sender_.get());
 
   // Call continue() until prefetching should kick in.
   EXPECT_EQ(0, dispatcher_->continue_calls());
   for (int i = 0; i < WebIDBCursorImpl::kPrefetchContinueThreshold; ++i) {
     cursor.continueFunction(null_key_, new MockContinueCallbacks());
   }
@@ skipping 98 matching lines @@
   // The real dispatcher would call cursor->CachedContinue(), so do that:
   scoped_ptr<WebIDBCallbacks> callbacks(new MockContinueCallbacks());
   cursor.CachedContinue(callbacks.get());
 
   // Now the cursor should have reset the rest of the cache.
   EXPECT_EQ(1, dispatcher_->reset_calls());
   EXPECT_EQ(1, dispatcher_->last_used_count());
 }
 
 }  // namespace content