Switch to standard integer types in content/.

content/child/indexed_db/indexed_db_dispatcher_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 <stddef.h>
+#include <stdint.h>
+
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "content/child/indexed_db/indexed_db_dispatcher.h"
 #include "content/child/indexed_db/mock_webidbcallbacks.h"
 #include "content/child/indexed_db/webidbcursor_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/indexed_db/indexed_db_key.h"
 #include "content/common/indexed_db/indexed_db_key_range.h"
@@ skipping 59 matching lines @@
 };
 
 TEST_F(IndexedDBDispatcherTest, ValueSizeTest) {
   // For testing use a much smaller maximum size to prevent allocating >100 MB
   // of memory, which crashes on memory-constrained systems.
   const size_t kMaxValueSizeForTesting = 10 * 1024 * 1024;  // 10 MB
 
   const std::vector<char> data(kMaxValueSizeForTesting + 1);
   const WebData value(&data.front(), data.size());
   const WebVector<WebBlobInfo> web_blob_info;
-  const int32 ipc_dummy_id = -1;
-  const int64 transaction_id = 1;
-  const int64 object_store_id = 2;
+  const int32_t ipc_dummy_id = -1;
+  const int64_t transaction_id = 1;
+  const int64_t object_store_id = 2;
 
   StrictMock<MockWebIDBCallbacks> callbacks;
   EXPECT_CALL(callbacks, onError(_)).Times(1);
 
   IndexedDBDispatcher dispatcher(thread_safe_sender_.get());
   dispatcher.max_put_value_size_ = kMaxValueSizeForTesting;
   IndexedDBKey key(0, blink::WebIDBKeyTypeNumber);
   dispatcher.RequestIDBDatabasePut(ipc_dummy_id,
                                    transaction_id,
                                    object_store_id,
@@ skipping 11 matching lines @@
   // of memory, which crashes on memory-constrained systems.
   const size_t kMaxValueSizeForTesting = 10 * 1024 * 1024;  // 10 MB
   const size_t kKeySize = 1024 * 1024;
 
   const std::vector<char> data(kMaxValueSizeForTesting - kKeySize);
   const WebData value(&data.front(), data.size());
   const WebVector<WebBlobInfo> web_blob_info;
   const IndexedDBKey key(
       base::string16(kKeySize / sizeof(base::string16::value_type), 'x'));
 
-  const int32 ipc_dummy_id = -1;
-  const int64 transaction_id = 1;
-  const int64 object_store_id = 2;
+  const int32_t ipc_dummy_id = -1;
+  const int64_t transaction_id = 1;
+  const int64_t object_store_id = 2;
 
   StrictMock<MockWebIDBCallbacks> callbacks;
   EXPECT_CALL(callbacks, onError(_)).Times(1);
 
   IndexedDBDispatcher dispatcher(thread_safe_sender_.get());
   dispatcher.max_put_value_size_ = kMaxValueSizeForTesting;
   dispatcher.RequestIDBDatabasePut(ipc_dummy_id,
                                    transaction_id,
                                    object_store_id,
                                    value,
                                    web_blob_info,
                                    key,
                                    blink::WebIDBPutModeAddOrUpdate,
                                    &callbacks,
                                    WebVector<long long>(),
                                    WebVector<WebVector<WebIDBKey> >());
 }
 
 TEST_F(IndexedDBDispatcherTest, CursorTransactionId) {
-  const int32 ipc_database_id = -1;
-  const int64 transaction_id = 1234;
-  const int64 object_store_id = 2;
-  const int32 index_id = 3;
+  const int32_t ipc_database_id = -1;
+  const int64_t transaction_id = 1234;
+  const int64_t object_store_id = 2;
+  const int32_t index_id = 3;
   const blink::WebIDBCursorDirection direction =
       blink::WebIDBCursorDirectionNext;
   const bool key_only = false;
 
   MockDispatcher dispatcher(thread_safe_sender_.get());
 
   // First case: successful cursor open.
   {
     scoped_ptr<WebIDBCursor> cursor;
     EXPECT_EQ(0UL, dispatcher.cursor_transaction_ids_.size());
@@ skipping 10 matching lines @@
     // Make a cursor request. This should record the transaction id.
     dispatcher.RequestIDBDatabaseOpenCursor(
         ipc_database_id, transaction_id, object_store_id, index_id,
         IndexedDBKeyRange(), direction, key_only, blink::WebIDBTaskTypeNormal,
         callbacks);
 
     // Verify that the transaction id was captured.
     EXPECT_EQ(1UL, dispatcher.cursor_transaction_ids_.size());
     EXPECT_FALSE(cursor.get());
 
-    int32 ipc_callbacks_id = dispatcher.cursor_transaction_ids_.begin()->first;
+    int32_t ipc_callbacks_id =
+        dispatcher.cursor_transaction_ids_.begin()->first;
 
     IndexedDBMsg_CallbacksSuccessIDBCursor_Params params;
     params.ipc_thread_id = dispatcher.CurrentWorkerId();
     params.ipc_callbacks_id = ipc_callbacks_id;
 
     // Now simululate the cursor response.
     params.ipc_cursor_id = WebIDBCursorImpl::kInvalidCursorId;
     dispatcher.OnSuccessOpenCursor(params);
 
     EXPECT_EQ(0UL, dispatcher.cursor_transaction_ids_.size());
@@ skipping 17 matching lines @@
 
     // Make a cursor request. This should record the transaction id.
     dispatcher.RequestIDBDatabaseOpenCursor(
         ipc_database_id, transaction_id, object_store_id, index_id,
         IndexedDBKeyRange(), direction, key_only, blink::WebIDBTaskTypeNormal,
         callbacks);
 
     // Verify that the transaction id was captured.
     EXPECT_EQ(1UL, dispatcher.cursor_transaction_ids_.size());
 
-    int32 ipc_callbacks_id = dispatcher.cursor_transaction_ids_.begin()->first;
+    int32_t ipc_callbacks_id =
+        dispatcher.cursor_transaction_ids_.begin()->first;
 
     // Now simululate a "null cursor" response.
     IndexedDBMsg_CallbacksSuccessValue_Params params;
     params.ipc_thread_id = dispatcher.CurrentWorkerId();
     params.ipc_callbacks_id = ipc_callbacks_id;
     dispatcher.OnSuccessValue(params);
 
     // Ensure the map result was deleted.
     EXPECT_EQ(0UL, dispatcher.cursor_transaction_ids_.size());
   }
 }
 
 namespace {
 
 class MockCursor : public WebIDBCursorImpl {
  public:
-  MockCursor(int32 ipc_cursor_id,
-             int64 transaction_id,
+  MockCursor(int32_t ipc_cursor_id,
+             int64_t transaction_id,
              ThreadSafeSender* thread_safe_sender)
       : WebIDBCursorImpl(ipc_cursor_id, transaction_id, thread_safe_sender),
         reset_count_(0) {}
 
   // This method is virtual so it can be overridden in unit tests.
   void ResetPrefetchCache() override { ++reset_count_; }
 
   int reset_count() const { return reset_count_; }
 
  private:
   int reset_count_;
 
   DISALLOW_COPY_AND_ASSIGN(MockCursor);
 };
 
 }  // namespace
 
 TEST_F(IndexedDBDispatcherTest, CursorReset) {
   scoped_ptr<WebIDBCursor> cursor;
   MockDispatcher dispatcher(thread_safe_sender_.get());
 
-  const int32 ipc_database_id = 0;
-  const int32 object_store_id = 0;
-  const int32 index_id = 0;
+  const int32_t ipc_database_id = 0;
+  const int32_t object_store_id = 0;
+  const int32_t index_id = 0;
   const bool key_only = false;
   const int cursor1_ipc_id = 1;
   const int cursor2_ipc_id = 2;
   const int other_cursor_ipc_id = 2;
   const int cursor1_transaction_id = 1;
   const int cursor2_transaction_id = 2;
   const int other_transaction_id = 3;
 
   scoped_ptr<MockCursor> cursor1(
       new MockCursor(WebIDBCursorImpl::kInvalidCursorId,
@@ skipping 41 matching lines @@
       other_cursor_ipc_id, cursor1_transaction_id);
 
   EXPECT_EQ(2, cursor1->reset_count());
   EXPECT_EQ(0, cursor2->reset_count());
 
   cursor1.reset();
   cursor2.reset();
 }
 
 }  // namespace content