Switch to standard integer types in jingle/.

BUG=138542
TBR=zea@chromium.org

Review URL: https://codereview.chromium.org/1544473003

Cr-Commit-Position: refs/heads/master@{#366518}

18 files changed, 119 insertions, 80 deletions

diff --git a/jingle/glue/chrome_async_socket.cc b/jingle/glue/chrome_async_socket.cc
index dc42e7e..6509f4c 100644
--- a/jingle/glue/chrome_async_socket.cc
+++ b/jingle/glue/chrome_async_socket.cc
@@ -4,11 +4,12 @@
 
 #include "jingle/glue/chrome_async_socket.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 #include <cstdlib>
 #include <cstring>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
diff --git a/jingle/glue/chrome_async_socket.h b/jingle/glue/chrome_async_socket.h
index 3ce97a4..cad4295 100644
--- a/jingle/glue/chrome_async_socket.h
+++ b/jingle/glue/chrome_async_socket.h
@@ -11,11 +11,13 @@
 #error ChromeAsyncSocket expects FEATURE_ENABLE_SSL to be defined
 #endif
 
+#include <stddef.h>
+
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
diff --git a/jingle/glue/chrome_async_socket_unittest.cc b/jingle/glue/chrome_async_socket_unittest.cc
index a785553..79fdb68 100644
--- a/jingle/glue/chrome_async_socket_unittest.cc
+++ b/jingle/glue/chrome_async_socket_unittest.cc
@@ -4,11 +4,13 @@
 
 #include "jingle/glue/chrome_async_socket.h"
 
+#include <stddef.h>
+
 #include <deque>
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_pump_default.h"
diff --git a/jingle/glue/fake_ssl_client_socket.cc b/jingle/glue/fake_ssl_client_socket.cc
index 58f1164..3284f8c 100644
--- a/jingle/glue/fake_ssl_client_socket.cc
+++ b/jingle/glue/fake_ssl_client_socket.cc
@@ -4,11 +4,14 @@
 
 #include "jingle/glue/fake_ssl_client_socket.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <cstdlib>
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
@@ -23,41 +26,41 @@ namespace {
 // This is a SSL v2 CLIENT_HELLO message.
 // TODO(juberti): Should this have a session id? The response doesn't have a
 // certificate, so the hello should have a session id.
-static const uint8 kSslClientHello[] = {
-  0x80, 0x46,                                            // msg len
-  0x01,                                                  // CLIENT_HELLO
-  0x03, 0x01,                                            // SSL 3.1
-  0x00, 0x2d,                                            // ciphersuite len
-  0x00, 0x00,                                            // session id len
-  0x00, 0x10,                                            // challenge len
-  0x01, 0x00, 0x80, 0x03, 0x00, 0x80, 0x07, 0x00, 0xc0,  // ciphersuites
-  0x06, 0x00, 0x40, 0x02, 0x00, 0x80, 0x04, 0x00, 0x80,  //
-  0x00, 0x00, 0x04, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x0a,  //
-  0x00, 0xfe, 0xfe, 0x00, 0x00, 0x09, 0x00, 0x00, 0x64,  //
-  0x00, 0x00, 0x62, 0x00, 0x00, 0x03, 0x00, 0x00, 0x06,  //
-  0x1f, 0x17, 0x0c, 0xa6, 0x2f, 0x00, 0x78, 0xfc,        // challenge
-  0x46, 0x55, 0x2e, 0xb1, 0x83, 0x39, 0xf1, 0xea         //
+static const uint8_t kSslClientHello[] = {
+    0x80, 0x46,                                            // msg len
+    0x01,                                                  // CLIENT_HELLO
+    0x03, 0x01,                                            // SSL 3.1
+    0x00, 0x2d,                                            // ciphersuite len
+    0x00, 0x00,                                            // session id len
+    0x00, 0x10,                                            // challenge len
+    0x01, 0x00, 0x80, 0x03, 0x00, 0x80, 0x07, 0x00, 0xc0,  // ciphersuites
+    0x06, 0x00, 0x40, 0x02, 0x00, 0x80, 0x04, 0x00, 0x80,  //
+    0x00, 0x00, 0x04, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x0a,  //
+    0x00, 0xfe, 0xfe, 0x00, 0x00, 0x09, 0x00, 0x00, 0x64,  //
+    0x00, 0x00, 0x62, 0x00, 0x00, 0x03, 0x00, 0x00, 0x06,  //
+    0x1f, 0x17, 0x0c, 0xa6, 0x2f, 0x00, 0x78, 0xfc,        // challenge
+    0x46, 0x55, 0x2e, 0xb1, 0x83, 0x39, 0xf1, 0xea         //
 };
 
 // This is a TLSv1 SERVER_HELLO message.
-static const uint8 kSslServerHello[] = {
-  0x16,                                            // handshake message
-  0x03, 0x01,                                      // SSL 3.1
-  0x00, 0x4a,                                      // message len
-  0x02,                                            // SERVER_HELLO
-  0x00, 0x00, 0x46,                                // handshake len
-  0x03, 0x01,                                      // SSL 3.1
-  0x42, 0x85, 0x45, 0xa7, 0x27, 0xa9, 0x5d, 0xa0,  // server random
-  0xb3, 0xc5, 0xe7, 0x53, 0xda, 0x48, 0x2b, 0x3f,  //
-  0xc6, 0x5a, 0xca, 0x89, 0xc1, 0x58, 0x52, 0xa1,  //
-  0x78, 0x3c, 0x5b, 0x17, 0x46, 0x00, 0x85, 0x3f,  //
-  0x20,                                            // session id len
-  0x0e, 0xd3, 0x06, 0x72, 0x5b, 0x5b, 0x1b, 0x5f,  // session id
-  0x15, 0xac, 0x13, 0xf9, 0x88, 0x53, 0x9d, 0x9b,  //
-  0xe8, 0x3d, 0x7b, 0x0c, 0x30, 0x32, 0x6e, 0x38,  //
-  0x4d, 0xa2, 0x75, 0x57, 0x41, 0x6c, 0x34, 0x5c,  //
-  0x00, 0x04,                                      // RSA/RC4-128/MD5
-  0x00                                             // null compression
+static const uint8_t kSslServerHello[] = {
+    0x16,                                            // handshake message
+    0x03, 0x01,                                      // SSL 3.1
+    0x00, 0x4a,                                      // message len
+    0x02,                                            // SERVER_HELLO
+    0x00, 0x00, 0x46,                                // handshake len
+    0x03, 0x01,                                      // SSL 3.1
+    0x42, 0x85, 0x45, 0xa7, 0x27, 0xa9, 0x5d, 0xa0,  // server random
+    0xb3, 0xc5, 0xe7, 0x53, 0xda, 0x48, 0x2b, 0x3f,  //
+    0xc6, 0x5a, 0xca, 0x89, 0xc1, 0x58, 0x52, 0xa1,  //
+    0x78, 0x3c, 0x5b, 0x17, 0x46, 0x00, 0x85, 0x3f,  //
+    0x20,                                            // session id len
+    0x0e, 0xd3, 0x06, 0x72, 0x5b, 0x5b, 0x1b, 0x5f,  // session id
+    0x15, 0xac, 0x13, 0xf9, 0x88, 0x53, 0x9d, 0x9b,  //
+    0xe8, 0x3d, 0x7b, 0x0c, 0x30, 0x32, 0x6e, 0x38,  //
+    0x4d, 0xa2, 0x75, 0x57, 0x41, 0x6c, 0x34, 0x5c,  //
+    0x00, 0x04,                                      // RSA/RC4-128/MD5
+    0x00                                             // null compression
 };
 
 net::DrainableIOBuffer* NewDrainableIOBufferWithSize(int size) {
@@ -103,11 +106,11 @@ int FakeSSLClientSocket::Write(net::IOBuffer* buf, int buf_len,
   return transport_socket_->Write(buf, buf_len, callback);
 }
 
-int FakeSSLClientSocket::SetReceiveBufferSize(int32 size) {
+int FakeSSLClientSocket::SetReceiveBufferSize(int32_t size) {
   return transport_socket_->SetReceiveBufferSize(size);
 }
 
-int FakeSSLClientSocket::SetSendBufferSize(int32 size) {
+int FakeSSLClientSocket::SetSendBufferSize(int32_t size) {
   return transport_socket_->SetSendBufferSize(size);
 }
 
@@ -271,7 +274,7 @@ net::Error FakeSSLClientSocket::ProcessVerifyServerHelloDone(size_t read) {
   if (read == 0U) {
     return net::ERR_UNEXPECTED;
   }
-  const uint8* expected_data_start =
+  const uint8_t* expected_data_start =
       &kSslServerHello[arraysize(kSslServerHello) -
                        read_buf_->BytesRemaining()];
   if (std::memcmp(expected_data_start, read_buf_->data(), read) != 0) {
diff --git a/jingle/glue/fake_ssl_client_socket.h b/jingle/glue/fake_ssl_client_socket.h
index c6a41c2..5bd4a0d 100644
--- a/jingle/glue/fake_ssl_client_socket.h
+++ b/jingle/glue/fake_ssl_client_socket.h
@@ -20,7 +20,6 @@
 
 #include <cstddef>
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ -53,8 +52,8 @@ class FakeSSLClientSocket : public net::StreamSocket {
   int Write(net::IOBuffer* buf,
             int buf_len,
             const net::CompletionCallback& callback) override;
-  int SetReceiveBufferSize(int32 size) override;
-  int SetSendBufferSize(int32 size) override;
+  int SetReceiveBufferSize(int32_t size) override;
+  int SetSendBufferSize(int32_t size) override;
   int Connect(const net::CompletionCallback& callback) override;
   void Disconnect() override;
   bool IsConnected() const override;
diff --git a/jingle/glue/fake_ssl_client_socket_unittest.cc b/jingle/glue/fake_ssl_client_socket_unittest.cc
index 4d7165d..c3d64fd 100644
--- a/jingle/glue/fake_ssl_client_socket_unittest.cc
+++ b/jingle/glue/fake_ssl_client_socket_unittest.cc
@@ -4,10 +4,13 @@
 
 #include "jingle/glue/fake_ssl_client_socket.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <vector>
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ -50,8 +53,8 @@ class MockClientSocket : public net::StreamSocket {
                          const net::CompletionCallback&));
   MOCK_METHOD3(Write, int(net::IOBuffer*, int,
                           const net::CompletionCallback&));
-  MOCK_METHOD1(SetReceiveBufferSize, int(int32));
-  MOCK_METHOD1(SetSendBufferSize, int(int32));
+  MOCK_METHOD1(SetReceiveBufferSize, int(int32_t));
+  MOCK_METHOD1(SetSendBufferSize, int(int32_t));
   MOCK_METHOD1(Connect, int(const net::CompletionCallback&));
   MOCK_METHOD0(Disconnect, void());
   MOCK_CONST_METHOD0(IsConnected, bool());
@@ -63,7 +66,7 @@ class MockClientSocket : public net::StreamSocket {
   MOCK_METHOD0(SetOmniboxSpeculation, void());
   MOCK_CONST_METHOD0(WasEverUsed, bool());
   MOCK_CONST_METHOD0(UsingTCPFastOpen, bool());
-  MOCK_CONST_METHOD0(NumBytesRead, int64());
+  MOCK_CONST_METHOD0(NumBytesRead, int64_t());
   MOCK_CONST_METHOD0(GetConnectTimeMicros, base::TimeDelta());
   MOCK_CONST_METHOD0(WasNpnNegotiated, bool());
   MOCK_CONST_METHOD0(GetNegotiatedProtocol, net::NextProto());
diff --git a/jingle/glue/jingle_glue_mock_objects.h b/jingle/glue/jingle_glue_mock_objects.h
index f34e6b0..0e65847f 100644
--- a/jingle/glue/jingle_glue_mock_objects.h
+++ b/jingle/glue/jingle_glue_mock_objects.h
@@ -5,6 +5,8 @@
 #ifndef JINGLE_GLUE_JINGLE_GLUE_MOCK_OBJECTS_H_
 #define JINGLE_GLUE_JINGLE_GLUE_MOCK_OBJECTS_H_
 
+#include <stddef.h>
+
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/webrtc/base/stream.h"
 
diff --git a/jingle/glue/logging_unittest.cc b/jingle/glue/logging_unittest.cc
index a5613f7..fc36f52 100644
--- a/jingle/glue/logging_unittest.cc
+++ b/jingle/glue/logging_unittest.cc
@@ -17,6 +17,7 @@
 // libjingle style logging is used.
 #define LOGGING_INSIDE_WEBRTC
 
+#include "build/build_config.h"
 #include "third_party/webrtc_overrides/webrtc/base/logging.h"
 
 #if defined(OS_WIN)
diff --git a/jingle/glue/proxy_resolving_client_socket.cc b/jingle/glue/proxy_resolving_client_socket.cc
index dc5608b..ae256144 100644
--- a/jingle/glue/proxy_resolving_client_socket.cc
+++ b/jingle/glue/proxy_resolving_client_socket.cc
@@ -4,7 +4,8 @@
 
 #include "jingle/glue/proxy_resolving_client_socket.h"
 
-#include "base/basictypes.h"
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
@@ -115,14 +116,14 @@ int ProxyResolvingClientSocket::Write(
   return net::ERR_SOCKET_NOT_CONNECTED;
 }
 
-int ProxyResolvingClientSocket::SetReceiveBufferSize(int32 size) {
+int ProxyResolvingClientSocket::SetReceiveBufferSize(int32_t size) {
   if (transport_.get() && transport_->socket())
     return transport_->socket()->SetReceiveBufferSize(size);
   NOTREACHED();
   return net::ERR_SOCKET_NOT_CONNECTED;
 }
 
-int ProxyResolvingClientSocket::SetSendBufferSize(int32 size) {
+int ProxyResolvingClientSocket::SetSendBufferSize(int32_t size) {
   if (transport_.get() && transport_->socket())
     return transport_->socket()->SetSendBufferSize(size);
   NOTREACHED();
diff --git a/jingle/glue/proxy_resolving_client_socket.h b/jingle/glue/proxy_resolving_client_socket.h
index 7d76778..4e3af23 100644
--- a/jingle/glue/proxy_resolving_client_socket.h
+++ b/jingle/glue/proxy_resolving_client_socket.h
@@ -10,8 +10,8 @@
 
 #include <stdint.h>
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "net/base/completion_callback.h"
@@ -56,8 +56,8 @@ class ProxyResolvingClientSocket : public net::StreamSocket {
   int Write(net::IOBuffer* buf,
             int buf_len,
             const net::CompletionCallback& callback) override;
-  int SetReceiveBufferSize(int32 size) override;
-  int SetSendBufferSize(int32 size) override;
+  int SetReceiveBufferSize(int32_t size) override;
+  int SetSendBufferSize(int32_t size) override;
   int Connect(const net::CompletionCallback& callback) override;
   void Disconnect() override;
   bool IsConnected() const override;
diff --git a/jingle/glue/proxy_resolving_client_socket_unittest.cc b/jingle/glue/proxy_resolving_client_socket_unittest.cc
index 1166f0d..bdd0305 100644
--- a/jingle/glue/proxy_resolving_client_socket_unittest.cc
+++ b/jingle/glue/proxy_resolving_client_socket_unittest.cc
@@ -4,8 +4,8 @@
 
 #include "jingle/glue/proxy_resolving_client_socket.h"
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/test_completion_callback.h"
diff --git a/jingle/glue/task_pump.cc b/jingle/glue/task_pump.cc
index 3c0ddaa..f2c769d 100644
--- a/jingle/glue/task_pump.cc
+++ b/jingle/glue/task_pump.cc
@@ -2,6 +2,8 @@
 // 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/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "jingle/glue/task_pump.h"
@@ -31,7 +33,7 @@ void TaskPump::WakeTasks() {
   }
 }
 
-int64 TaskPump::CurrentTime() {
+int64_t TaskPump::CurrentTime() {
   DCHECK(CalledOnValidThread());
   // Only timeout tasks rely on this function.  Since we're not using
   // libjingle tasks for timeout, it's safe to return 0 here.
diff --git a/jingle/glue/task_pump.h b/jingle/glue/task_pump.h
index b102605..7d46acd 100644
--- a/jingle/glue/task_pump.h
+++ b/jingle/glue/task_pump.h
@@ -5,7 +5,10 @@
 #ifndef JINGLE_GLUE_TASK_PUMP_H_
 #define JINGLE_GLUE_TASK_PUMP_H_
 
+#include <stdint.h>
+
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "third_party/webrtc/base/taskrunner.h"
@@ -21,7 +24,7 @@ class TaskPump : public rtc::TaskRunner, public base::NonThreadSafe {
 
   // rtc::TaskRunner implementation.
   void WakeTasks() override;
-  int64 CurrentTime() override;
+  int64_t CurrentTime() override;
 
   // No tasks will be processed after this is called, even if
   // WakeTasks() is called.
diff --git a/jingle/glue/thread_wrapper.cc b/jingle/glue/thread_wrapper.cc
index f74fbb3..b035dbe 100644
--- a/jingle/glue/thread_wrapper.cc
+++ b/jingle/glue/thread_wrapper.cc
@@ -4,9 +4,13 @@
 
 #include "jingle/glue/thread_wrapper.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
+#include "base/macros.h"
 #include "base/threading/thread_local.h"
 #include "third_party/webrtc/base/nullsocketserver.h"
 
@@ -85,19 +89,22 @@ void JingleThreadWrapper::WillDestroyCurrentMessageLoop() {
   delete this;
 }
 
-void JingleThreadWrapper::Post(
-    rtc::MessageHandler* handler, uint32 message_id,
-    rtc::MessageData* data, bool time_sensitive) {
+void JingleThreadWrapper::Post(rtc::MessageHandler* handler,
+                               uint32_t message_id,
+                               rtc::MessageData* data,
+                               bool time_sensitive) {
   PostTaskInternal(0, handler, message_id, data);
 }
 
-void JingleThreadWrapper::PostDelayed(
-    int delay_ms, rtc::MessageHandler* handler,
-    uint32 message_id, rtc::MessageData* data) {
+void JingleThreadWrapper::PostDelayed(int delay_ms,
+                                      rtc::MessageHandler* handler,
+                                      uint32_t message_id,
+                                      rtc::MessageData* data) {
   PostTaskInternal(delay_ms, handler, message_id, data);
 }
 
-void JingleThreadWrapper::Clear(rtc::MessageHandler* handler, uint32 id,
+void JingleThreadWrapper::Clear(rtc::MessageHandler* handler,
+                                uint32_t id,
                                 rtc::MessageList* removed) {
   base::AutoLock auto_lock(lock_);
 
@@ -137,8 +144,9 @@ void JingleThreadWrapper::Clear(rtc::MessageHandler* handler, uint32 id,
   }
 }
 
-void JingleThreadWrapper::Send(rtc::MessageHandler *handler, uint32 id,
-                               rtc::MessageData *data) {
+void JingleThreadWrapper::Send(rtc::MessageHandler* handler,
+                               uint32_t id,
+                               rtc::MessageData* data) {
   if (fStop_)
     return;
 
@@ -209,9 +217,10 @@ void JingleThreadWrapper::ProcessPendingSends() {
   }
 }
 
-void JingleThreadWrapper::PostTaskInternal(
-    int delay_ms, rtc::MessageHandler* handler,
-    uint32 message_id, rtc::MessageData* data) {
+void JingleThreadWrapper::PostTaskInternal(int delay_ms,
+                                           rtc::MessageHandler* handler,
+                                           uint32_t message_id,
+                                           rtc::MessageData* data) {
   int task_id;
   rtc::Message message;
   message.phandler = handler;
@@ -283,8 +292,10 @@ bool JingleThreadWrapper::Peek(rtc::Message*, int) {
   return false;
 }
 
-void JingleThreadWrapper::PostAt(uint32, rtc::MessageHandler*,
-                                 uint32, rtc::MessageData*) {
+void JingleThreadWrapper::PostAt(uint32_t,
+                                 rtc::MessageHandler*,
+                                 uint32_t,
+                                 rtc::MessageData*) {
   NOTREACHED();
 }
 
diff --git a/jingle/glue/thread_wrapper.h b/jingle/glue/thread_wrapper.h
index 7969d2b..c14b8c1 100644
--- a/jingle/glue/thread_wrapper.h
+++ b/jingle/glue/thread_wrapper.h
@@ -5,10 +5,13 @@
 #ifndef JINGLE_GLUE_THREAD_WRAPPER_H_
 #define JINGLE_GLUE_THREAD_WRAPPER_H_
 
+#include <stdint.h>
+
 #include <list>
 #include <map>
 
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
@@ -58,18 +61,18 @@ class JingleThreadWrapper : public base::MessageLoop::DestructionObserver,
 
   // rtc::MessageQueue overrides.
   void Post(rtc::MessageHandler* phandler,
-            uint32 id,
+            uint32_t id,
             rtc::MessageData* pdata,
             bool time_sensitive) override;
   void PostDelayed(int delay_ms,
                    rtc::MessageHandler* handler,
-                   uint32 id,
+                   uint32_t id,
                    rtc::MessageData* data) override;
   void Clear(rtc::MessageHandler* handler,
-             uint32 id,
+             uint32_t id,
              rtc::MessageList* removed) override;
   void Send(rtc::MessageHandler* handler,
-            uint32 id,
+            uint32_t id,
             rtc::MessageData* data) override;
 
   // Following methods are not supported.They are overriden just to
@@ -81,9 +84,9 @@ class JingleThreadWrapper : public base::MessageLoop::DestructionObserver,
   void Restart() override;
   bool Get(rtc::Message* message, int delay_ms, bool process_io) override;
   bool Peek(rtc::Message* message, int delay_ms) override;
-  void PostAt(uint32 timestamp,
+  void PostAt(uint32_t timestamp,
               rtc::MessageHandler* handler,
-              uint32 id,
+              uint32_t id,
               rtc::MessageData* data) override;
   void Dispatch(rtc::Message* message) override;
   void ReceiveSends() override;
@@ -100,9 +103,10 @@ class JingleThreadWrapper : public base::MessageLoop::DestructionObserver,
   explicit JingleThreadWrapper(
      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
-  void PostTaskInternal(
-      int delay_ms, rtc::MessageHandler* handler,
-      uint32 message_id, rtc::MessageData* data);
+  void PostTaskInternal(int delay_ms,
+                        rtc::MessageHandler* handler,
+                        uint32_t message_id,
+                        rtc::MessageData* data);
   void RunTask(int task_id);
   void ProcessPendingSends();
 
diff --git a/jingle/glue/thread_wrapper_unittest.cc b/jingle/glue/thread_wrapper_unittest.cc
index 5c4daf1..db590ef 100644
--- a/jingle/glue/thread_wrapper_unittest.cc
+++ b/jingle/glue/thread_wrapper_unittest.cc
@@ -2,6 +2,8 @@
 // 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/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
@@ -17,8 +19,8 @@ using ::testing::Mock;
 
 namespace jingle_glue {
 
-static const uint32 kTestMessage1 = 1;
-static const uint32 kTestMessage2 = 2;
+static const uint32_t kTestMessage1 = 1;
+static const uint32_t kTestMessage2 = 2;
 
 static const int kTestDelayMs1 = 10;
 static const int kTestDelayMs2 = 20;
diff --git a/jingle/glue/utils.cc b/jingle/glue/utils.cc
index 130d0e3..618ac5c 100644
--- a/jingle/glue/utils.cc
+++ b/jingle/glue/utils.cc
@@ -4,6 +4,8 @@
 
 #include "jingle/glue/utils.h"
 
+#include <stdint.h>
+
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
diff --git a/jingle/glue/xmpp_client_socket_factory.h b/jingle/glue/xmpp_client_socket_factory.h
index db46afd..986ede0 100644
--- a/jingle/glue/xmpp_client_socket_factory.h
+++ b/jingle/glue/xmpp_client_socket_factory.h
@@ -8,6 +8,7 @@
 #include <string>
 
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "jingle/glue/resolving_client_socket_factory.h"
 #include "net/ssl/ssl_config_service.h"