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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: net/filter/filter_unittest.cc

Issue 1662763002: [ON HOLD] Implement pull-based design for content decoding (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: rebased Created 4 years, 4 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
« no previous file with comments | « net/filter/filter.cc ('k') | net/filter/gzip_filter.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2014 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/filter/filter.h"
6
7 #include <utility>
8
9 #include "base/macros.h"
10 #include "net/base/io_buffer.h"
11 #include "net/filter/mock_filter_context.h"
12 #include "testing/gtest/include/gtest/gtest.h"
13
14 namespace net {
15
16 namespace {
17
18 class PassThroughFilter : public Filter {
19 public:
20 PassThroughFilter() : Filter(FILTER_TYPE_UNSUPPORTED) {}
21
22 FilterStatus ReadFilteredData(char* dest_buffer, int* dest_len) override {
23 return CopyOut(dest_buffer, dest_len);
24 }
25
26 DISALLOW_COPY_AND_ASSIGN(PassThroughFilter);
27 };
28
29 } // namespace
30
31 TEST(FilterTest, ContentTypeId) {
32 // Check for basic translation of Content-Encoding, including case variations.
33 EXPECT_EQ(Filter::FILTER_TYPE_DEFLATE,
34 Filter::ConvertEncodingToType("deflate"));
35 EXPECT_EQ(Filter::FILTER_TYPE_DEFLATE,
36 Filter::ConvertEncodingToType("deflAte"));
37 EXPECT_EQ(Filter::FILTER_TYPE_GZIP,
38 Filter::ConvertEncodingToType("gzip"));
39 EXPECT_EQ(Filter::FILTER_TYPE_GZIP,
40 Filter::ConvertEncodingToType("GzIp"));
41 EXPECT_EQ(Filter::FILTER_TYPE_GZIP,
42 Filter::ConvertEncodingToType("x-gzip"));
43 EXPECT_EQ(Filter::FILTER_TYPE_GZIP,
44 Filter::ConvertEncodingToType("X-GzIp"));
45 EXPECT_EQ(Filter::FILTER_TYPE_SDCH,
46 Filter::ConvertEncodingToType("sdch"));
47 EXPECT_EQ(Filter::FILTER_TYPE_SDCH,
48 Filter::ConvertEncodingToType("sDcH"));
49 EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
50 Filter::ConvertEncodingToType("weird"));
51 EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
52 Filter::ConvertEncodingToType("strange"));
53 }
54
55 TEST(FilterTest, SdchEncoding) {
56 // Handle content encodings including SDCH.
57 const std::string kTextHtmlMime("text/html");
58 MockFilterContext filter_context;
59 // Empty handle indicates to filter that SDCH is active.
60 filter_context.SetSdchResponse(
61 SdchManager::CreateEmptyDictionarySetForTesting());
62
63 std::vector<Filter::FilterType> encoding_types;
64
65 // Check for most common encoding, and verify it survives unchanged.
66 encoding_types.clear();
67 encoding_types.push_back(Filter::FILTER_TYPE_SDCH);
68 encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
69 filter_context.SetMimeType(kTextHtmlMime);
70 Filter::FixupEncodingTypes(filter_context, &encoding_types);
71 ASSERT_EQ(2U, encoding_types.size());
72 EXPECT_EQ(Filter::FILTER_TYPE_SDCH, encoding_types[0]);
73 EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types[1]);
74
75 // Unchanged even with other mime types.
76 encoding_types.clear();
77 encoding_types.push_back(Filter::FILTER_TYPE_SDCH);
78 encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
79 filter_context.SetMimeType("other/type");
80 Filter::FixupEncodingTypes(filter_context, &encoding_types);
81 ASSERT_EQ(2U, encoding_types.size());
82 EXPECT_EQ(Filter::FILTER_TYPE_SDCH, encoding_types[0]);
83 EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types[1]);
84
85 // Solo SDCH is extended to include optional gunzip.
86 encoding_types.clear();
87 encoding_types.push_back(Filter::FILTER_TYPE_SDCH);
88 Filter::FixupEncodingTypes(filter_context, &encoding_types);
89 ASSERT_EQ(2U, encoding_types.size());
90 EXPECT_EQ(Filter::FILTER_TYPE_SDCH, encoding_types[0]);
91 EXPECT_EQ(Filter::FILTER_TYPE_GZIP_HELPING_SDCH, encoding_types[1]);
92 }
93
94 TEST(FilterTest, MissingSdchEncoding) {
95 // Handle interesting case where entire SDCH encoding assertion "got lost."
96 const std::string kTextHtmlMime("text/html");
97 MockFilterContext filter_context;
98 filter_context.SetSdchResponse(
99 SdchManager::CreateEmptyDictionarySetForTesting());
100
101 std::vector<Filter::FilterType> encoding_types;
102
103 // Loss of encoding, but it was an SDCH response with html type.
104 encoding_types.clear();
105 filter_context.SetMimeType(kTextHtmlMime);
106 Filter::FixupEncodingTypes(filter_context, &encoding_types);
107 ASSERT_EQ(2U, encoding_types.size());
108 EXPECT_EQ(Filter::FILTER_TYPE_SDCH_POSSIBLE, encoding_types[0]);
109 EXPECT_EQ(Filter::FILTER_TYPE_GZIP_HELPING_SDCH, encoding_types[1]);
110
111 // Loss of encoding, but it was an SDCH response with a prefix that says it
112 // was an html type. Note that it *should* be the case that a precise match
113 // with "text/html" we be collected by GetMimeType() and passed in, but we
114 // coded the fixup defensively (scanning for a prefix of "text/html", so this
115 // is an example which could survive such confusion in the caller).
116 encoding_types.clear();
117 filter_context.SetMimeType("text/html; charset=UTF-8");
118 Filter::FixupEncodingTypes(filter_context, &encoding_types);
119 ASSERT_EQ(2U, encoding_types.size());
120 EXPECT_EQ(Filter::FILTER_TYPE_SDCH_POSSIBLE, encoding_types[0]);
121 EXPECT_EQ(Filter::FILTER_TYPE_GZIP_HELPING_SDCH, encoding_types[1]);
122
123 // No encoding, but it was an SDCH response with non-html type.
124 encoding_types.clear();
125 filter_context.SetMimeType("other/mime");
126 Filter::FixupEncodingTypes(filter_context, &encoding_types);
127 ASSERT_EQ(2U, encoding_types.size());
128 EXPECT_EQ(Filter::FILTER_TYPE_SDCH_POSSIBLE, encoding_types[0]);
129 EXPECT_EQ(Filter::FILTER_TYPE_GZIP_HELPING_SDCH, encoding_types[1]);
130 }
131
132 // FixupEncodingTypes() should leave gzip encoding intact.
133 TEST(FilterTest, Gzip) {
134 const std::string kUrl("http://example.com/foo");
135 MockFilterContext filter_context;
136 std::vector<Filter::FilterType> encoding_types;
137 filter_context.SetURL(GURL(kUrl));
138
139 Filter::FixupEncodingTypes(filter_context, &encoding_types);
140 EXPECT_EQ(0U, encoding_types.size());
141
142 encoding_types.clear();
143 encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
144 Filter::FixupEncodingTypes(filter_context, &encoding_types);
145 ASSERT_EQ(1U, encoding_types.size());
146 EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types.front());
147 }
148
149 // Make sure a series of three pass-through filters copies the data cleanly.
150 // Regression test for http://crbug.com/418975.
151 TEST(FilterTest, ThreeFilterChain) {
152 std::unique_ptr<PassThroughFilter> filter1(new PassThroughFilter);
153 std::unique_ptr<PassThroughFilter> filter2(new PassThroughFilter);
154 std::unique_ptr<PassThroughFilter> filter3(new PassThroughFilter);
155
156 filter1->InitBuffer(32 * 1024);
157 filter2->InitBuffer(32 * 1024);
158 filter3->InitBuffer(32 * 1024);
159
160 filter2->next_filter_ = std::move(filter3);
161 filter1->next_filter_ = std::move(filter2);
162
163 // Initialize the input array with a varying byte sequence.
164 const size_t input_array_size = 64 * 1024;
165 char input_array[input_array_size];
166 size_t read_array_index = 0;
167 for (size_t i = 0; i < input_array_size; i++) {
168 input_array[i] = i % 113;
169 }
170
171 const size_t output_array_size = 4 * 1024;
172 char output_array[output_array_size];
173
174 size_t compare_array_index = 0;
175
176 do {
177 // Read data from the filter chain.
178 int amount_read = output_array_size;
179 Filter::FilterStatus status = filter1->ReadData(output_array, &amount_read);
180 EXPECT_NE(Filter::FILTER_ERROR, status);
181 EXPECT_EQ(0, memcmp(output_array, input_array + compare_array_index,
182 amount_read));
183 compare_array_index += amount_read;
184
185 // Detect the various indications that data transfer along the chain is
186 // complete.
187 if (Filter::FILTER_DONE == status || Filter::FILTER_ERROR == status ||
188 (Filter::FILTER_OK == status && amount_read == 0) ||
189 (Filter::FILTER_NEED_MORE_DATA == status &&
190 read_array_index == input_array_size))
191 break;
192
193 if (Filter::FILTER_OK == status)
194 continue;
195
196 // Write needed data into the filter chain.
197 ASSERT_EQ(Filter::FILTER_NEED_MORE_DATA, status);
198 ASSERT_NE(0, filter1->stream_buffer_size());
199 size_t amount_to_copy = std::min(
200 static_cast<size_t>(filter1->stream_buffer_size()),
201 input_array_size - read_array_index);
202 memcpy(filter1->stream_buffer()->data(),
203 input_array + read_array_index,
204 amount_to_copy);
205 filter1->FlushStreamBuffer(amount_to_copy);
206 read_array_index += amount_to_copy;
207 } while (true);
208
209 EXPECT_EQ(read_array_index, input_array_size);
210 EXPECT_EQ(compare_array_index, input_array_size);
211 }
212
213 } // Namespace net
OLDNEW
« no previous file with comments | « net/filter/filter.cc ('k') | net/filter/gzip_filter.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698