Switch to standard integer types in components/, part 4 of 4.

components/tracing/child_trace_message_filter_browsertest.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 <stdint.h>
+
 #include "base/callback.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/trace_event.h"
 #include "components/tracing/child_memory_dump_manager_delegate_impl.h"
 #include "components/tracing/child_trace_message_filter.h"
 #include "components/tracing/tracing_messages.h"
 #include "content/public/test/render_view_test.h"
@@ skipping 14 matching lines @@
 class MockDumpProvider : public base::trace_event::MemoryDumpProvider {
  public:
   MOCK_METHOD2(OnMemoryDump,
                bool(const MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd));
 };
 
 class ChildTracingTest : public content::RenderViewTest, public IPC::Listener {
  public:
   // Used as callback argument for MemoryDumpManager::RequestGlobalDump():
-  void OnMemoryDumpCallback(uint64 dump_guid, bool status) {
+  void OnMemoryDumpCallback(uint64_t dump_guid, bool status) {
     last_callback_dump_guid_ = dump_guid;
     last_callback_status_ = status;
     ++callback_call_count_;
   }
 
  protected:
   void SetUp() override {
     // RenderViewTest::SetUp causes additional registrations, so we first
     // register the mock dump provider and ignore registrations from then on.
     // In addition to the mock dump provider, the TraceLog has already
@@ skipping 67 matching lines @@
     TracingMsg_BeginTracing msg(trace_config.ToString(), base::TimeTicks(), 0);
     SimulateSyntheticMessageFromBrowser(msg);
   }
 
   void DisableTracing() {
     SimulateSyntheticMessageFromBrowser(TracingMsg_EndTracing());
   }
 
   // Simulates a synthetic browser -> child process memory dump request and
   // checks that the child actually sends a response to that.
-  void RequestProcessMemoryDumpAndCheckResponse(uint64 dump_guid) {
+  void RequestProcessMemoryDumpAndCheckResponse(uint64_t dump_guid) {
     SimulateSyntheticMessageFromBrowser(TracingMsg_ProcessMemoryDumpRequest(
         {dump_guid, MemoryDumpType::EXPLICITLY_TRIGGERED}));
 
     // Check that a child -> browser response to the local dump request is sent.
     const IPC::Message* msg =
         WaitForIPCMessage(TracingHostMsg_ProcessMemoryDumpResponse::ID);
     EXPECT_NE(nullptr, msg);
 
     // Check that the |dump_guid| and the |success| fields are properly set.
     TracingHostMsg_ProcessMemoryDumpResponse::Param params;
     TracingHostMsg_ProcessMemoryDumpResponse::Read(msg, &params);
-    const uint64 resp_guid = base::get<0>(params);
+    const uint64_t resp_guid = base::get<0>(params);
     const bool resp_success = base::get<1>(params);
     EXPECT_EQ(dump_guid, resp_guid);
     EXPECT_TRUE(resp_success);
   }
 
   // Retrieves the MemoryDumpRequestArgs of the global memory dump request that
   // this child process tried to send to the browser. Fails if either none or
   // multiple requests were sent.
   MemoryDumpRequestArgs GetInterceptedGlobalMemoryDumpRequest() {
     const IPC::Message* msg = render_thread_->sink().GetUniqueMessageMatching(
         TracingHostMsg_GlobalMemoryDumpRequest::ID);
     EXPECT_NE(nullptr, msg);
     TracingHostMsg_GlobalMemoryDumpRequest::Param params;
     TracingHostMsg_GlobalMemoryDumpRequest::Read(msg, &params);
     MemoryDumpRequestArgs args = base::get<0>(params);
     EXPECT_NE(0U, args.dump_guid);
     return args;
   }
 
   scoped_refptr<ChildTraceMessageFilter> ctmf_;
   scoped_ptr<MockDumpProvider> mock_dump_provider_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   base::trace_event::MemoryDumpCallback callback_;
   uint32_t wait_for_ipc_message_type_;
   base::Closure wait_for_ipc_closure_;
-  uint32 callback_call_count_;
-  uint64 last_callback_dump_guid_;
+  uint32_t callback_call_count_;
+  uint64_t last_callback_dump_guid_;
   bool last_callback_status_;
 };
 
 // Covers the case of some browser-initiated memory dumps.
 TEST_F(ChildTracingTest, BrowserInitiatedMemoryDumps) {
-  const uint32 kNumDumps = 3;
+  const uint32_t kNumDumps = 3;
 
   EnableTracingWithMemoryDumps();
   EXPECT_CALL(*mock_dump_provider_, OnMemoryDump(_, _))
       .Times(kNumDumps)
       .WillRepeatedly(Return(true));
 
-  for (uint32 i = 0; i < kNumDumps; ++i) {
+  for (uint32_t i = 0; i < kNumDumps; ++i) {
     render_thread_->sink().ClearMessages();
     RequestProcessMemoryDumpAndCheckResponse(i + 1);
   }
 
   DisableTracing();
 }
 
 // Covers the case of one simple child-initiated memory dump without callback,
 // simulating a global memory dump request to the browser (+ response).
 TEST_F(ChildTracingTest, SingleChildInitiatedMemoryDump) {
@@ skipping 77 matching lines @@
   EXPECT_EQ(2u, callback_call_count_);
   EXPECT_EQ(args.dump_guid, last_callback_dump_guid_);
   EXPECT_TRUE(last_callback_status_);
 
   DisableTracing();
 }
 
 // Covers the case of five child-initiated global memory dumps. Each global dump
 // request has a callback, which is expected to fail for 3 out of 5 cases.
 TEST_F(ChildTracingTest, MultipleChildInitiatedMemoryDumpWithFailures) {
-  const uint32 kNumRequests = 5;
+  const uint32_t kNumRequests = 5;
   MemoryDumpType kDumpType = MemoryDumpType::EXPLICITLY_TRIGGERED;
 
   EnableTracingWithMemoryDumps();
   EXPECT_CALL(*mock_dump_provider_, OnMemoryDump(_, _))
       .Times(kNumRequests)
       .WillRepeatedly(Return(true));
 
-  for (uint32 i = 0; i < kNumRequests; ++i) {
+  for (uint32_t i = 0; i < kNumRequests; ++i) {
     render_thread_->sink().ClearMessages();
     MemoryDumpManager::GetInstance()->RequestGlobalDump(
         kDumpType, MemoryDumpLevelOfDetail::DETAILED, callback_);
     base::RunLoop().RunUntilIdle();
 
     MemoryDumpRequestArgs args = GetInterceptedGlobalMemoryDumpRequest();
     EXPECT_EQ(kDumpType, args.dump_type);
     RequestProcessMemoryDumpAndCheckResponse(args.dump_guid);
 
     const bool success = (i & 1) ? true : false;
     SimulateSyntheticMessageFromBrowser(
         TracingMsg_GlobalMemoryDumpResponse(args.dump_guid, success));
     EXPECT_EQ(i + 1, callback_call_count_);
     EXPECT_EQ(args.dump_guid, last_callback_dump_guid_);
     EXPECT_EQ(success, last_callback_status_);
   }
 
   DisableTracing();
 }
 
 }  // namespace tracing