Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(134)

Side by Side Diff: net/quic/quic_data_reader.cc

Issue 11125002: Add QuicFramer and friends. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: narrowing in Created 8 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/quic/quic_data_reader.h"
6
7 using base::StringPiece;
8
9 namespace net {
10
11 QuicDataReader::QuicDataReader(const char* data, const size_t len)
12 : data_(data),
13 len_(len),
14 pos_(0) {
15 }
16
17 bool QuicDataReader::ReadUInt16(uint16* result) {
18 // Make sure that we have the whole uint16.
19 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
20 OnFailure();
21 return false;
22 }
23
24 // Read into result.
25 *result = *reinterpret_cast<const uint16*>(data_ + pos_);
26
27 // Iterate.
28 pos_ += 2;
29
30 return true;
31 }
32
33 bool QuicDataReader::ReadUInt32(uint32* result) {
34 // Make sure that we have the whole uint32.
35 if (!CanRead(4)) {
36 OnFailure();
37 return false;
38 }
39
40 // Read into result.
41 *result = *reinterpret_cast<const uint32*>(data_ + pos_);
42
43 // Iterate.
44 pos_ += 4;
45
46 return true;
47 }
48
49 bool QuicDataReader::ReadUInt48(uint64* result) {
50 // 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.
51 if (!CanRead(6)) {
52 OnFailure();
53 return false;
54 }
55
56 uint32 lo;
57 if (!ReadUInt32(&lo)) {
58 return false;
59 }
60
61 uint16 hi;
62 if (!ReadUInt16(&hi)) {
63 return false;
64 }
65
66 *result = hi;
67 *result <<= 32;
68 *result += lo;
69
70 return true;
71 }
72
73 bool QuicDataReader::ReadUInt64(uint64* result) {
74 // Make sure that we have the whole uint64.
75 if (!CanRead(8)) {
76 OnFailure();
77 return false;
78 }
79
80 // Read into result.
81 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.
82 *result = *reinterpret_cast<const uint64*>(data_ + pos_);
83 LOG(INFO) << "here";
84
85 // Iterate.
86 pos_ += 8;
87
88 return true;
89 }
90
91 bool QuicDataReader::ReadUInt128(uint128* result) {
92 uint64 high_hash;
93 uint64 low_hash;
94
95 if (!ReadUInt64(&low_hash)) {
96 return false;
97 }
98 if (!ReadUInt64(&high_hash)) {
99 return false;
100 }
101
102 *result = uint128(high_hash, low_hash);
103 return true;
104 }
105
106 bool QuicDataReader::ReadStringPiece16(StringPiece* result) {
107 // Read resultant length.
108 uint16 result_len;
109 if (!ReadUInt16(&result_len)) {
110 // OnFailure() already called.
111 return false;
112 }
113
114 return ReadStringPiece(result, result_len);
115 }
116
117 bool QuicDataReader::ReadBytes(void* result, size_t size) {
118 // Make sure that we have enough data to read.
119 if (!CanRead(size)) {
120 OnFailure();
121 return false;
122 }
123
124 // Read into result.
125 memcpy(result, data_ + pos_, size);
126
127 // Iterate.
128 pos_ += size;
129
130 return true;
131 }
132
133
134 bool QuicDataReader::ReadStringPiece(StringPiece* result, size_t size) {
135 // Make sure that we have enough data to read.
136 if (!CanRead(size)) {
137 OnFailure();
138 return false;
139 }
140
141 // Set result.
142 result->set(data_ + pos_, size);
143
144 // Iterate.
145 pos_ += size;
146
147 return true;
148 }
149
150 StringPiece QuicDataReader::PeekRemainingPayload() {
151 return StringPiece(data_ + pos_, len_ - pos_);
152 }
153
154 StringPiece QuicDataReader::ReadRemainingPayload() {
155 StringPiece payload = PeekRemainingPayload();
156 pos_ = len_;
157 return payload;
158 }
159
160 bool QuicDataReader::IsDoneReading() const {
161 return len_ == pos_;
162 }
163
164 size_t QuicDataReader::BytesRemaining() const {
165 return len_ - pos_;
166 }
167
168 bool QuicDataReader::CanRead(size_t bytes) const {
169 return bytes <= (len_ - pos_);
170 }
171
172 void QuicDataReader::OnFailure() {
173 // Set our iterator to the end of the buffer so that further reads fail
174 // immediately.
175 pos_ = len_;
176 }
177
178 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698