Switch to standard integer types in chrome/.

chrome/test/chromedriver/server/chromedriver_server.cc

 // Copyright (c) 2013 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 <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <locale>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_local.h"
+#include "build/build_config.h"
 #include "chrome/test/chromedriver/logging.h"
 #include "chrome/test/chromedriver/net/port_server.h"
 #include "chrome/test/chromedriver/server/http_handler.h"
 #include "chrome/test/chromedriver/version.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/server/http_server.h"
 #include "net/server/http_server_request_info.h"
 #include "net/server/http_server_response_info.h"
 #include "net/socket/tcp_server_socket.h"
 
 namespace {
 
 const char kLocalHostAddress[] = "127.0.0.1";
 const int kBufferSize = 100 * 1024 * 1024;  // 100 MB
 
 typedef base::Callback<
     void(const net::HttpServerRequestInfo&, const HttpResponseSenderFunc&)>
     HttpRequestHandlerFunc;
 
 class HttpServer : public net::HttpServer::Delegate {
  public:
   explicit HttpServer(const HttpRequestHandlerFunc& handle_request_func)
       : handle_request_func_(handle_request_func),
         weak_factory_(this) {}
 
   ~HttpServer() override {}
 
-  bool Start(uint16 port, bool allow_remote) {
+  bool Start(uint16_t port, bool allow_remote) {
     std::string binding_ip = kLocalHostAddress;
     if (allow_remote)
       binding_ip = "0.0.0.0";
     scoped_ptr<net::ServerSocket> server_socket(
         new net::TCPServerSocket(NULL, net::NetLog::Source()));
     server_socket->ListenWithAddressAndPort(binding_ip, port, 1);
     server_.reset(new net::HttpServer(server_socket.Pass(), this));
     net::IPEndPoint address;
     return server_->GetLocalAddress(&address) == net::OK;
   }
@@ skipping 79 matching lines @@
 base::LazyInstance<base::ThreadLocalPointer<HttpServer> >
     lazy_tls_server = LAZY_INSTANCE_INITIALIZER;
 
 void StopServerOnIOThread() {
   // Note, |server| may be NULL.
   HttpServer* server = lazy_tls_server.Pointer()->Get();
   lazy_tls_server.Pointer()->Set(NULL);
   delete server;
 }
 
-void StartServerOnIOThread(uint16 port,
+void StartServerOnIOThread(uint16_t port,
                            bool allow_remote,
                            const HttpRequestHandlerFunc& handle_request_func) {
   scoped_ptr<HttpServer> temp_server(new HttpServer(handle_request_func));
   if (!temp_server->Start(port, allow_remote)) {
     printf("Port not available. Exiting...\n");
     exit(1);
   }
   lazy_tls_server.Pointer()->Set(temp_server.release());
 }
 
-void RunServer(uint16 port,
+void RunServer(uint16_t port,
                bool allow_remote,
                const std::vector<std::string>& whitelisted_ips,
                const std::string& url_base,
                int adb_port,
                scoped_ptr<PortServer> port_server) {
   base::Thread io_thread("ChromeDriver IO");
   CHECK(io_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
   base::MessageLoop cmd_loop;
@@ skipping 27 matching lines @@
   base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
 
 #if defined(OS_LINUX)
   // Select the locale from the environment by passing an empty string instead
   // of the default "C" locale. This is particularly needed for the keycode
   // conversion code to work.
   setlocale(LC_ALL, "");
 #endif
 
   // Parse command line flags.
-  uint16 port = 9515;
+  uint16_t port = 9515;
   int adb_port = 5037;
   bool allow_remote = false;
   std::vector<std::string> whitelisted_ips;
   std::string url_base;
   scoped_ptr<PortServer> port_server;
   if (cmd_line->HasSwitch("h") || cmd_line->HasSwitch("help")) {
     std::string options;
     const char* const kOptionAndDescriptions[] = {
         "port=PORT", "port to listen on",
         "adb-port=PORT", "adb server port",
@@ skipping 20 matching lines @@
     return 0;
   }
   if (cmd_line->HasSwitch("port")) {
     int cmd_line_port;
     if (!base::StringToInt(cmd_line->GetSwitchValueASCII("port"),
                            &cmd_line_port) ||
         cmd_line_port < 0 || cmd_line_port > 65535) {
       printf("Invalid port. Exiting...\n");
       return 1;
     }
-    port = static_cast<uint16>(cmd_line_port);
+    port = static_cast<uint16_t>(cmd_line_port);
   }
   if (cmd_line->HasSwitch("adb-port")) {
     if (!base::StringToInt(cmd_line->GetSwitchValueASCII("adb-port"),
                            &adb_port)) {
       printf("Invalid adb-port. Exiting...\n");
       return 1;
     }
   }
   if (cmd_line->HasSwitch("port-server")) {
 #if defined(OS_LINUX)
@@ skipping 37 matching lines @@
   }
 
   if (!InitLogging()) {
     printf("Unable to initialize logging. Exiting...\n");
     return 1;
   }
   RunServer(port, allow_remote, whitelisted_ips,
             url_base, adb_port, port_server.Pass());
   return 0;
 }