Switch to standard integer types in net/.

net/tools/flip_server/spdy_interface_test.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 "net/tools/flip_server/spdy_interface.h"
 
 #include <list>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
@@ skipping 58 matching lines @@
   MOCK_METHOD4(OnStreamFrameData, void(SpdyStreamId,
                                        const char*,
                                        size_t,
                                        bool));
   MOCK_METHOD2(OnStreamPadding, void(SpdyStreamId, size_t));
   MOCK_METHOD1(OnHeaderFrameStart,
                SpdyHeadersHandlerInterface*(SpdyStreamId stream_id));
   MOCK_METHOD2(OnHeaderFrameEnd,
                void(SpdyStreamId stream_id, bool end_headers));
   MOCK_METHOD1(OnSettings, void(bool clear_persisted));
-  MOCK_METHOD3(OnSetting, void(SpdySettingsIds, uint8, uint32));
+  MOCK_METHOD3(OnSetting, void(SpdySettingsIds, uint8_t, uint32_t));
   MOCK_METHOD2(OnPing, void(SpdyPingId unique_id, bool is_ack));
   MOCK_METHOD2(OnRstStream, void(SpdyStreamId, SpdyRstStreamStatus));
   MOCK_METHOD3(OnGoAway, void(SpdyStreamId, SpdyGoAwayStatus, StringPiece));
   MOCK_METHOD2(OnWindowUpdate, void(SpdyStreamId, int));
   MOCK_METHOD3(OnPushPromise,
                void(SpdyStreamId, SpdyStreamId, const SpdyHeaderBlock&));
   MOCK_METHOD2(OnUnknownFrame, bool(SpdyStreamId stream_id, int frame_type));
 };
 
 class FakeSMConnection : public SMConnection {
@@ skipping 92 matching lines @@
     }
     OutputList& output_list = *connection_->output_list();
     for (OutputList::const_iterator i = output_list.begin();
          i != output_list.end();
          ++i) {
       delete *i;
     }
     output_list.clear();
   }
 
