1 // Copyright 2013 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifdef UNSAFE_BUFFERS_BUILD
6 // TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
7 #pragma allow_unsafe_buffers
8 #endif
9
10 #include "net/spdy/spdy_read_queue.h"
11
12 #include <algorithm>
13 #include <cstddef>
14 #include <memory>
15 #include <string>
16 #include <utility>
17
18 #include "base/functional/bind.h"
19 #include "base/functional/callback.h"
20 #include "net/spdy/spdy_buffer.h"
21 #include "testing/gtest/include/gtest/gtest.h"
22
23 namespace net::test {
24 namespace {
25
26 const char kData[] = "SPDY read queue test data.\0Some more data.";
27 const size_t kDataSize = std::size(kData);
28
29 // Enqueues |data| onto |queue| in chunks of at most |max_buffer_size|
30 // bytes.
EnqueueString(const std::string & data,size_t max_buffer_size,SpdyReadQueue * queue)31 void EnqueueString(const std::string& data,
32 size_t max_buffer_size,
33 SpdyReadQueue* queue) {
34 ASSERT_GT(data.size(), 0u);
35 ASSERT_GT(max_buffer_size, 0u);
36 size_t old_total_size = queue->GetTotalSize();
37 for (size_t i = 0; i < data.size();) {
38 size_t buffer_size = std::min(data.size() - i, max_buffer_size);
39 queue->Enqueue(std::make_unique<SpdyBuffer>(data.data() + i, buffer_size));
40 i += buffer_size;
41 EXPECT_FALSE(queue->IsEmpty());
42 EXPECT_EQ(old_total_size + i, queue->GetTotalSize());
43 }
44 }
45
46 // Dequeues all bytes in |queue| in chunks of at most
47 // |max_buffer_size| bytes and returns the data as a string.
DrainToString(size_t max_buffer_size,SpdyReadQueue * queue)48 std::string DrainToString(size_t max_buffer_size, SpdyReadQueue* queue) {
49 std::string data;
50
51 // Pad the buffer so we can detect out-of-bound writes.
52 size_t padding = std::max(static_cast<size_t>(4096), queue->GetTotalSize());
53 size_t buffer_size_with_padding = padding + max_buffer_size + padding;
54 auto buffer = std::make_unique<char[]>(buffer_size_with_padding);
55 std::memset(buffer.get(), 0, buffer_size_with_padding);
56 char* buffer_data = buffer.get() + padding;
57
58 while (!queue->IsEmpty()) {
59 size_t old_total_size = queue->GetTotalSize();
60 EXPECT_GT(old_total_size, 0u);
61 size_t dequeued_bytes = queue->Dequeue(buffer_data, max_buffer_size);
62
63 // Make sure |queue| doesn't write past either end of its given
64 // boundaries.
65 for (int i = 1; i <= static_cast<int>(padding); ++i) {
66 EXPECT_EQ('\0', buffer_data[-i]) << -i;
67 }
68 for (size_t i = 0; i < padding; ++i) {
69 EXPECT_EQ('\0', buffer_data[max_buffer_size + i]) << i;
70 }
71
72 data.append(buffer_data, dequeued_bytes);
73 EXPECT_EQ(dequeued_bytes, std::min(max_buffer_size, dequeued_bytes));
74 EXPECT_EQ(queue->GetTotalSize(), old_total_size - dequeued_bytes);
75 }
76 EXPECT_TRUE(queue->IsEmpty());
77 return data;
78 }
79
80 // Enqueue a test string with the given enqueue/dequeue max buffer
81 // sizes.
RunEnqueueDequeueTest(size_t enqueue_max_buffer_size,size_t dequeue_max_buffer_size)82 void RunEnqueueDequeueTest(size_t enqueue_max_buffer_size,
83 size_t dequeue_max_buffer_size) {
84 std::string data(kData, kDataSize);
85 SpdyReadQueue read_queue;
86 EnqueueString(data, enqueue_max_buffer_size, &read_queue);
87 const std::string& drained_data =
88 DrainToString(dequeue_max_buffer_size, &read_queue);
89 EXPECT_EQ(data, drained_data);
90 }
91
OnBufferDiscarded(bool * discarded,size_t * discarded_bytes,size_t delta,SpdyBuffer::ConsumeSource consume_source)92 void OnBufferDiscarded(bool* discarded,
93 size_t* discarded_bytes,
94 size_t delta,
95 SpdyBuffer::ConsumeSource consume_source) {
96 EXPECT_EQ(SpdyBuffer::DISCARD, consume_source);
97 *discarded = true;
98 *discarded_bytes = delta;
99 }
100
101 } // namespace
102
103 class SpdyReadQueueTest : public ::testing::Test {};
104
105 // Call RunEnqueueDequeueTest() with various buffer size combinatinos.
106
TEST_F(SpdyReadQueueTest,LargeEnqueueAndDequeueBuffers)107 TEST_F(SpdyReadQueueTest, LargeEnqueueAndDequeueBuffers) {
108 RunEnqueueDequeueTest(2 * kDataSize, 2 * kDataSize);
109 }
110
TEST_F(SpdyReadQueueTest,OneByteEnqueueAndDequeueBuffers)111 TEST_F(SpdyReadQueueTest, OneByteEnqueueAndDequeueBuffers) {
112 RunEnqueueDequeueTest(1, 1);
113 }
114
TEST_F(SpdyReadQueueTest,CoprimeBufferSizes)115 TEST_F(SpdyReadQueueTest, CoprimeBufferSizes) {
116 RunEnqueueDequeueTest(2, 3);
117 RunEnqueueDequeueTest(3, 2);
118 }
119
TEST_F(SpdyReadQueueTest,Clear)120 TEST_F(SpdyReadQueueTest, Clear) {
121 auto buffer = std::make_unique<SpdyBuffer>(kData, kDataSize);
122 bool discarded = false;
123 size_t discarded_bytes = 0;
124 buffer->AddConsumeCallback(
125 base::BindRepeating(&OnBufferDiscarded, &discarded, &discarded_bytes));
126
127 SpdyReadQueue read_queue;
128 read_queue.Enqueue(std::move(buffer));
129
130 EXPECT_FALSE(discarded);
131 EXPECT_EQ(0u, discarded_bytes);
132 EXPECT_FALSE(read_queue.IsEmpty());
133
134 read_queue.Clear();
135
136 EXPECT_TRUE(discarded);
137 EXPECT_EQ(kDataSize, discarded_bytes);
138 EXPECT_TRUE(read_queue.IsEmpty());
139 }
140
141 } // namespace net::test
142