Switch to standard integer types in content/browser/.

content/browser/indexed_db/indexed_db_browsertest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/thread_test_helper.h"
+#include "build/build_config.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/indexed_db/indexed_db_class_factory.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
 #include "content/browser/indexed_db/mock_browsertest_indexed_db_class_factory.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 86 matching lines @@
   }
 
   void SetQuota(int quota_kilobytes) {
     const int kTemporaryStorageQuotaSize =
         quota_kilobytes * 1024 * QuotaManager::kPerHostTemporaryPortion;
     SetTempQuota(kTemporaryStorageQuotaSize,
         BrowserContext::GetDefaultStoragePartition(
             shell()->web_contents()->GetBrowserContext())->GetQuotaManager());
   }
 
-  static void SetTempQuota(int64 bytes, scoped_refptr<QuotaManager> qm) {
+  static void SetTempQuota(int64_t bytes, scoped_refptr<QuotaManager> qm) {
     if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&IndexedDBBrowserTest::SetTempQuota, bytes, qm));
       return;
     }
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     qm->SetTemporaryGlobalOverrideQuota(bytes, storage::QuotaCallback());
     // Don't return until the quota has been set.
     scoped_refptr<base::ThreadTestHelper> helper(new base::ThreadTestHelper(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB)));
     ASSERT_TRUE(helper->Run());
   }
 
-  virtual int64 RequestDiskUsage() {
+  virtual int64_t RequestDiskUsage() {
     PostTaskAndReplyWithResult(
         GetContext()->TaskRunner(),
         FROM_HERE,
         base::Bind(&IndexedDBContext::GetOriginDiskUsage,
                    GetContext(),
                    GURL("file:///")),
         base::Bind(&IndexedDBBrowserTest::DidGetDiskUsage, this));
     scoped_refptr<base::ThreadTestHelper> helper(new base::ThreadTestHelper(
         BrowserMainLoop::GetInstance()->indexed_db_thread()->task_runner()));
     EXPECT_TRUE(helper->Run());
@@ skipping 20 matching lines @@
   static MockBrowserTestIndexedDBClassFactory* GetTestClassFactory() {
     static ::base::LazyInstance<MockBrowserTestIndexedDBClassFactory>::Leaky
         s_factory = LAZY_INSTANCE_INITIALIZER;
     return s_factory.Pointer();
   }
 
   static IndexedDBClassFactory* GetIDBClassFactory() {
     return GetTestClassFactory();
   }
 
-  virtual void DidGetDiskUsage(int64 bytes) {
-    disk_usage_ = bytes;
-  }
+  virtual void DidGetDiskUsage(int64_t bytes) { disk_usage_ = bytes; }
 
   virtual void DidGetBlobFileCount(int count) { blob_file_count_ = count; }
 
-  int64 disk_usage_;
+  int64_t disk_usage_;
   int blob_file_count_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(IndexedDBBrowserTest);
 };
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest, CursorTest) {
   SimpleTest(GetTestUrl("indexeddb", "cursor_test.html"));
 }
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest, CursorTestIncognito) {
@@ skipping 149 matching lines @@
   SimpleTest(GetTestUrl("indexeddb", "migration_test.html"));
 }
 
 class IndexedDBBrowserTestWithVersion123456Schema : public
     IndexedDBBrowserTestWithPreexistingLevelDB {
   std::string EnclosingLevelDBDir() override { return "schema_version_123456"; }
 };
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTestWithVersion123456Schema,
                        DestroyTest) {
-  int64 original_size = RequestDiskUsage();
+  int64_t original_size = RequestDiskUsage();
   EXPECT_GT(original_size, 0);
   SimpleTest(GetTestUrl("indexeddb", "open_bad_db.html"));
-  int64 new_size = RequestDiskUsage();
+  int64_t new_size = RequestDiskUsage();
   EXPECT_GT(new_size, 0);
   EXPECT_NE(original_size, new_size);
 }
 
 class IndexedDBBrowserTestWithVersion987654SSVData : public
     IndexedDBBrowserTestWithPreexistingLevelDB {
   std::string EnclosingLevelDBDir() override { return "ssv_version_987654"; }
 };
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTestWithVersion987654SSVData,
                        DestroyTest) {
-  int64 original_size = RequestDiskUsage();
+  int64_t original_size = RequestDiskUsage();
   EXPECT_GT(original_size, 0);
   SimpleTest(GetTestUrl("indexeddb", "open_bad_db.html"));
-  int64 new_size = RequestDiskUsage();
+  int64_t new_size = RequestDiskUsage();
   EXPECT_GT(new_size, 0);
   EXPECT_NE(original_size, new_size);
 }
 
 class IndexedDBBrowserTestWithCorruptLevelDB : public
     IndexedDBBrowserTestWithPreexistingLevelDB {
   std::string EnclosingLevelDBDir() override { return "corrupt_leveldb"; }
 };
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTestWithCorruptLevelDB,
                        DestroyTest) {
-  int64 original_size = RequestDiskUsage();
+  int64_t original_size = RequestDiskUsage();
   EXPECT_GT(original_size, 0);
   SimpleTest(GetTestUrl("indexeddb", "open_bad_db.html"));
-  int64 new_size = RequestDiskUsage();
+  int64_t new_size = RequestDiskUsage();
   EXPECT_GT(new_size, 0);
   EXPECT_NE(original_size, new_size);
 }
 
 class IndexedDBBrowserTestWithMissingSSTFile : public
     IndexedDBBrowserTestWithPreexistingLevelDB {
   std::string EnclosingLevelDBDir() override { return "missing_sst"; }
 };
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTestWithMissingSSTFile,
                        DestroyTest) {
-  int64 original_size = RequestDiskUsage();
+  int64_t original_size = RequestDiskUsage();
   EXPECT_GT(original_size, 0);
   SimpleTest(GetTestUrl("indexeddb", "open_missing_table.html"));
-  int64 new_size = RequestDiskUsage();
+  int64_t new_size = RequestDiskUsage();
   EXPECT_GT(new_size, 0);
   EXPECT_NE(original_size, new_size);
 }
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest, LevelDBLogFileTest) {
   // Any page that opens an IndexedDB will work here.
   SimpleTest(GetTestUrl("indexeddb", "database_test.html"));
   base::FilePath leveldb_dir(FILE_PATH_LITERAL("file__0.indexeddb.leveldb"));
   base::FilePath log_file(FILE_PATH_LITERAL("LOG"));
   base::FilePath log_file_path =
       GetContext()->data_path().Append(leveldb_dir).Append(log_file);
-  int64 size;
+  int64_t size;
   EXPECT_TRUE(base::GetFileSize(log_file_path, &size));
   EXPECT_GT(size, 0);
 }
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest, CanDeleteWhenOverQuotaTest) {
   SimpleTest(GetTestUrl("indexeddb", "fill_up_5k.html"));
-  int64 size = RequestDiskUsage();
+  int64_t size = RequestDiskUsage();
   const int kQuotaKilobytes = 2;
   EXPECT_GT(size, kQuotaKilobytes * 1024);
   SetQuota(kQuotaKilobytes);
   SimpleTest(GetTestUrl("indexeddb", "delete_over_quota.html"));
 }
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest, EmptyBlob) {
   // First delete all IDB's for the test origin
   GetContext()->TaskRunner()->PostTask(
       FROM_HERE, base::Bind(&IndexedDBContextImpl::DeleteForOrigin,
@@ skipping 41 matching lines @@
           shell()->web_contents()->GetBrowserContext());
   EXPECT_EQ(0UL, blob_context->context()->blob_count());
 }
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest, BlobsCountAgainstQuota) {
   SimpleTest(GetTestUrl("indexeddb", "blobs_use_quota.html"));
 }
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest, DeleteForOriginDeletesBlobs) {
   SimpleTest(GetTestUrl("indexeddb", "write_20mb_blob.html"));
-  int64 size = RequestDiskUsage();
+  int64_t size = RequestDiskUsage();
   // This assertion assumes that we do not compress blobs.
   EXPECT_GT(size, 20 << 20 /* 20 MB */);
   GetContext()->TaskRunner()->PostTask(
       FROM_HERE, base::Bind(&IndexedDBContextImpl::DeleteForOrigin,
                             GetContext(), GURL("file:///")));
   scoped_refptr<base::ThreadTestHelper> helper(new base::ThreadTestHelper(
       BrowserMainLoop::GetInstance()->indexed_db_thread()->task_runner()));
   ASSERT_TRUE(helper->Run());
   EXPECT_EQ(0, RequestDiskUsage());
 }