-  bool HasStream(uint32 stream_id) {
+  bool HasStream(uint32_t stream_id) {
     return interface_->output_ordering().ExistsInPriorityMaps(stream_id);
   }
 
  protected:
   scoped_ptr<MockSMInterface> mock_another_interface_;
   scoped_ptr<MemoryCache> memory_cache_;
   scoped_ptr<FlipAcceptor> acceptor_;
   scoped_ptr<EpollServer> epoll_server_;
   scoped_ptr<FakeSMConnection> connection_;
   scoped_ptr<TestSpdySM> interface_;
@@ skipping 21 matching lines @@
     InSequence s;
     EXPECT_CALL(*connection_, InitSMConnection(_, _, _, _, _, _, _, _));
   }
   interface_->InitSMConnection(
       NULL, NULL, epoll_server_.get(), -1, "", "", "", false);
 }
 
 TEST_P(SpdySMProxyTest, OnStreamFrameData) {
   BufferedSpdyFramerVisitorInterface* visitor = interface_.get();
   scoped_ptr<MockSMInterface> mock_interface(new MockSMInterface);
-  uint32 stream_id = 92;
-  uint32 associated_id = 43;
+  uint32_t stream_id = 92;
+  uint32_t associated_id = 43;
   SpdyHeaderBlock block;
   testing::MockFunction<void(int)> checkpoint;  // NOLINT
 
   scoped_ptr<SpdyFrame> frame(spdy_framer_->CreatePingFrame(12, false));
   block[":method"] = "GET";
   block[":host"] = "www.example.com";
   block[":path"] = "/path";
   block[":scheme"] = "http";
   block["foo"] = "bar";
   {
     InSequence s;
     EXPECT_CALL(*interface_,
                 FindOrMakeNewSMConnectionInterface(_, _))
         .WillOnce(Return(mock_interface.get()));
     EXPECT_CALL(*mock_interface, SetStreamID(stream_id));
     EXPECT_CALL(*mock_interface, ProcessWriteInput(_, _)).Times(1);
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(*mock_interface,
                 ProcessWriteInput(frame->data(), frame->size())).Times(1);
   }
 
   visitor->OnSynStream(stream_id, associated_id, 0, false, false, block);
   checkpoint.Call(0);
   visitor->OnStreamFrameData(stream_id, frame->data(), frame->size(), true);
 }
 
 TEST_P(SpdySMProxyTest, OnRstStream) {
   BufferedSpdyFramerVisitorInterface* visitor = interface_.get();
-  uint32 stream_id = 82;
+  uint32_t stream_id = 82;
   MemCacheIter mci;
   mci.stream_id = stream_id;
 
   {
     BalsaHeaders headers;
     std::string filename = "foobar";
     memory_cache_->InsertFile(&headers, filename, "");
     mci.file_data = memory_cache_->GetFileData(filename);
   }
 
   interface_->AddToOutputOrder(mci);
   ASSERT_TRUE(HasStream(stream_id));
   visitor->OnRstStream(stream_id, RST_STREAM_INVALID);
   ASSERT_FALSE(HasStream(stream_id));
 }
 
 TEST_P(SpdySMProxyTest, ProcessReadInput) {
   ASSERT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME,
             interface_->spdy_framer()->state());
   interface_->ProcessReadInput("", 1);
   ASSERT_EQ(SpdyFramer::SPDY_READING_COMMON_HEADER,
             interface_->spdy_framer()->state());
 }
 
 TEST_P(SpdySMProxyTest, ResetForNewConnection) {
-  uint32 stream_id = 13;
+  uint32_t stream_id = 13;
   MemCacheIter mci;
   mci.stream_id = stream_id;
   // incomplete input
   const char input[] = {'\0', '\0', '\0'};
 
   {
     BalsaHeaders headers;
     std::string filename = "foobar";
     memory_cache_->InsertFile(&headers, filename, "");
     mci.file_data = memory_cache_->GetFileData(filename);
@@ skipping 38 matching lines @@
   spdy_framer_->ProcessInput(df->data, df->size);
 }
 
 TEST_P(SpdySMProxyTest, NewStream) {
   // TODO(yhirano): SpdySM::NewStream leads to crash when
   // acceptor_->flip_handler_type_ != FLIP_HANDLER_SPDY_SERVER.
   // It should be fixed though I don't know the solution now.
 }
 
 TEST_P(SpdySMProxyTest, AddToOutputOrder) {
-  uint32 stream_id = 13;
+  uint32_t stream_id = 13;
   MemCacheIter mci;
   mci.stream_id = stream_id;
 
   {
     BalsaHeaders headers;
     std::string filename = "foobar";
     memory_cache_->InsertFile(&headers, filename, "");
     mci.file_data = memory_cache_->GetFileData(filename);
   }
 
   interface_->AddToOutputOrder(mci);
   ASSERT_TRUE(HasStream(stream_id));
 }
 
 TEST_P(SpdySMProxyTest, SendErrorNotFound) {
-  uint32 stream_id = 82;
+  uint32_t stream_id = 82;
   SpdyHeaderBlock actual_header_block;
   const char* actual_data;
   size_t actual_size;
   testing::MockFunction<void(int)> checkpoint;  // NOLINT
 
   interface_->SendErrorNotFound(stream_id);
 
   ASSERT_EQ(2u, connection_->output_list()->size());
 
   {
@@ skipping 27 matching lines @@
   spdy_framer_->ProcessInput(df->data, df->size);
 
   ASSERT_EQ(2, spdy_framer_->frames_received());
   ASSERT_EQ(2u, actual_header_block.size());
   ASSERT_EQ("404 Not Found", actual_header_block[":status"]);
   ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]);
   ASSERT_EQ("wtf?", StringPiece(actual_data, actual_size));
 }
 
 TEST_P(SpdySMProxyTest, SendSynStream) {
-  uint32 stream_id = 82;
+  uint32_t stream_id = 82;
   BalsaHeaders headers;
   SpdyHeaderBlock actual_header_block;
   headers.AppendHeader("key1", "value1");
   headers.AppendHeader("Host", "www.example.com");
   headers.SetRequestFirstlineFromStringPieces("GET", "/path", "HTTP/1.1");
 
   interface_->SendSynStream(stream_id, headers);
 
   ASSERT_EQ(1u, connection_->output_list()->size());
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
@@ skipping 10 matching lines @@
   ASSERT_EQ(1, spdy_framer_->frames_received());
   ASSERT_EQ(5u, actual_header_block.size());
   ASSERT_EQ("GET", actual_header_block[":method"]);
   ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]);
   ASSERT_EQ("/path", actual_header_block[":path"]);
   ASSERT_EQ("www.example.com", actual_header_block[":host"]);
   ASSERT_EQ("value1", actual_header_block["key1"]);
 }
 
 TEST_P(SpdySMProxyTest, SendSynReply) {
-  uint32 stream_id = 82;
+  uint32_t stream_id = 82;
   BalsaHeaders headers;
   SpdyHeaderBlock actual_header_block;
   headers.AppendHeader("key1", "value1");
   headers.SetResponseFirstlineFromStringPieces("HTTP/1.1", "200", "OK");
 
   interface_->SendSynReply(stream_id, headers);
 
   ASSERT_EQ(1u, connection_->output_list()->size());
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
@@ skipping 13 matching lines @@
 
   spdy_framer_->ProcessInput(df->data, df->size);
   ASSERT_EQ(1, spdy_framer_->frames_received());
   ASSERT_EQ(3u, actual_header_block.size());
   ASSERT_EQ("200 OK", actual_header_block[":status"]);
   ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]);
   ASSERT_EQ("value1", actual_header_block["key1"]);
 }
 
 TEST_P(SpdySMProxyTest, SendDataFrame) {
-  uint32 stream_id = 133;
+  uint32_t stream_id = 133;
   SpdyDataFlags flags = DATA_FLAG_NONE;
   const char* actual_data;
   size_t actual_size;
 
   interface_->SendDataFrame(stream_id, "hello", 5, flags, true);
 
   ASSERT_EQ(1u, connection_->output_list()->size());
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
 
   {
     InSequence s;
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnDataFrameHeader(stream_id, _, false));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnStreamFrameData(stream_id, _, _, false))
         .WillOnce(DoAll(SaveArg<1>(&actual_data), SaveArg<2>(&actual_size)));
   }
 
   spdy_framer_->ProcessInput(df->data, df->size);
   ASSERT_EQ(1, spdy_framer_->frames_received());
   ASSERT_EQ("hello", StringPiece(actual_data, actual_size));
 }
 
 TEST_P(SpdySMProxyTest, SendLongDataFrame) {
-  uint32 stream_id = 133;
+  uint32_t stream_id = 133;
   SpdyDataFlags flags = DATA_FLAG_NONE;
   const char* actual_data;
   size_t actual_size;
 
   std::string data = std::string(kSpdySegmentSize, 'a') +
                      std::string(kSpdySegmentSize, 'b') + "c";
   interface_->SendDataFrame(stream_id, data.data(), data.size(), flags, true);
 
   {
     InSequence s;
@@ skipping 19 matching lines @@
   ASSERT_EQ(std::string(kSpdySegmentSize, 'b'),
             StringPiece(actual_data, actual_size));
 
   df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
   ASSERT_EQ("c", StringPiece(actual_data, actual_size));
 }
 
 TEST_P(SpdySMServerTest, OnSynStream) {
   BufferedSpdyFramerVisitorInterface* visitor = interface_.get();
-  uint32 stream_id = 82;
+  uint32_t stream_id = 82;
   SpdyHeaderBlock spdy_headers;
   spdy_headers["url"] = "http://www.example.com/path";
   spdy_headers["method"] = "GET";
   spdy_headers["scheme"] = "http";
   spdy_headers["version"] = "HTTP/1.1";
 
   {
     BalsaHeaders headers;
     memory_cache_->InsertFile(&headers, "GET_/path", "");
   }
   visitor->OnSynStream(stream_id, 0, 0, true, true, spdy_headers);
   ASSERT_TRUE(HasStream(stream_id));
 }
 
 TEST_P(SpdySMServerTest, NewStream) {
-  uint32 stream_id = 13;
+  uint32_t stream_id = 13;
   std::string filename = "foobar";
 
   {
     BalsaHeaders headers;
     memory_cache_->InsertFile(&headers, filename, "");
   }
 
   interface_->NewStream(stream_id, 0, filename);
   ASSERT_TRUE(HasStream(stream_id));
 }
 
 TEST_P(SpdySMServerTest, NewStreamError) {
-  uint32 stream_id = 82;
+  uint32_t stream_id = 82;
   SpdyHeaderBlock actual_header_block;
   const char* actual_data;
   size_t actual_size;
   testing::MockFunction<void(int)> checkpoint;  // NOLINT
 
   interface_->NewStream(stream_id, 0, "nonexistingfile");
 
   ASSERT_EQ(2u, connection_->output_list()->size());
 
   {
@@ skipping 28 matching lines @@
   ASSERT_EQ(2, spdy_framer_->frames_received());
   ASSERT_EQ(2u, actual_header_block.size());
   ASSERT_EQ("404 Not Found", actual_header_block["status"]);
   ASSERT_EQ("HTTP/1.1", actual_header_block["version"]);
   ASSERT_EQ("wtf?", StringPiece(actual_data, actual_size));
 }
 
 }  // namespace
 
 }  // namespace net