Switch to standard integer types in net/.

net/spdy/spdy_framer_test.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_framer.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/mock_spdy_framer_visitor.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_frame_reader.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/platform_test.h"
 
@@ skipping 125 matching lines @@
       scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
       ResetBuffer();
       memcpy(buffer_.get(), frame->data(), framer.GetHeadersMinimumSize());
       size_ += framer.GetSynStreamMinimumSize();
     }
 
     void OnRstStream(SpdyStreamId stream_id,
                      SpdyRstStreamStatus status) override {
       LOG(FATAL);
     }
-    void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override {
+    void OnSetting(SpdySettingsIds id, uint8_t flags, uint32_t value) override {
       LOG(FATAL);
     }
     void OnPing(SpdyPingId unique_id, bool is_ack) override { LOG(FATAL); }
     void OnSettingsEnd() override { LOG(FATAL); }
     void OnGoAway(SpdyStreamId last_accepted_stream_id,
                   SpdyGoAwayStatus status) override {
       LOG(FATAL);
     }
 
     void OnHeaders(SpdyStreamId stream_id,
@@ skipping 33 matching lines @@
       memcpy(buffer_.get(), frame->data(), framer.GetPushPromiseMinimumSize());
       size_ += framer.GetPushPromiseMinimumSize();
     }
 
     void OnContinuation(SpdyStreamId stream_id, bool end) override {
       LOG(FATAL);
     }
 
     void OnPriority(SpdyStreamId stream_id,
                     SpdyStreamId parent_stream_id,
-                    uint8 weight,
+                    uint8_t weight,
                     bool exclusive) override {
       // Do nothing.
     }
 
     bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
       LOG(FATAL);
       return false;
     }
 
     char* ReleaseBuffer() {
@@ skipping 169 matching lines @@
     ++fin_frame_count_;
   }
 
   bool OnRstStreamFrameData(const char* rst_stream_data, size_t len) override {
     if ((rst_stream_data != NULL) && (len > 0)) {
       fin_opaque_data_ += string(rst_stream_data, len);
     }
     return true;
   }
 
-  void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override {
+  void OnSetting(SpdySettingsIds id, uint8_t flags, uint32_t value) override {
     ++setting_count_;
   }
 
   void OnSettingsAck() override {
     DCHECK_LT(SPDY3, framer_.protocol_version());
     ++settings_ack_received_;
   }
 
   void OnSettingsEnd() override {
     if (framer_.protocol_version() <= SPDY3) { return; }
@@ skipping 52 matching lines @@
     }
     for (const SpdyAltSvcWireFormat::AlternativeService& altsvc :
          altsvc_vector) {
       test_altsvc_ir_.add_altsvc(altsvc);
     }
     ++altsvc_count_;
   }
 
   void OnPriority(SpdyStreamId stream_id,
                   SpdyStreamId parent_stream_id,
-                  uint8 weight,
+                  uint8_t weight,
                   bool exclusive) override {
     ++priority_count_;
   }
 
   bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
     DLOG(INFO) << "Unknown frame type " << frame_type;
     return on_unknown_frame_result_;
   }
 
   void OnSendCompressedFrame(SpdyStreamId stream_id,
@@ skipping 125 matching lines @@
 StringPiece GetSerializedHeaders(const SpdyFrame* frame,
                                  const SpdyFramer& framer) {
   SpdyFrameReader reader(frame->data(), frame->size());
   if (framer.protocol_version() > SPDY3) {
     reader.Seek(3);  // Seek past the frame length.
   } else {
     reader.Seek(2);  // Seek past the frame length.
   }
   SpdyFrameType frame_type;
   if (framer.protocol_version() > SPDY3) {
-    uint8 serialized_type;
+    uint8_t serialized_type;
     reader.ReadUInt8(&serialized_type);
     frame_type = SpdyConstants::ParseFrameType(framer.protocol_version(),
                                                serialized_type);
     DCHECK_EQ(HEADERS, frame_type);
-    uint8 flags;
+    uint8_t flags;
     reader.ReadUInt8(&flags);
     if (flags & HEADERS_FLAG_PRIORITY) {
       frame_type = SYN_STREAM;
     }
   } else {
-    uint16 serialized_type;
+    uint16_t serialized_type;
     reader.ReadUInt16(&serialized_type);
     frame_type = SpdyConstants::ParseFrameType(framer.protocol_version(),
                                                serialized_type);
     DCHECK(frame_type == HEADERS ||
            frame_type == SYN_STREAM) << frame_type;
   }
 
   if (frame_type == SYN_STREAM) {
     return StringPiece(frame->data() + framer.GetSynStreamMinimumSize(),
                        frame->size() - framer.GetSynStreamMinimumSize());
@@ skipping 1886 matching lines @@
       0x01, 0x00, 0x00, 0x07,
       0x0a, 0x0b, 0x0c, 0x0d,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x06, 0x04,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x04, 0x0a,
       0x0b, 0x0c, 0x0d,
     };
 
-    uint32 kValue = 0x0a0b0c0d;
+    uint32_t kValue = 0x0a0b0c0d;
     SpdySettingsIR settings_ir;
 
     SpdySettingsFlags kFlags = static_cast<SpdySettingsFlags>(0x01);
     SpdySettingsIds kId = SETTINGS_INITIAL_WINDOW_SIZE;
     settings_ir.AddSetting(kId,
                            kFlags & SETTINGS_FLAG_PLEASE_PERSIST,
                            kFlags & SETTINGS_FLAG_PERSISTED,
                            kValue);
 
     scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
@@ skipping 2336 matching lines @@
     EXPECT_EQ(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   }
 }
 
 TEST_P(SpdyFramerTest, DataFrameFlagsV2V3) {
   if (spdy_version_ > SPDY3) {
     return;
   }
 
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyDataIR data_ir(1, "hello");
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     SetFrameFlags(frame.get(), flags, spdy_version_);
@@ skipping 20 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, DataFrameFlagsV4) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
-  uint8 valid_data_flags = DATA_FLAG_FIN | DATA_FLAG_END_SEGMENT |
-      DATA_FLAG_PADDED;
+  uint8_t valid_data_flags =
+      DATA_FLAG_FIN | DATA_FLAG_END_SEGMENT | DATA_FLAG_PADDED;
 
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyDataIR data_ir(1, "hello");
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     SetFrameFlags(frame.get(), flags, spdy_version_);
@@ skipping 26 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, SynStreamFrameFlags) {
   if (!IsSpdy2() && !IsSpdy3()) {
     // SYN_STREAM not supported in SPDY>3
     return;
   }
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(8, SYN_STREAM, _, _));
@@ skipping 33 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, SynReplyFrameFlags) {
   if (!IsSpdy2() && !IsSpdy3()) {
     // SYN_REPLY not supported in SPDY>3
     return;
   }
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdySynReplyIR syn_reply(37);
     syn_reply.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
@@ skipping 18 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, RstStreamFrameFlags) {
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyRstStreamIR rst_stream(13, RST_STREAM_CANCEL);
     scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
     SetFrameFlags(frame.get(), flags, spdy_version_);
@@ skipping 13 matching lines @@
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, SettingsFrameFlagsOldFormat) {
   if (spdy_version_ > SPDY3) { return; }
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdySettingsIR settings_ir;
     settings_ir.AddSetting(SETTINGS_UPLOAD_BANDWIDTH,
                            false,
@@ skipping 21 matching lines @@
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, SettingsFrameFlags) {
   if (spdy_version_ <= SPDY3) { return; }
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdySettingsIR settings_ir;
     settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 0, 0, 16);
     scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
@@ skipping 21 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, GoawayFrameFlags) {
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyGoAwayIR goaway_ir(97, GOAWAY_OK, "test");
     scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir));
     SetFrameFlags(frame.get(), flags, spdy_version_);
