Remove all uses of GG_LONGLONG and GG_ULONGLONG.

base/allocator/allocator_unittest.cc

 // Copyright 2014 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 <stdio.h>
 #include <stdlib.h>
 #include <algorithm>   // for min()
+
 #include "base/atomicops.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Number of bits in a size_t.
 static const int kSizeBits = 8 * sizeof(size_t);
 // The maximum size of a size_t.
 static const size_t kMaxSize = ~static_cast<size_t>(0);
 // Maximum positive size of a size_t if it were signed.
 static const size_t kMaxSignedSize = ((size_t(1) << (kSizeBits-1)) - 1);
 // An allocation size which is not too big to be reasonable.
@@ skipping 56 matching lines @@
     if (size == power-1)
       return power;
 
     assert(size == power);
     return power+1;
   } else {
     return -1;
   }
 }
 
-#define GG_ULONGLONG(x)  static_cast<uint64>(x)
-
 template <class AtomicType>
 static void TestAtomicIncrement() {
   // For now, we just test single threaded execution
 
   // use a guard value to make sure the NoBarrier_AtomicIncrement doesn't go
   // outside the expected address bounds.  This is in particular to
   // test that some future change to the asm code doesn't cause the
   // 32-bit NoBarrier_AtomicIncrement to do the wrong thing on 64-bit machines.
   struct {
     AtomicType prev_word;
@@ skipping 61 matching lines @@
 
 template <class AtomicType>
 static void TestCompareAndSwap() {
   AtomicType value = 0;
   AtomicType prev = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 1);
   EXPECT_EQ(1, value);
   EXPECT_EQ(0, prev);
 
   // Use test value that has non-zero bits in both halves, more for testing
   // 64-bit implementation on 32-bit platforms.
-  const AtomicType k_test_val = (GG_ULONGLONG(1) <<
+  const AtomicType k_test_val = (static_cast<uint64_t>(1) <<
                                  (NUM_BITS(AtomicType) - 2)) + 11;
   value = k_test_val;
   prev = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 5);
   EXPECT_EQ(k_test_val, value);
   EXPECT_EQ(k_test_val, prev);
 
   value = k_test_val;
   prev = base::subtle::NoBarrier_CompareAndSwap(&value, k_test_val, 5);
   EXPECT_EQ(5, value);
   EXPECT_EQ(k_test_val, prev);
 }
 
 
 template <class AtomicType>
 static void TestAtomicExchange() {
   AtomicType value = 0;
   AtomicType new_value = base::subtle::NoBarrier_AtomicExchange(&value, 1);
   EXPECT_EQ(1, value);
   EXPECT_EQ(0, new_value);
 
   // Use test value that has non-zero bits in both halves, more for testing
   // 64-bit implementation on 32-bit platforms.
-  const AtomicType k_test_val = (GG_ULONGLONG(1) <<
+  const AtomicType k_test_val = (static_cast<uint64_t>(1) <<
                                  (NUM_BITS(AtomicType) - 2)) + 11;
   value = k_test_val;
   new_value = base::subtle::NoBarrier_AtomicExchange(&value, k_test_val);
   EXPECT_EQ(k_test_val, value);
   EXPECT_EQ(k_test_val, new_value);
 
   value = k_test_val;
   new_value = base::subtle::NoBarrier_AtomicExchange(&value, 5);
   EXPECT_EQ(5, value);
   EXPECT_EQ(k_test_val, new_value);
 }
 
 
 template <class AtomicType>
 static void TestAtomicIncrementBounds() {
   // Test increment at the half-width boundary of the atomic type.
   // It is primarily for testing at the 32-bit boundary for 64-bit atomic type.
-  AtomicType test_val = GG_ULONGLONG(1) << (NUM_BITS(AtomicType) / 2);
+  AtomicType test_val = static_cast<uint64_t>(1) << (NUM_BITS(AtomicType) / 2);
   AtomicType value = test_val - 1;
   AtomicType new_value = base::subtle::NoBarrier_AtomicIncrement(&value, 1);
   EXPECT_EQ(test_val, value);
   EXPECT_EQ(value, new_value);
 
   base::subtle::NoBarrier_AtomicIncrement(&value, -1);
   EXPECT_EQ(test_val - 1, value);
 }
 
 // This is a simple sanity check that values are correct. Not testing
@@ skipping 293 matching lines @@
   }
 }
 
 #endif
 
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }