Index: net/quic/quic_data_reader.cc |
diff --git a/net/quic/quic_data_reader.cc b/net/quic/quic_data_reader.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..2ffc284a277057b9e899045d2cd3de46924b8d17 |
--- /dev/null |
+++ b/net/quic/quic_data_reader.cc |
@@ -0,0 +1,178 @@ |
+// 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/quic/quic_data_reader.h" |
+ |
+using base::StringPiece; |
+ |
+namespace net { |
+ |
+QuicDataReader::QuicDataReader(const char* data, const size_t len) |
+ : data_(data), |
+ len_(len), |
+ pos_(0) { |
+} |
+ |
+bool QuicDataReader::ReadUInt16(uint16* result) { |
+ // Make sure that we have the whole uint16. |
+ if (!CanRead(2)) { |
jar (doing other things)
2012/10/14 23:04:38
nit: probably better is to use:
CanRead(sizeof(*re
Ryan Hamilton
2012/10/15 21:22:08
Added TODO. Will address in a follow on CL once t
|
+ OnFailure(); |
+ return false; |
+ } |
+ |
+ // Read into result. |
+ *result = *reinterpret_cast<const uint16*>(data_ + pos_); |
+ |
+ // Iterate. |
+ pos_ += 2; |
+ |
+ return true; |
+} |
+ |
+bool QuicDataReader::ReadUInt32(uint32* result) { |
+ // Make sure that we have the whole uint32. |
+ if (!CanRead(4)) { |
+ OnFailure(); |
+ return false; |
+ } |
+ |
+ // Read into result. |
+ *result = *reinterpret_cast<const uint32*>(data_ + pos_); |
+ |
+ // Iterate. |
+ pos_ += 4; |
+ |
+ return true; |
+} |
+ |
+bool QuicDataReader::ReadUInt48(uint64* result) { |
+ // Make sure that we have the whole uint48. |
jar (doing other things)
2012/10/14 23:04:38
nit: you don't need lines 51-54, since the other r
Ryan Hamilton
2012/10/15 21:22:08
Done.
|
+ if (!CanRead(6)) { |
+ OnFailure(); |
+ return false; |
+ } |
+ |
+ uint32 lo; |
+ if (!ReadUInt32(&lo)) { |
+ return false; |
+ } |
+ |
+ uint16 hi; |
+ if (!ReadUInt16(&hi)) { |
+ return false; |
+ } |
+ |
+ *result = hi; |
+ *result <<= 32; |
+ *result += lo; |
+ |
+ return true; |
+} |
+ |
+bool QuicDataReader::ReadUInt64(uint64* result) { |
+ // Make sure that we have the whole uint64. |
+ if (!CanRead(8)) { |
+ OnFailure(); |
+ return false; |
+ } |
+ |
+ // Read into result. |
+ LOG(INFO) << "here"; |
jar (doing other things)
2012/10/14 23:04:38
nit: DLOG?
Ryan Hamilton
2012/10/15 21:22:08
Part of my on-going debugging. will remove.
|
+ *result = *reinterpret_cast<const uint64*>(data_ + pos_); |
+ LOG(INFO) << "here"; |
+ |
+ // Iterate. |
+ pos_ += 8; |
+ |
+ return true; |
+} |
+ |
+bool QuicDataReader::ReadUInt128(uint128* result) { |
+ uint64 high_hash; |
+ uint64 low_hash; |
+ |
+ if (!ReadUInt64(&low_hash)) { |
+ return false; |
+ } |
+ if (!ReadUInt64(&high_hash)) { |
+ return false; |
+ } |
+ |
+ *result = uint128(high_hash, low_hash); |
+ return true; |
+} |
+ |
+bool QuicDataReader::ReadStringPiece16(StringPiece* result) { |
+ // Read resultant length. |
+ uint16 result_len; |
+ if (!ReadUInt16(&result_len)) { |
+ // OnFailure() already called. |
+ return false; |
+ } |
+ |
+ return ReadStringPiece(result, result_len); |
+} |
+ |
+bool QuicDataReader::ReadBytes(void* result, size_t size) { |
+ // Make sure that we have enough data to read. |
+ if (!CanRead(size)) { |
+ OnFailure(); |
+ return false; |
+ } |
+ |
+ // Read into result. |
+ memcpy(result, data_ + pos_, size); |
+ |
+ // Iterate. |
+ pos_ += size; |
+ |
+ return true; |
+} |
+ |
+ |
+bool QuicDataReader::ReadStringPiece(StringPiece* result, size_t size) { |
+ // Make sure that we have enough data to read. |
+ if (!CanRead(size)) { |
+ OnFailure(); |
+ return false; |
+ } |
+ |
+ // Set result. |
+ result->set(data_ + pos_, size); |
+ |
+ // Iterate. |
+ pos_ += size; |
+ |
+ return true; |
+} |
+ |
+StringPiece QuicDataReader::PeekRemainingPayload() { |
+ return StringPiece(data_ + pos_, len_ - pos_); |
+} |
+ |
+StringPiece QuicDataReader::ReadRemainingPayload() { |
+ StringPiece payload = PeekRemainingPayload(); |
+ pos_ = len_; |
+ return payload; |
+} |
+ |
+bool QuicDataReader::IsDoneReading() const { |
+ return len_ == pos_; |
+} |
+ |
+size_t QuicDataReader::BytesRemaining() const { |
+ return len_ - pos_; |
+} |
+ |
+bool QuicDataReader::CanRead(size_t bytes) const { |
+ return bytes <= (len_ - pos_); |
+} |
+ |
+void QuicDataReader::OnFailure() { |
+ // Set our iterator to the end of the buffer so that further reads fail |
+ // immediately. |
+ pos_ = len_; |
+} |
+ |
+} // namespace net |