Remove all uses of GG_LONGLONG and GG_ULONGLONG.

base/atomicops_unittest.cc

 // Copyright (c) 2011 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/atomicops.h"
 
+#include <stdint.h>
 #include <string.h>
 
-#include "base/port.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 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 doesn't do the wrong thing on 64-bit
@@ skipping 64 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 at rollover boundary between int_max and int_min
-  AtomicType test_val = (GG_ULONGLONG(1) <<
+  AtomicType test_val = (static_cast<uint64_t>(1) <<
                          (NUM_BITS(AtomicType) - 1));
   AtomicType value = -1 ^ test_val;
   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(-1 ^ test_val, value);
 
   // Test at 32-bit boundary for 64-bit atomic type.
-  test_val = GG_ULONGLONG(1) << (NUM_BITS(AtomicType) / 2);
+  test_val = static_cast<uint64_t>(1) << (NUM_BITS(AtomicType) / 2);
   value = test_val - 1;
   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);
 }
 
 // Return an AtomicType with the value 0xa5a5a5..
@@ skipping 76 matching lines @@
 
 TEST(AtomicOpsTest, Store) {
   TestStore<base::subtle::Atomic32>();
   TestStore<base::subtle::AtomicWord>();
 }
 
 TEST(AtomicOpsTest, Load) {
   TestLoad<base::subtle::Atomic32>();
   TestLoad<base::subtle::AtomicWord>();
 }