Remove kint32min.

net/spdy/spdy_stream.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/spdy/spdy_stream.h"
 
+#include <limits>
+
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
@@ skipping 12 matching lines @@
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", static_cast<int>(stream_id));
   dict->SetInteger("status", status);
   dict->SetString("description", *description);
   return dict.Pass();
 }
 
 scoped_ptr<base::Value> NetLogSpdyStreamWindowUpdateCallback(
     SpdyStreamId stream_id,
-    int32 delta,
-    int32 window_size,
+    int32_t delta,
+    int32_t window_size,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", stream_id);
   dict->SetInteger("delta", delta);
   dict->SetInteger("window_size", window_size);
   return dict.Pass();
 }
 
 bool ContainsUppercaseAscii(const std::string& str) {
   for (std::string::const_iterator i(str.begin()); i != str.end(); ++i) {
@@ skipping 29 matching lines @@
   }
 
  private:
   const base::WeakPtr<SpdyStream> stream_;
 };
 
 SpdyStream::SpdyStream(SpdyStreamType type,
                        const base::WeakPtr<SpdySession>& session,
                        const GURL& url,
                        RequestPriority priority,
-                       int32 initial_send_window_size,
-                       int32 max_recv_window_size,
+                       int32_t initial_send_window_size,
+                       int32_t max_recv_window_size,
                        const BoundNetLog& net_log)
     : type_(type),
       stream_id_(0),
       url_(url),
       priority_(priority),
       send_stalled_by_flow_control_(false),
       send_window_size_(initial_send_window_size),
       max_recv_window_size_(max_recv_window_size),
       recv_window_size_(max_recv_window_size),
       unacked_recv_window_bytes_(0),
@@ skipping 111 matching lines @@
   send_time_ = base::TimeTicks::Now();
   return frame.Pass();
 }
 
 void SpdyStream::DetachDelegate() {
   DCHECK(!IsClosed());
   delegate_ = NULL;
   Cancel();
 }
 
-void SpdyStream::AdjustSendWindowSize(int32 delta_window_size) {
+void SpdyStream::AdjustSendWindowSize(int32_t delta_window_size) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
 
   if (IsClosed())
     return;
 
   // Check for wraparound.
   if (send_window_size_ > 0) {
-    DCHECK_LE(delta_window_size, kint32max - send_window_size_);
+    DCHECK_LE(delta_window_size,
+              std::numeric_limits<int32_t>::max() - send_window_size_);
   }
   if (send_window_size_ < 0) {
-    DCHECK_GE(delta_window_size, kint32min - send_window_size_);
+    DCHECK_GE(delta_window_size,
+              std::numeric_limits<int32_t>::min() - send_window_size_);
   }
   send_window_size_ += delta_window_size;
   PossiblyResumeIfSendStalled();
 }
 
 void SpdyStream::OnWriteBufferConsumed(
     size_t frame_payload_size,
     size_t consume_size,
     SpdyBuffer::ConsumeSource consume_source) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
   if (consume_source == SpdyBuffer::DISCARD) {
     // If we're discarding a frame or part of it, increase the send
     // window by the number of discarded bytes. (Although if we're
     // discarding part of a frame, it's probably because of a write
     // error and we'll be tearing down the stream soon.)
     size_t remaining_payload_bytes = std::min(consume_size, frame_payload_size);
     DCHECK_GT(remaining_payload_bytes, 0u);
-    IncreaseSendWindowSize(static_cast<int32>(remaining_payload_bytes));
+    IncreaseSendWindowSize(static_cast<int32_t>(remaining_payload_bytes));
   }
   // For consumed bytes, the send window is increased when we receive
   // a WINDOW_UPDATE frame.
 }
 
