Switch to standard integer types in net/.

net/tools/get_server_time/get_server_time.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.
 
 // This is a small utility that snarfs the server time from the
 // response headers of an http/https HEAD request and compares it to
 // the local time.
 //
 // TODO(akalin): Also snarf the server time from the TLS handshake, if
 // any (http://crbug.com/146090).
 
 #include <cstdio>
 #include <cstdlib>
 #include <string>
 
 #include "base/at_exit.h"
-#include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "net/base/net_errors.h"
@@ skipping 13 matching lines @@
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #endif
 
 using base::UTF16ToUTF8;
 
 namespace {
 
 // base::TimeTicks::Now() is documented to have a resolution of
 // ~1-15ms.
-const int64 kTicksResolutionMs = 15;
+const int64_t kTicksResolutionMs = 15;
 
 // For the sources that are supported (HTTP date headers, TLS
 // handshake), the resolution of the server time is 1 second.
-const int64 kServerTimeResolutionMs = 1000;
+const int64_t kServerTimeResolutionMs = 1000;
 
 // Assume base::Time::Now() has the same resolution as
 // base::TimeTicks::Now().
 //
 // TODO(akalin): Figure out the real resolution.
-const int64 kTimeResolutionMs = kTicksResolutionMs;
+const int64_t kTimeResolutionMs = kTicksResolutionMs;
 
 // Simply quits the current message loop when finished.  Used to make
 // URLFetcher synchronous.
 class QuitDelegate : public net::URLFetcherDelegate {
  public:
   QuitDelegate() {}
 
   ~QuitDelegate() override {}
 
   // net::URLFetcherDelegate implementation.
   void OnURLFetchComplete(const net::URLFetcher* source) override {
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void OnURLFetchDownloadProgress(const net::URLFetcher* source,
-                                  int64 current,
-                                  int64 total) override {
+                                  int64_t current,
+                                  int64_t total) override {
     NOTREACHED();
   }
 
   void OnURLFetchUploadProgress(const net::URLFetcher* source,
-                                int64 current,
-                                int64 total) override {
+                                int64_t current,
+                                int64_t total) override {
     NOTREACHED();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuitDelegate);
 };
 
 // NetLog::ThreadSafeObserver implementation that simply prints events
 // to the logs.
 class PrintingLogObserver : public net::NetLog::ThreadSafeObserver {
@@ skipping 153 matching lines @@
   main_loop.Run();
 
   const base::Time end_time = base::Time::Now();
   const base::TimeTicks end_ticks = base::TimeTicks::Now();
 
   std::printf(
       "Request ended at %s (ticks = %" PRId64 ")\n",
       UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(end_time)).c_str(),
       end_ticks.ToInternalValue());
 
-  const int64 delta_ticks_internal =
+  const int64_t delta_ticks_internal =
       end_ticks.ToInternalValue() - start_ticks.ToInternalValue();
   const base::TimeDelta delta_ticks = end_ticks - start_ticks;
 
   std::printf(
       "Request took %" PRId64 " ticks (%.2f ms)\n",
       delta_ticks_internal, delta_ticks.InMillisecondsF());
 
   const net::URLRequestStatus status = fetcher->GetStatus();
   if (status.status() != net::URLRequestStatus::SUCCESS) {
     LOG(ERROR) << "Request failed with error code: "
@@ skipping 42 matching lines @@
                &skew, &skew_uncertainty);
 
   std::printf(
       "An estimate for the local clock skew is %.2f ms with "
       "uncertainty %.2f ms\n",
       skew.InMillisecondsF(),
       skew_uncertainty.InMillisecondsF());
 
   return EXIT_SUCCESS;
 }