@@ skipping 12 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, HeadersFrameFlags) {
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyHeadersIR headers_ir(57);
     if (IsHttp2() && (flags & HEADERS_FLAG_PRIORITY)) {
       headers_ir.set_priority(3);
       headers_ir.set_has_priority(true);
       headers_ir.set_parent_stream_id(5);
       headers_ir.set_exclusive(true);
     }
     headers_ir.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
-    uint8 set_flags = flags;
+    uint8_t set_flags = flags;
     if (IsHttp2()) {
       // TODO(jgraettinger): Add padding to SpdyHeadersIR,
       // and implement framing.
       set_flags &= ~HEADERS_FLAG_PADDED;
     }
     SetFrameFlags(frame.get(), set_flags, spdy_version_);
 
     if (!IsHttp2() && flags & ~CONTROL_FLAG_FIN) {
       EXPECT_CALL(visitor, OnError(_));
     } else if (IsHttp2() && flags & ~(CONTROL_FLAG_FIN |
@@ skipping 51 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, PingFrameFlags) {
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     scoped_ptr<SpdyFrame> frame(framer.SerializePing(SpdyPingIR(42)));
     SetFrameFlags(frame.get(), flags, spdy_version_);
 
@@ skipping 15 matching lines @@
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, WindowUpdateFrameFlags) {
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
         SpdyWindowUpdateIR(4, 1024)));
     SetFrameFlags(frame.get(), flags, spdy_version_);
@@ skipping 16 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, PushPromiseFrameFlags) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, PUSH_PROMISE, _, _));
@@ skipping 28 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, ContinuationFrameFlags) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
-  uint8 flags = 0;
+  uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, HEADERS, _, _));
@@ skipping 68 matching lines @@
   EXPECT_CALL(visitor, OnSynStream(1, 0, 1, false, false));
   EXPECT_CALL(visitor, OnControlFrameHeaderData(1, NULL, 0));
 
   framer.ProcessInput(frame->data(), framer.GetSynStreamMinimumSize());
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, SettingsFlagsAndId) {
-  const uint32 kId = 0x020304;
-  const uint32 kFlags = 0x01;
-  const uint32 kWireFormat =
+  const uint32_t kId = 0x020304;
+  const uint32_t kFlags = 0x01;
+  const uint32_t kWireFormat =
       base::HostToNet32(IsSpdy2() ? 0x04030201 : 0x01020304);
 
   SettingsFlagsAndId id_and_flags =
       SettingsFlagsAndId::FromWireFormat(spdy_version_, kWireFormat);
   EXPECT_EQ(kId, id_and_flags.id());
   EXPECT_EQ(kFlags, id_and_flags.flags());
   EXPECT_EQ(kWireFormat, id_and_flags.GetWireFormat(spdy_version_));
 }
 
 // Test handling of a RST_STREAM with out-of-bounds status codes.
@@ skipping 519 matching lines @@
 
     EXPECT_EQ(1, visitor->data_frame_count_);
     EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
     EXPECT_EQ(0, visitor->headers_frame_count_);
   }
 }
 
 }  // namespace test
 
 }  // namespace net