Switch to standard integer types in net/.

net/log/net_log.h

 // 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.
 
 #ifndef NET_LOG_NET_LOG_H_
 #define NET_LOG_NET_LOG_H_
 
+#include <stdint.h>
+
 #include <string>
 
 #include "build/build_config.h"
 
 #include "base/atomicops.h"
-#include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
 #include "net/log/net_log_capture_mode.h"
 
 namespace base {
 class DictionaryValue;
 class Value;
@@ skipping 45 matching lines @@
   // associated with an event.  If called, it will be called synchronously,
   // so it need not have owning references.  May be called more than once, or
   // not at all.  May return NULL.
   typedef base::Callback<scoped_ptr<base::Value>(NetLogCaptureMode)>
       ParametersCallback;
 
   // Identifies the entity that generated this log. The |id| field should
   // uniquely identify the source, and is used by log observers to infer
   // message groupings. Can use NetLog::NextID() to create unique IDs.
   struct NET_EXPORT Source {
-    static const uint32 kInvalidId;
+    static const uint32_t kInvalidId;
 
     Source();
-    Source(SourceType type, uint32 id);
+    Source(SourceType type, uint32_t id);
     bool IsValid() const;
 
     // Adds the source to a DictionaryValue containing event parameters,
     // using the name "source_dependency".
     void AddToEventParameters(base::DictionaryValue* event_params) const;
 
     // Returns a callback that returns a dictionary with a single entry
     // named "source_dependency" that describes |this|.
     ParametersCallback ToEventParametersCallback() const;
 
     // Attempts to extract a Source from a set of event parameters.  Returns
     // true and writes the result to |source| on success.  Returns false and
     // makes |source| an invalid source on failure.
     // TODO(mmenke):  Long term, we want to remove this.
     static bool FromEventParameters(base::Value* event_params, Source* source);
 
     SourceType type;
-    uint32 id;
+    uint32_t id;
   };
 
   struct NET_EXPORT EntryData {
     EntryData(EventType type,
               Source source,
               EventPhase phase,
               base::TimeTicks time,
               const ParametersCallback* parameters_callback);
     ~EntryData();
 
@@ skipping 86 matching lines @@
   NetLog();
   virtual ~NetLog();
 
   // Emits a global event to the log stream, with its own unique source ID.
   void AddGlobalEntry(EventType type);
   void AddGlobalEntry(EventType type,
                       const NetLog::ParametersCallback& parameters_callback);
 
   // Returns a unique ID which can be used as a source ID.  All returned IDs
   // will be unique and greater than 0.
-  uint32 NextID();
+  uint32_t NextID();
 
   // Returns true if there are any observers attached to the NetLog. This can be
   // used as an optimization to avoid emitting log entries when there is no
   // chance that the data will be consumed.
   bool IsCapturing() const;
 
   // Adds an observer and sets its log capture mode.  The observer must not be
   // watching any NetLog, including this one, when this is called.
   //
   // NetLog implementations must call NetLog::OnAddObserver to update the
@@ skipping 43 matching lines @@
   // Returns a C-String symbolic name for |event_phase|.
   static const char* EventPhaseToString(EventPhase event_phase);
 
   // Creates a ParametersCallback that encapsulates a single bool.
   // Warning: |name| must remain valid for the life of the callback.
   static ParametersCallback BoolCallback(const char* name, bool value);
 
   // Warning: |name| must remain valid for the life of the callback.
   static ParametersCallback IntCallback(const char* name, int value);
 
-  // Creates a ParametersCallback that encapsulates a single int64.  The
+  // Creates a ParametersCallback that encapsulates a single int64_t.  The
   // callback will return the value as a StringValue, since IntegerValues
   // only support 32-bit values.
   // Warning: |name| must remain valid for the life of the callback.
-  static ParametersCallback Int64Callback(const char* name, int64 value);
+  static ParametersCallback Int64Callback(const char* name, int64_t value);
 
   // Creates a ParametersCallback that encapsulates a single UTF8 string.  Takes
   // |value| as a pointer to avoid copying, and emphasize it must be valid for
   // the life of the callback.  |value| may not be NULL.
   // Warning: |name| and |value| must remain valid for the life of the callback.
   static ParametersCallback StringCallback(const char* name,
                                            const std::string* value);
 
   // Same as above, but takes in a UTF16 string.
   static ParametersCallback StringCallback(const char* name,
@@ skipping 100 matching lines @@
   NetLog::Source source_;
   NetLog* net_log_;
 
   // TODO(eroman): Temporary until crbug.com/467797 is solved.
   Liveness liveness_ = ALIVE;
 };
 
 }  // namespace net
 
 #endif  // NET_LOG_NET_LOG_H_