@@ skipping 49 matching lines @@
 
   int num_files = 0;
   int num_errors = 0;
   const bool recursive = false;
   for (const base::FilePath& idb_data_path :
        context->GetStoragePaths(origin_url)) {
     base::FileEnumerator enumerator(
         idb_data_path, recursive, base::FileEnumerator::FILES);
     for (base::FilePath idb_file = enumerator.Next(); !idb_file.empty();
          idb_file = enumerator.Next()) {
-      int64 size(0);
+      int64_t size(0);
       GetFileSize(idb_file, &size);
 
       if (idb_file.Extension() == FILE_PATH_LITERAL(".ldb")) {
         num_files++;
         base::File file(
             idb_file, base::File::FLAG_WRITE | base::File::FLAG_OPEN_TRUNCATED);
         if (file.IsValid()) {
           // Was opened truncated, expand back to the original
           // file size and fill with zeros (corrupting the file).
           file.SetLength(size);
@@ skipping 152 matching lines @@
                                           "getAll",
                                           "failWebkitGetDatabaseNames",
                                           "iterate",
                                           "failTransactionCommit",
                                           "clearObjectStore"));
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest,
                        DeleteCompactsBackingStore) {
   const GURL test_url = GetTestUrl("indexeddb", "delete_compact.html");
   SimpleTest(GURL(test_url.spec() + "#fill"));
-  int64 after_filling = RequestDiskUsage();
+  int64_t after_filling = RequestDiskUsage();
   EXPECT_GT(after_filling, 0);
 
   SimpleTest(GURL(test_url.spec() + "#purge"));
-  int64 after_deleting = RequestDiskUsage();
+  int64_t after_deleting = RequestDiskUsage();
   EXPECT_LT(after_deleting, after_filling);
 
   // The above tests verify basic assertions - that filling writes data and
   // deleting reduces the amount stored.
 
   // The below tests make assumptions about implementation specifics, such as
   // data compression, compaction efficiency, and the maximum amount of
   // metadata and log data remains after a deletion. It is possible that
   // changes to the implementation may require these constants to be tweaked.
 
@@ skipping 101 matching lines @@
     command_line->AppendSwitch(switches::kSingleProcess);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTestSingleProcess,
                        RenderThreadShutdownTest) {
   SimpleTest(GetTestUrl("indexeddb", "shutdown_with_requests.html"));
 }
 
 }  // namespace content