Switch to standard integer types in net/.

net/log/net_log.cc

 // Copyright (c) 2012 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 "net/log/net_log.h"
 
 #include "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 44 matching lines @@
     const char* name,
     int value,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetInteger(name, value);
   return event_params.Pass();
 }
 
 scoped_ptr<base::Value> NetLogInt64Callback(
     const char* name,
-    int64 value,
+    int64_t value,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetString(name, base::Int64ToString(value));
   return event_params.Pass();
 }
 
 scoped_ptr<base::Value> NetLogStringCallback(
     const char* name,
     const std::string* value,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetString(name, *value);
   return event_params.Pass();
 }
 
 scoped_ptr<base::Value> NetLogString16Callback(
     const char* name,
     const base::string16* value,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetString(name, *value);
   return event_params.Pass();
 }
 
 }  // namespace
 
 // LoadTimingInfo requires this be 0.
-const uint32 NetLog::Source::kInvalidId = 0;
+const uint32_t NetLog::Source::kInvalidId = 0;
 
 NetLog::Source::Source() : type(SOURCE_NONE), id(kInvalidId) {
 }
 
-NetLog::Source::Source(SourceType type, uint32 id) : type(type), id(id) {
-}
+NetLog::Source::Source(SourceType type, uint32_t id) : type(type), id(id) {}
 
 bool NetLog::Source::IsValid() const {
   return id != kInvalidId;
 }
 
 void NetLog::Source::AddToEventParameters(
     base::DictionaryValue* event_params) const {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("type", static_cast<int>(type));
   dict->SetInteger("id", static_cast<int>(id));
@@ skipping 113 matching lines @@
            NULL);
 }
 
 void NetLog::AddGlobalEntry(
     EventType type,
     const NetLog::ParametersCallback& parameters_callback) {
   AddEntry(type, Source(NetLog::SOURCE_NONE, NextID()), NetLog::PHASE_NONE,
            &parameters_callback);
 }
 
-uint32 NetLog::NextID() {
+uint32_t NetLog::NextID() {
   return base::subtle::NoBarrier_AtomicIncrement(&last_id_, 1);
 }
 
 bool NetLog::IsCapturing() const {
   return base::subtle::NoBarrier_Load(&is_capturing_) != 0;
 }
 
 void NetLog::DeprecatedAddObserver(NetLog::ThreadSafeObserver* observer,
                                    NetLogCaptureMode capture_mode) {
   base::AutoLock lock(lock_);
@@ skipping 26 matching lines @@
 }
 
 void NetLog::UpdateIsCapturing() {
   lock_.AssertAcquired();
   base::subtle::NoBarrier_Store(&is_capturing_,
                                 observers_.might_have_observers() ? 1 : 0);
 }
 
 // static
 std::string NetLog::TickCountToString(const base::TimeTicks& time) {
-  int64 delta_time = (time - base::TimeTicks()).InMilliseconds();
+  int64_t delta_time = (time - base::TimeTicks()).InMilliseconds();
   return base::Int64ToString(delta_time);
 }
 
 // static
 const char* NetLog::EventTypeToString(EventType event) {
   switch (event) {
 #define EVENT_TYPE(label) \
   case TYPE_##label:      \
     return #label;
 #include "net/log/net_log_event_type_list.h"
@@ skipping 55 matching lines @@
   return base::Bind(&NetLogBoolCallback, name, value);
 }
 
 // static
 NetLog::ParametersCallback NetLog::IntCallback(const char* name, int value) {
   return base::Bind(&NetLogIntCallback, name, value);
 }
 
 // static
 NetLog::ParametersCallback NetLog::Int64Callback(const char* name,
-                                                 int64 value) {
+                                                 int64_t value) {
   return base::Bind(&NetLogInt64Callback, name, value);
 }
 
 // static
 NetLog::ParametersCallback NetLog::StringCallback(const char* name,
                                                   const std::string* value) {
   DCHECK(value);
   return base::Bind(&NetLogStringCallback, name, value);
 }
 
@@ skipping 116 matching lines @@
   Liveness liveness = liveness_;
 
   if (liveness == ALIVE)
     return;
 
   base::debug::Alias(&liveness);
   CHECK_EQ(ALIVE, liveness);
 }
 
 }  // namespace net