Switch to standard integer types in base/trace_event/.

base/trace_event/memory_dump_manager_unittest.cc

 // Copyright 2015 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/trace_event/memory_dump_manager.h"
 
+#include <stdint.h>
+
 #include <vector>
 
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_io_thread.h"
 #include "base/test/trace_event_analyzer.h"
@@ skipping 59 matching lines @@
   MemoryDumpManagerDelegateForTesting() {
     ON_CALL(*this, RequestGlobalMemoryDump(_, _))
         .WillByDefault(Invoke(
             this, &MemoryDumpManagerDelegateForTesting::CreateProcessDump));
   }
 
   MOCK_METHOD2(RequestGlobalMemoryDump,
                void(const MemoryDumpRequestArgs& args,
                     const MemoryDumpCallback& callback));
 
-  uint64 GetTracingProcessId() const override {
+  uint64_t GetTracingProcessId() const override {
     NOTREACHED();
     return MemoryDumpManager::kInvalidTracingProcessId;
   }
 };
 
 class MockMemoryDumpProvider : public MemoryDumpProvider {
  public:
   MOCK_METHOD2(OnMemoryDump,
                bool(const MemoryDumpArgs& args, ProcessMemoryDump* pmd));
 };
@@ skipping 16 matching lines @@
     mdm_.reset();
     delegate_.reset();
     message_loop_.reset();
     TraceLog::DeleteForTesting();
   }
 
   // Turns a Closure into a MemoryDumpCallback, keeping track of the callback
   // result and taking care of posting the closure on the correct task runner.
   void DumpCallbackAdapter(scoped_refptr<SingleThreadTaskRunner> task_runner,
                            Closure closure,
-                           uint64 dump_guid,
+                           uint64_t dump_guid,
                            bool success) {
     last_callback_success_ = success;
     task_runner->PostTask(FROM_HERE, closure);
   }
 
  protected:
   void InitializeMemoryDumpManager(bool is_coordinator) {
     mdm_->set_dumper_registrations_ignored_for_testing(true);
     mdm_->Initialize(delegate_.get(), is_coordinator);
   }
@@ skipping 232 matching lines @@
     DisableTracing();
   }
 }
 
 // Checks that the MemoryDumpManager respects the thread affinity when a
 // MemoryDumpProvider specifies a task_runner(). The test starts creating 8
 // threads and registering a MemoryDumpProvider on each of them. At each
 // iteration, one thread is removed, to check the live unregistration logic.
 TEST_F(MemoryDumpManagerTest, RespectTaskRunnerAffinity) {
   InitializeMemoryDumpManager(false /* is_coordinator */);
-  const uint32 kNumInitialThreads = 8;
+  const uint32_t kNumInitialThreads = 8;
 
   std::vector<scoped_ptr<Thread>> threads;
   std::vector<scoped_ptr<MockMemoryDumpProvider>> mdps;
 
   // Create the threads and setup the expectations. Given that at each iteration
   // we will pop out one thread/MemoryDumpProvider, each MDP is supposed to be
   // invoked a number of times equal to its index.
-  for (uint32 i = kNumInitialThreads; i > 0; --i) {
+  for (uint32_t i = kNumInitialThreads; i > 0; --i) {
     threads.push_back(make_scoped_ptr(new Thread("test thread")));
     auto thread = threads.back().get();
     thread->Start();
     scoped_refptr<SingleThreadTaskRunner> task_runner = thread->task_runner();
     mdps.push_back(make_scoped_ptr(new MockMemoryDumpProvider()));
     auto mdp = mdps.back().get();
     RegisterDumpProvider(mdp, task_runner, kDefaultOptions);
     EXPECT_CALL(*mdp, OnMemoryDump(_, _))
         .Times(i)
         .WillRepeatedly(Invoke(
@@ skipping 475 matching lines @@
   ASSERT_EQ(1u, trace_analyzer::CountMatches(events, Query::EventPidIs(123)));
   ASSERT_EQ(1u, trace_analyzer::CountMatches(events, Query::EventPidIs(456)));
   ASSERT_EQ(1u, trace_analyzer::CountMatches(
                     events, Query::EventPidIs(GetCurrentProcId())));
   ASSERT_EQ(events[0]->id, events[1]->id);
   ASSERT_EQ(events[0]->id, events[2]->id);
 }
 
 }  // namespace trace_event
 }  // namespace base