-void SpdyStream::IncreaseSendWindowSize(int32 delta_window_size) {
+void SpdyStream::IncreaseSendWindowSize(int32_t delta_window_size) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
   DCHECK_GE(delta_window_size, 1);
 
   // Ignore late WINDOW_UPDATEs.
   if (IsClosed())
     return;
 
   if (send_window_size_ > 0) {
     // Check for overflow.
-    int32 max_delta_window_size = kint32max - send_window_size_;
+    int32_t max_delta_window_size =
+        std::numeric_limits<int32_t>::max() - send_window_size_;
     if (delta_window_size > max_delta_window_size) {
       std::string desc = base::StringPrintf(
           "Received WINDOW_UPDATE [delta: %d] for stream %d overflows "
           "send_window_size_ [current: %d]", delta_window_size, stream_id_,
           send_window_size_);
       session_->ResetStream(stream_id_, RST_STREAM_FLOW_CONTROL_ERROR, desc);
       return;
     }
   }
 
   send_window_size_ += delta_window_size;
 
   net_log_.AddEvent(
       NetLog::TYPE_HTTP2_STREAM_UPDATE_SEND_WINDOW,
       base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
                  delta_window_size, send_window_size_));
 
   PossiblyResumeIfSendStalled();
 }
 
-void SpdyStream::DecreaseSendWindowSize(int32 delta_window_size) {
+void SpdyStream::DecreaseSendWindowSize(int32_t delta_window_size) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
 
   if (IsClosed())
     return;
 
   // We only call this method when sending a frame. Therefore,
   // |delta_window_size| should be within the valid frame size range.
   DCHECK_GE(delta_window_size, 1);
   DCHECK_LE(delta_window_size, kMaxSpdyFrameChunkSize);
 
   // |send_window_size_| should have been at least |delta_window_size| for
   // this call to happen.
   DCHECK_GE(send_window_size_, delta_window_size);
 
   send_window_size_ -= delta_window_size;
 
   net_log_.AddEvent(
       NetLog::TYPE_HTTP2_STREAM_UPDATE_SEND_WINDOW,
       base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
                  -delta_window_size, send_window_size_));
 }
 
 void SpdyStream::OnReadBufferConsumed(
     size_t consume_size,
     SpdyBuffer::ConsumeSource consume_source) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
   DCHECK_GE(consume_size, 1u);
-  DCHECK_LE(consume_size, static_cast<size_t>(kint32max));
-  IncreaseRecvWindowSize(static_cast<int32>(consume_size));
+  DCHECK_LE(consume_size,
+            static_cast<size_t>(std::numeric_limits<int32_t>::max()));
+  IncreaseRecvWindowSize(static_cast<int32_t>(consume_size));
 }
 
-void SpdyStream::IncreaseRecvWindowSize(int32 delta_window_size) {
+void SpdyStream::IncreaseRecvWindowSize(int32_t delta_window_size) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
 
   // By the time a read is processed by the delegate, this stream may
   // already be inactive.
   if (!session_->IsStreamActive(stream_id_))
     return;
 
   DCHECK_GE(unacked_recv_window_bytes_, 0);
   DCHECK_GE(recv_window_size_, unacked_recv_window_bytes_);
   DCHECK_GE(delta_window_size, 1);
   // Check for overflow.
-  DCHECK_LE(delta_window_size, kint32max - recv_window_size_);
+  DCHECK_LE(delta_window_size,
+            std::numeric_limits<int32_t>::max() - recv_window_size_);
 
   recv_window_size_ += delta_window_size;
   net_log_.AddEvent(
       NetLog::TYPE_HTTP2_STREAM_UPDATE_RECV_WINDOW,
       base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
                  delta_window_size, recv_window_size_));
 
   unacked_recv_window_bytes_ += delta_window_size;
   if (unacked_recv_window_bytes_ > max_recv_window_size_ / 2) {
     session_->SendStreamWindowUpdate(
-        stream_id_, static_cast<uint32>(unacked_recv_window_bytes_));
+        stream_id_, static_cast<uint32_t>(unacked_recv_window_bytes_));
     unacked_recv_window_bytes_ = 0;
   }
 }
 
