Remove kint32max.

net/spdy/spdy_stream_unittest.cc

 // Copyright 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 <stdint.h>
+
 #include <cstddef>
+#include <limits>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 #include "net/base/completion_callback.h"
 #include "net/base/request_priority.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
@@ skipping 35 matching lines @@
 const size_t kPostBodyLength = arraysize(kPostBody);
 const base::StringPiece kPostBodyStringPiece(kPostBody, kPostBodyLength);
 
 }  // namespace
 
 class SpdyStreamTest : public ::testing::Test,
                        public ::testing::WithParamInterface<TestCase> {
  protected:
   // A function that takes a SpdyStream and the number of bytes which
   // will unstall the next frame completely.
-  typedef base::Callback<void(const base::WeakPtr<SpdyStream>&, int32)>
+  typedef base::Callback<void(const base::WeakPtr<SpdyStream>&, int32_t)>
       UnstallFunction;
 
   SpdyStreamTest()
       : spdy_util_(GetProtocol(), GetDependenciesFromPriority()),
         session_deps_(GetProtocol()),
         offset_(0) {
     SpdySession::SetPriorityDependencyDefaultForTesting(
         GetDependenciesFromPriority());
   }
 
@@ skipping 751 matching lines @@
   EXPECT_FALSE(push_stream);
 
   data.RunFor(2);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 }
 
 // The tests below are only for SPDY/3 and above.
 
 // Call IncreaseSendWindowSize on a stream with a large enough delta
-// to overflow an int32. The SpdyStream should handle that case
+// to overflow an int32_t. The SpdyStream should handle that case
 // gracefully.
 TEST_P(SpdyStreamTest, IncreaseSendWindowSizeOverflow) {
   session_ =
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   AddWrite(*req);
 
@@ skipping 26 matching lines @@
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrlFromHeaders());
   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 
   data.RunFor(1);
 
-  int32 old_send_window_size = stream->send_window_size();
+  int32_t old_send_window_size = stream->send_window_size();
   ASSERT_GT(old_send_window_size, 0);
-  int32 delta_window_size = kint32max - old_send_window_size + 1;
+  int32_t delta_window_size =
+      std::numeric_limits<int32_t>::max() - old_send_window_size + 1;
   stream->IncreaseSendWindowSize(delta_window_size);
   EXPECT_EQ(NULL, stream.get());
 
   data.RunFor(2);
 
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, delegate.WaitForClose());
 }
 
 // Functions used with
 // RunResumeAfterUnstall{RequestResponse,Bidirectional}Test().
 
 void StallStream(const base::WeakPtr<SpdyStream>& stream) {
   // Reduce the send window size to 0 to stall.
   while (stream->send_window_size() > 0) {
     stream->DecreaseSendWindowSize(
         std::min(kMaxSpdyFrameChunkSize, stream->send_window_size()));
   }
 }
 
 void IncreaseStreamSendWindowSize(const base::WeakPtr<SpdyStream>& stream,
-                                  int32 delta_window_size) {
+                                  int32_t delta_window_size) {
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
   stream->IncreaseSendWindowSize(delta_window_size);
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 }
 
 void AdjustStreamSendWindowSize(const base::WeakPtr<SpdyStream>& stream,
-                                int32 delta_window_size) {
+                                int32_t delta_window_size) {
   // Make sure that negative adjustments are handled properly.
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
   stream->AdjustSendWindowSize(-delta_window_size);
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
   stream->AdjustSendWindowSize(+delta_window_size);
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
   stream->AdjustSendWindowSize(+delta_window_size);
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 }
 
@@ skipping 207 matching lines @@
 
   EXPECT_FALSE(stream->HasUrlFromHeaders());
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock(kStreamUrl));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrlFromHeaders());
   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 
-  int64 reply_frame_len = reply->size();
-  int64 data_header_len = spdy_util_.CreateFramer(false)
-      ->GetDataFrameMinimumSize();
-  int64 data_frame_len = data_header_len + kPostBodyLength;
-  int64 response_len = reply_frame_len + data_frame_len;
+  int64_t reply_frame_len = reply->size();
+  int64_t data_header_len =
+      spdy_util_.CreateFramer(false)->GetDataFrameMinimumSize();
+  int64_t data_frame_len = data_header_len + kPostBodyLength;
+  int64_t response_len = reply_frame_len + data_frame_len;
 
   EXPECT_EQ(0, stream->raw_received_bytes());
   data.RunFor(1); // SYN
   EXPECT_EQ(0, stream->raw_received_bytes());
   data.RunFor(1); // REPLY
   EXPECT_EQ(reply_frame_len, stream->raw_received_bytes());
   data.RunFor(1); // DATA
   EXPECT_EQ(response_len, stream->raw_received_bytes());
   data.RunFor(1); // FIN
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 }
 
 }  // namespace test
 
 }  // namespace net