Switch to standard integer types in net/.

net/tools/flip_server/spdy_interface.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/tools/flip_server/spdy_interface.h"
 
 #include <algorithm>
 #include <string>
 
 #include "net/spdy/spdy_framer.h"
@@ skipping 75 matching lines @@
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Creating new HTTP interface";
   SMInterface* sm_http_interface =
       new HttpSM(server_connection, this, memory_cache_, acceptor_);
   return sm_http_interface;
 }
 
 SMInterface* SpdySM::FindOrMakeNewSMConnectionInterface(
     const std::string& server_ip,
     const std::string& server_port) {
   SMInterface* sm_http_interface;
-  int32 server_idx;
+  int32_t server_idx;
   if (unused_server_interface_list.empty()) {
     sm_http_interface = NewConnectionInterface();
     server_idx = server_interface_list.size();
     server_interface_list.push_back(sm_http_interface);
     VLOG(2) << ACCEPTOR_CLIENT_IDENT
             << "SpdySM: Making new server connection on index: " << server_idx;
   } else {
     server_idx = unused_server_interface_list.back();
     unused_server_interface_list.pop_back();
     sm_http_interface = server_interface_list.at(server_idx);
@@ skipping 229 matching lines @@
   DCHECK(buffered_spdy_framer_);
   return close_on_error_ || buffered_spdy_framer_->HasError();
 }
 
 const char* SpdySM::ErrorAsString() const {
   DCHECK(Error());
   DCHECK(buffered_spdy_framer_);
   return SpdyFramer::ErrorCodeToString(buffered_spdy_framer_->error_code());
 }
 
-void SpdySM::ResetForNewInterface(int32 server_idx) {
+void SpdySM::ResetForNewInterface(int32_t server_idx) {
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Reset for new interface: "
           << "server_idx: " << server_idx;
   unused_server_interface_list.push_back(server_idx);
 }
 
 void SpdySM::ResetForNewConnection() {
   // seq_num is not cleared, intentionally.
   buffered_spdy_framer_.reset();
   valid_spdy_session_ = false;
   client_output_ordering_.Reset();
   next_outgoing_stream_id_ = 2;
 }
 
 // Send a settings frame
 int SpdySM::PostAcceptHook() {
   // We should have buffered_spdy_framer_ set after reuse
   DCHECK(buffered_spdy_framer_);
   SettingsMap settings;
   settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, 100);
   SpdyFrame* settings_frame = buffered_spdy_framer_->CreateSettings(settings);
 
   VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Sending Settings Frame";
   EnqueueDataFrame(new SpdyFrameDataFrame(settings_frame));
   return 1;
 }
 
-void SpdySM::NewStream(uint32 stream_id,
-                       uint32 priority,
+void SpdySM::NewStream(uint32_t stream_id,
+                       uint32_t priority,
                        const std::string& filename) {
   MemCacheIter mci;
   mci.stream_id = stream_id;
   mci.priority = priority;
   // TODO(yhirano): The program will crash when
   // acceptor_->flip_handler_type_ != FLIP_HANDLER_SPDY_SERVER.
   // It should be fixed or an assertion should be placed.
   if (acceptor_->flip_handler_type_ == FLIP_HANDLER_SPDY_SERVER) {
     if (!memory_cache_->AssignFileData(filename, &mci)) {
       // error creating new stream.
       VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Sending ErrorNotFound";
       SendErrorNotFound(stream_id);
     } else {
       AddToOutputOrder(mci);
     }
   } else {
     AddToOutputOrder(mci);
   }
 }
 
 void SpdySM::AddToOutputOrder(const MemCacheIter& mci) {
   client_output_ordering_.AddToOutputOrder(mci);
 }
 
-void SpdySM::SendEOF(uint32 stream_id) { SendEOFImpl(stream_id); }
+void SpdySM::SendEOF(uint32_t stream_id) {
+  SendEOFImpl(stream_id);
+}
 
-void SpdySM::SendErrorNotFound(uint32 stream_id) {
+void SpdySM::SendErrorNotFound(uint32_t stream_id) {
   SendErrorNotFoundImpl(stream_id);
 }
 
-size_t SpdySM::SendSynStream(uint32 stream_id, const BalsaHeaders& headers) {
+size_t SpdySM::SendSynStream(uint32_t stream_id, const BalsaHeaders& headers) {
   return SendSynStreamImpl(stream_id, headers);
 }
 
-size_t SpdySM::SendSynReply(uint32 stream_id, const BalsaHeaders& headers) {
+size_t SpdySM::SendSynReply(uint32_t stream_id, const BalsaHeaders& headers) {
   return SendSynReplyImpl(stream_id, headers);
 }
 
-void SpdySM::SendDataFrame(uint32 stream_id,
+void SpdySM::SendDataFrame(uint32_t stream_id,
                            const char* data,
-                           int64 len,
-                           uint32 flags,
+                           int64_t len,
+                           uint32_t flags,
                            bool compress) {
   SpdyDataFlags spdy_flags = static_cast<SpdyDataFlags>(flags);
   SendDataFrameImpl(stream_id, data, len, spdy_flags, compress);
 }
 
-void SpdySM::SendEOFImpl(uint32 stream_id) {
+void SpdySM::SendEOFImpl(uint32_t stream_id) {
   SendDataFrame(stream_id, NULL, 0, DATA_FLAG_FIN, false);
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending EOF: " << stream_id;
   KillStream(stream_id);
   stream_to_smif_.erase(stream_id);
 }
 
-void SpdySM::SendErrorNotFoundImpl(uint32 stream_id) {
+void SpdySM::SendErrorNotFoundImpl(uint32_t stream_id) {
   BalsaHeaders my_headers;
   my_headers.SetFirstlineFromStringPieces("HTTP/1.1", "404", "Not Found");
   SendSynReplyImpl(stream_id, my_headers);
   SendDataFrame(stream_id, "wtf?", 4, DATA_FLAG_FIN, false);
   client_output_ordering_.RemoveStreamId(stream_id);
 }
 
-void SpdySM::KillStream(uint32 stream_id) {
+void SpdySM::KillStream(uint32_t stream_id) {
   client_output_ordering_.RemoveStreamId(stream_id);
 }
 
 void SpdySM::CopyHeaders(SpdyHeaderBlock& dest, const BalsaHeaders& headers) {
   for (BalsaHeaders::const_header_lines_iterator hi =
            headers.header_lines_begin();
        hi != headers.header_lines_end();
        ++hi) {
     // It is illegal to send SPDY headers with empty value or header
     // names.
@@ skipping 10 matching lines @@
       dest[key] = (std::string(fhi->second.data(), fhi->second.size()) + "\0" +
                    std::string(hi->second.data(), hi->second.size()));
     }
   }
 
   // These headers have no value
   dest.erase("X-Associated-Content");  // TODO(mbelshe): case-sensitive
   dest.erase("X-Original-Url");        // TODO(mbelshe): case-sensitive
 }
 
-size_t SpdySM::SendSynStreamImpl(uint32 stream_id,
+size_t SpdySM::SendSynStreamImpl(uint32_t stream_id,
                                  const BalsaHeaders& headers) {
   SpdyHeaderBlock block;
   CopyHeaders(block, headers);
   if (spdy_version() == SPDY2) {
     block["method"] = headers.request_method().as_string();
     if (!headers.HasHeader("version"))
       block["version"] = headers.request_version().as_string();
     if (headers.HasHeader("X-Original-Url")) {
       std::string original_url =
           headers.GetHeader("X-Original-Url").as_string();
@@ skipping 22 matching lines @@
   SpdyFrame* fsrcf = buffered_spdy_framer_->CreateSynStream(
       stream_id, 0, 0, CONTROL_FLAG_NONE, &block);
   size_t df_size = fsrcf->size();
   EnqueueDataFrame(new SpdyFrameDataFrame(fsrcf));
 
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending SynStreamheader "
           << stream_id;
   return df_size;
 }
 
-size_t SpdySM::SendSynReplyImpl(uint32 stream_id, const BalsaHeaders& headers) {
+size_t SpdySM::SendSynReplyImpl(uint32_t stream_id,
+                                const BalsaHeaders& headers) {
   SpdyHeaderBlock block;
   CopyHeaders(block, headers);
   if (spdy_version() == SPDY2) {
     block["status"] = headers.response_code().as_string() + " " +
         headers.response_reason_phrase().as_string();
     block["version"] = headers.response_version().as_string();
   } else {
     block[":status"] = headers.response_code().as_string() + " " +
         headers.response_reason_phrase().as_string();
     block[":version"] = headers.response_version().as_string();
   }
 
   DCHECK(buffered_spdy_framer_);
   SpdyFrame* fsrcf = buffered_spdy_framer_->CreateSynReply(
       stream_id, CONTROL_FLAG_NONE, &block);
   size_t df_size = fsrcf->size();
   EnqueueDataFrame(new SpdyFrameDataFrame(fsrcf));
 
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending SynReplyheader "
           << stream_id;
   return df_size;
 }
 
-void SpdySM::SendDataFrameImpl(uint32 stream_id,
+void SpdySM::SendDataFrameImpl(uint32_t stream_id,
                                const char* data,
-                               int64 len,
+                               int64_t len,
                                SpdyDataFlags flags,
                                bool compress) {
   DCHECK(buffered_spdy_framer_);
   // TODO(mbelshe):  We can't compress here - before going into the
   //                 priority queue.  Compression needs to be done
   //                 with late binding.
   if (len == 0) {
     SpdyFrame* fdf =
         buffered_spdy_framer_->CreateDataFrame(stream_id, data, len, flags);
     EnqueueDataFrame(new SpdyFrameDataFrame(fdf));
     return;
   }
 
   // Chop data frames into chunks so that one stream can't monopolize the
   // output channel.
   while (len > 0) {
-    int64 size = std::min(len, static_cast<int64>(kSpdySegmentSize));
+    int64_t size = std::min(len, static_cast<int64_t>(kSpdySegmentSize));
     SpdyDataFlags chunk_flags = flags;
 
     // If we chunked this block, and the FIN flag was set, there is more
     // data coming.  So, remove the flag.
     if ((size < len) && (flags & DATA_FLAG_FIN))
       chunk_flags = static_cast<SpdyDataFlags>(chunk_flags & ~DATA_FLAG_FIN);
 
     SpdyFrame* fdf = buffered_spdy_framer_->CreateDataFrame(
         stream_id, data, size, chunk_flags);
     EnqueueDataFrame(new SpdyFrameDataFrame(fdf));
@@ skipping 73 matching lines @@
   }
 }
 
 void SpdySM::CreateFramer(SpdyMajorVersion spdy_version) {
   DCHECK(!buffered_spdy_framer_);
   buffered_spdy_framer_.reset(new BufferedSpdyFramer(spdy_version, true));
   buffered_spdy_framer_->set_visitor(this);
 }
 
 }  // namespace net