-void SpdyStream::DecreaseRecvWindowSize(int32 delta_window_size) {
+void SpdyStream::DecreaseRecvWindowSize(int32_t delta_window_size) {
   DCHECK(session_->IsStreamActive(stream_id_));
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
   DCHECK_GE(delta_window_size, 1);
 
   // The receiving window size as the peer knows it is
   // |recv_window_size_ - unacked_recv_window_bytes_|, if more data are sent by
   // the peer, that means that the receive window is not being respected.
   if (delta_window_size > recv_window_size_ - unacked_recv_window_bytes_) {
     session_->ResetStream(
         stream_id_, RST_STREAM_FLOW_CONTROL_ERROR,
@@ skipping 163 matching lines @@
       NOTREACHED() << io_state_;
     }
     return;
   }
 
   size_t length = buffer->GetRemainingSize();
   DCHECK_LE(length, session_->GetDataFrameMaximumPayload());
   if (session_->flow_control_state() >= SpdySession::FLOW_CONTROL_STREAM) {
     base::WeakPtr<SpdyStream> weak_this = GetWeakPtr();
     // May close the stream.
-    DecreaseRecvWindowSize(static_cast<int32>(length));
+    DecreaseRecvWindowSize(static_cast<int32_t>(length));
     if (!weak_this)
       return;
     buffer->AddConsumeCallback(
         base::Bind(&SpdyStream::OnReadBufferConsumed, GetWeakPtr()));
   }
 
   // Track our bandwidth.
   recv_bytes_ += length;
   recv_last_byte_time_ = base::TimeTicks::Now();
 
   // May close |this|.
   delegate_->OnDataReceived(buffer.Pass());
 }
 
 void SpdyStream::OnPaddingConsumed(size_t len) {
   if (session_->flow_control_state() >= SpdySession::FLOW_CONTROL_STREAM) {
     // Decrease window size because padding bytes are received.
     // Increase window size because padding bytes are consumed (by discarding).
     // Net result: |unacked_recv_window_bytes_| increases by |len|,
     // |recv_window_size_| does not change.
     base::WeakPtr<SpdyStream> weak_this = GetWeakPtr();
     // May close the stream.
-    DecreaseRecvWindowSize(static_cast<int32>(len));
+    DecreaseRecvWindowSize(static_cast<int32_t>(len));
     if (!weak_this)
       return;
-    IncreaseRecvWindowSize(static_cast<int32>(len));
+    IncreaseRecvWindowSize(static_cast<int32_t>(len));
   }
 }
 
 void SpdyStream::OnFrameWriteComplete(SpdyFrameType frame_type,
                                       size_t frame_size) {
   DCHECK_NE(type_, SPDY_PUSH_STREAM);
   CHECK(frame_type == SYN_STREAM ||
         frame_type == DATA) << frame_type;
 
   int result = (frame_type == SYN_STREAM) ?
@@ skipping 277 matching lines @@
   if (session_->flow_control_state() >= SpdySession::FLOW_CONTROL_STREAM) {
     DCHECK_GE(data_buffer->GetRemainingSize(),
               session_->GetDataFrameMinimumSize());
     size_t payload_size =
         data_buffer->GetRemainingSize() - session_->GetDataFrameMinimumSize();
     DCHECK_LE(payload_size, session_->GetDataFrameMaximumPayload());
 
     // Send window size is based on payload size, so nothing to do if this is
     // just a FIN with no payload.
     if (payload_size != 0) {
-      DecreaseSendWindowSize(static_cast<int32>(payload_size));
+      DecreaseSendWindowSize(static_cast<int32_t>(payload_size));
       // This currently isn't strictly needed, since write frames are
       // discarded only if the stream is about to be closed. But have it
       // here anyway just in case this changes.
       data_buffer->AddConsumeCallback(
           base::Bind(&SpdyStream::OnWriteBufferConsumed,
                      GetWeakPtr(), payload_size));
     }
   }
 
   session_->EnqueueStreamWrite(
@@ skipping 78 matching lines @@
       description = base::StringPrintf("Unknown state 0x%08X (%u)", state,
                                        state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net