Remove kuint16max.

net/test/spawned_test_server/spawner_communicator.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/test/spawned_test_server/spawner_communicator.h"
 
+#include <limits>
+
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/supports_user_data.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/port_util.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_test_util.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
-GURL GenerateSpawnerCommandURL(const std::string& command, uint16 port) {
+GURL GenerateSpawnerCommandURL(const std::string& command, uint16_t port) {
   // Always performs HTTP request for sending command to the spawner server.
   return GURL(base::StringPrintf("%s:%u/%s", "http://127.0.0.1", port,
                                  command.c_str()));
 }
 
 int kBufferSize = 2048;
 
 // A class to hold all data needed to send a command to spawner server.
 class SpawnerRequestData : public base::SupportsUserData::Data {
  public:
@@ skipping 53 matching lines @@
 
   // Used to track how many times the OnResponseStarted get called after
   // sending a command to spawner server.
   int response_started_count_;
 
   DISALLOW_COPY_AND_ASSIGN(SpawnerRequestData);
 };
 
 }  // namespace
 
-SpawnerCommunicator::SpawnerCommunicator(uint16 port)
+SpawnerCommunicator::SpawnerCommunicator(uint16_t port)
     : io_thread_("spawner_communicator"),
       event_(false, false),
       port_(port),
       next_id_(0),
       is_running_(false),
       weak_factory_(this) {}
 
 SpawnerCommunicator::~SpawnerCommunicator() {
   DCHECK(!is_running_);
 }
@@ skipping 205 matching lines @@
 
   if (data->ConsumeBytesRead(num_bytes)) {
     // Keep reading.
     ReadResult(request);
   } else {
     OnSpawnerCommandCompleted(request);
   }
 }
 
 bool SpawnerCommunicator::StartServer(const std::string& arguments,
-                                      uint16* port) {
+                                      uint16_t* port) {
   *port = 0;
   // Send the start command to spawner server to start the Python test server
   // on remote machine.
   std::string server_return_data;
   int result_code;
   SendCommandAndWaitForResult("start", arguments, &result_code,
                               &server_return_data);
   if (OK != result_code || server_return_data.empty())
     return false;
 
   // Check whether the data returned from spawner server is JSON-formatted.
   scoped_ptr<base::Value> value = base::JSONReader::Read(server_return_data);
   if (!value.get() || !value->IsType(base::Value::TYPE_DICTIONARY)) {
     LOG(ERROR) << "Invalid server data: " << server_return_data.c_str();
     return false;
   }
 
   // Check whether spawner server returns valid data.
   base::DictionaryValue* server_data =
       static_cast<base::DictionaryValue*>(value.get());
   std::string message;
   if (!server_data->GetString("message", &message) || message != "started") {
     LOG(ERROR) << "Invalid message in server data: ";
     return false;
   }
   int int_port;
   if (!server_data->GetInteger("port", &int_port) || int_port <= 0 ||
-      int_port > kuint16max) {
+      int_port > std::numeric_limits<uint16_t>::max()) {
     LOG(ERROR) << "Invalid port value: " << int_port;
     return false;
   }
-  *port = static_cast<uint16>(int_port);
+  *port = static_cast<uint16_t>(int_port);
   return true;
 }
 
 bool SpawnerCommunicator::StopServer() {
   // It's OK to stop the SpawnerCommunicator without starting it. Some tests
   // have test server on their test fixture but do not actually use it.
   if (!is_running_)
     return true;
 
   // When the test is done, ask the test server spawner to kill the test server
   // on the remote machine.
   std::string server_return_data;
   int result_code;
   SendCommandAndWaitForResult("kill", "", &result_code, &server_return_data);
   Shutdown();
   if (OK != result_code || server_return_data != "killed")
     return false;
   return true;
 }
 
 }  // namespace net