OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/safe_browsing/two_phase_uploader.h" | 5 #include "chrome/browser/safe_browsing/two_phase_uploader.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include "base/files/file_path.h" | 9 #include "base/files/file_path.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
| 11 #include "base/task_scheduler/post_task.h" |
| 12 #include "base/task_scheduler/task_traits.h" |
11 #include "chrome/browser/safe_browsing/local_two_phase_testserver.h" | 13 #include "chrome/browser/safe_browsing/local_two_phase_testserver.h" |
12 #include "content/public/test/test_browser_thread_bundle.h" | 14 #include "content/public/test/test_browser_thread_bundle.h" |
13 #include "content/public/test/test_utils.h" | 15 #include "content/public/test/test_utils.h" |
14 #include "net/base/net_errors.h" | 16 #include "net/base/net_errors.h" |
15 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h" | 17 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h" |
16 #include "net/url_request/url_fetcher.h" | 18 #include "net/url_request/url_fetcher.h" |
17 #include "net/url_request/url_request_test_util.h" | 19 #include "net/url_request/url_request_test_util.h" |
18 #include "testing/gtest/include/gtest/gtest.h" | 20 #include "testing/gtest/include/gtest/gtest.h" |
19 | 21 |
20 using content::BrowserThread; | 22 using content::BrowserThread; |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
65 public: | 67 public: |
66 TwoPhaseUploaderTest() | 68 TwoPhaseUploaderTest() |
67 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), | 69 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), |
68 url_request_context_getter_(new net::TestURLRequestContextGetter( | 70 url_request_context_getter_(new net::TestURLRequestContextGetter( |
69 BrowserThread::GetTaskRunnerForThread(BrowserThread::IO))) {} | 71 BrowserThread::GetTaskRunnerForThread(BrowserThread::IO))) {} |
70 | 72 |
71 protected: | 73 protected: |
72 content::TestBrowserThreadBundle thread_bundle_; | 74 content::TestBrowserThreadBundle thread_bundle_; |
73 | 75 |
74 scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_; | 76 scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_; |
| 77 const scoped_refptr<base::SequencedTaskRunner> task_runner_ = |
| 78 base::CreateSequencedTaskRunnerWithTraits( |
| 79 {base::MayBlock(), base::TaskPriority::BACKGROUND}); |
75 }; | 80 }; |
76 | 81 |
77 TEST_F(TwoPhaseUploaderTest, UploadFile) { | 82 TEST_F(TwoPhaseUploaderTest, UploadFile) { |
78 scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner; | 83 scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner; |
79 LocalTwoPhaseTestServer test_server; | 84 LocalTwoPhaseTestServer test_server; |
80 ASSERT_TRUE(test_server.Start()); | 85 ASSERT_TRUE(test_server.Start()); |
81 Delegate delegate; | 86 Delegate delegate; |
82 std::unique_ptr<TwoPhaseUploader> uploader(TwoPhaseUploader::Create( | 87 std::unique_ptr<TwoPhaseUploader> uploader(TwoPhaseUploader::Create( |
83 url_request_context_getter_.get(), | 88 url_request_context_getter_.get(), task_runner_.get(), |
84 BrowserThread::GetTaskRunnerForThread(BrowserThread::DB).get(), | |
85 test_server.GetURL("start"), "metadata", GetTestFilePath(), | 89 test_server.GetURL("start"), "metadata", GetTestFilePath(), |
86 base::Bind(&Delegate::ProgressCallback, base::Unretained(&delegate)), | 90 base::Bind(&Delegate::ProgressCallback, base::Unretained(&delegate)), |
87 base::Bind(&Delegate::FinishCallback, base::Unretained(&delegate), | 91 base::Bind(&Delegate::FinishCallback, base::Unretained(&delegate), |
88 runner), | 92 runner), |
89 TRAFFIC_ANNOTATION_FOR_TESTS)); | 93 TRAFFIC_ANNOTATION_FOR_TESTS)); |
90 uploader->Start(); | 94 uploader->Start(); |
91 runner->Run(); | 95 runner->Run(); |
92 EXPECT_EQ(TwoPhaseUploader::STATE_SUCCESS, delegate.state_); | 96 EXPECT_EQ(TwoPhaseUploader::STATE_SUCCESS, delegate.state_); |
93 EXPECT_EQ(net::OK, delegate.net_error_); | 97 EXPECT_EQ(net::OK, delegate.net_error_); |
94 EXPECT_EQ(200, delegate.response_code_); | 98 EXPECT_EQ(200, delegate.response_code_); |
95 EXPECT_EQ( | 99 EXPECT_EQ( |
96 "/start\n" // path of start request | 100 "/start\n" // path of start request |
97 "4c24b2612e94e2ae622e54397663f2b7bf0a2e17\n" // sha1sum of "metadata" | 101 "4c24b2612e94e2ae622e54397663f2b7bf0a2e17\n" // sha1sum of "metadata" |
98 "944857cc626f2cafe232521986b4c6d3f9993c97\n", // sha1sum of test file | 102 "944857cc626f2cafe232521986b4c6d3f9993c97\n", // sha1sum of test file |
99 delegate.response_); | 103 delegate.response_); |
100 } | 104 } |
101 | 105 |
102 TEST_F(TwoPhaseUploaderTest, BadPhaseOneResponse) { | 106 TEST_F(TwoPhaseUploaderTest, BadPhaseOneResponse) { |
103 scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner; | 107 scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner; |
104 LocalTwoPhaseTestServer test_server; | 108 LocalTwoPhaseTestServer test_server; |
105 ASSERT_TRUE(test_server.Start()); | 109 ASSERT_TRUE(test_server.Start()); |
106 Delegate delegate; | 110 Delegate delegate; |
107 std::unique_ptr<TwoPhaseUploader> uploader(TwoPhaseUploader::Create( | 111 std::unique_ptr<TwoPhaseUploader> uploader(TwoPhaseUploader::Create( |
108 url_request_context_getter_.get(), | 112 url_request_context_getter_.get(), task_runner_.get(), |
109 BrowserThread::GetTaskRunnerForThread(BrowserThread::DB).get(), | |
110 test_server.GetURL("start?p1code=500"), "metadata", GetTestFilePath(), | 113 test_server.GetURL("start?p1code=500"), "metadata", GetTestFilePath(), |
111 base::Bind(&Delegate::ProgressCallback, base::Unretained(&delegate)), | 114 base::Bind(&Delegate::ProgressCallback, base::Unretained(&delegate)), |
112 base::Bind(&Delegate::FinishCallback, base::Unretained(&delegate), | 115 base::Bind(&Delegate::FinishCallback, base::Unretained(&delegate), |
113 runner), | 116 runner), |
114 TRAFFIC_ANNOTATION_FOR_TESTS)); | 117 TRAFFIC_ANNOTATION_FOR_TESTS)); |
115 uploader->Start(); | 118 uploader->Start(); |
116 runner->Run(); | 119 runner->Run(); |
117 EXPECT_EQ(TwoPhaseUploader::UPLOAD_METADATA, delegate.state_); | 120 EXPECT_EQ(TwoPhaseUploader::UPLOAD_METADATA, delegate.state_); |
118 EXPECT_EQ(net::OK, delegate.net_error_); | 121 EXPECT_EQ(net::OK, delegate.net_error_); |
119 EXPECT_EQ(500, delegate.response_code_); | 122 EXPECT_EQ(500, delegate.response_code_); |
120 EXPECT_EQ("", delegate.response_); | 123 EXPECT_EQ("", delegate.response_); |
121 } | 124 } |
122 | 125 |
123 TEST_F(TwoPhaseUploaderTest, BadPhaseTwoResponse) { | 126 TEST_F(TwoPhaseUploaderTest, BadPhaseTwoResponse) { |
124 scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner; | 127 scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner; |
125 LocalTwoPhaseTestServer test_server; | 128 LocalTwoPhaseTestServer test_server; |
126 ASSERT_TRUE(test_server.Start()); | 129 ASSERT_TRUE(test_server.Start()); |
127 Delegate delegate; | 130 Delegate delegate; |
128 std::unique_ptr<TwoPhaseUploader> uploader(TwoPhaseUploader::Create( | 131 std::unique_ptr<TwoPhaseUploader> uploader(TwoPhaseUploader::Create( |
129 url_request_context_getter_.get(), | 132 url_request_context_getter_.get(), task_runner_.get(), |
130 BrowserThread::GetTaskRunnerForThread(BrowserThread::DB).get(), | |
131 test_server.GetURL("start?p2code=500"), "metadata", GetTestFilePath(), | 133 test_server.GetURL("start?p2code=500"), "metadata", GetTestFilePath(), |
132 base::Bind(&Delegate::ProgressCallback, base::Unretained(&delegate)), | 134 base::Bind(&Delegate::ProgressCallback, base::Unretained(&delegate)), |
133 base::Bind(&Delegate::FinishCallback, base::Unretained(&delegate), | 135 base::Bind(&Delegate::FinishCallback, base::Unretained(&delegate), |
134 runner), | 136 runner), |
135 TRAFFIC_ANNOTATION_FOR_TESTS)); | 137 TRAFFIC_ANNOTATION_FOR_TESTS)); |
136 uploader->Start(); | 138 uploader->Start(); |
137 runner->Run(); | 139 runner->Run(); |
138 EXPECT_EQ(TwoPhaseUploader::UPLOAD_FILE, delegate.state_); | 140 EXPECT_EQ(TwoPhaseUploader::UPLOAD_FILE, delegate.state_); |
139 EXPECT_EQ(net::OK, delegate.net_error_); | 141 EXPECT_EQ(net::OK, delegate.net_error_); |
140 EXPECT_EQ(500, delegate.response_code_); | 142 EXPECT_EQ(500, delegate.response_code_); |
141 EXPECT_EQ( | 143 EXPECT_EQ( |
142 "/start\n" // path of start request | 144 "/start\n" // path of start request |
143 "4c24b2612e94e2ae622e54397663f2b7bf0a2e17\n" // sha1sum of "metadata" | 145 "4c24b2612e94e2ae622e54397663f2b7bf0a2e17\n" // sha1sum of "metadata" |
144 "944857cc626f2cafe232521986b4c6d3f9993c97\n", // sha1sum of test file | 146 "944857cc626f2cafe232521986b4c6d3f9993c97\n", // sha1sum of test file |
145 delegate.response_); | 147 delegate.response_); |
146 } | 148 } |
147 | 149 |
148 TEST_F(TwoPhaseUploaderTest, PhaseOneConnectionClosed) { | 150 TEST_F(TwoPhaseUploaderTest, PhaseOneConnectionClosed) { |
149 scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner; | 151 scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner; |
150 LocalTwoPhaseTestServer test_server; | 152 LocalTwoPhaseTestServer test_server; |
151 ASSERT_TRUE(test_server.Start()); | 153 ASSERT_TRUE(test_server.Start()); |
152 Delegate delegate; | 154 Delegate delegate; |
153 std::unique_ptr<TwoPhaseUploader> uploader(TwoPhaseUploader::Create( | 155 std::unique_ptr<TwoPhaseUploader> uploader(TwoPhaseUploader::Create( |
154 url_request_context_getter_.get(), | 156 url_request_context_getter_.get(), task_runner_.get(), |
155 BrowserThread::GetTaskRunnerForThread(BrowserThread::DB).get(), | |
156 test_server.GetURL("start?p1close=1"), "metadata", GetTestFilePath(), | 157 test_server.GetURL("start?p1close=1"), "metadata", GetTestFilePath(), |
157 base::Bind(&Delegate::ProgressCallback, base::Unretained(&delegate)), | 158 base::Bind(&Delegate::ProgressCallback, base::Unretained(&delegate)), |
158 base::Bind(&Delegate::FinishCallback, base::Unretained(&delegate), | 159 base::Bind(&Delegate::FinishCallback, base::Unretained(&delegate), |
159 runner), | 160 runner), |
160 TRAFFIC_ANNOTATION_FOR_TESTS)); | 161 TRAFFIC_ANNOTATION_FOR_TESTS)); |
161 uploader->Start(); | 162 uploader->Start(); |
162 runner->Run(); | 163 runner->Run(); |
163 EXPECT_EQ(TwoPhaseUploader::UPLOAD_METADATA, delegate.state_); | 164 EXPECT_EQ(TwoPhaseUploader::UPLOAD_METADATA, delegate.state_); |
164 EXPECT_EQ(net::ERR_EMPTY_RESPONSE, delegate.net_error_); | 165 EXPECT_EQ(net::ERR_EMPTY_RESPONSE, delegate.net_error_); |
165 EXPECT_EQ(net::URLFetcher::RESPONSE_CODE_INVALID, delegate.response_code_); | 166 EXPECT_EQ(net::URLFetcher::RESPONSE_CODE_INVALID, delegate.response_code_); |
166 EXPECT_EQ("", delegate.response_); | 167 EXPECT_EQ("", delegate.response_); |
167 } | 168 } |
168 | 169 |
169 TEST_F(TwoPhaseUploaderTest, PhaseTwoConnectionClosed) { | 170 TEST_F(TwoPhaseUploaderTest, PhaseTwoConnectionClosed) { |
170 scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner; | 171 scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner; |
171 LocalTwoPhaseTestServer test_server; | 172 LocalTwoPhaseTestServer test_server; |
172 ASSERT_TRUE(test_server.Start()); | 173 ASSERT_TRUE(test_server.Start()); |
173 Delegate delegate; | 174 Delegate delegate; |
174 std::unique_ptr<TwoPhaseUploader> uploader(TwoPhaseUploader::Create( | 175 std::unique_ptr<TwoPhaseUploader> uploader(TwoPhaseUploader::Create( |
175 url_request_context_getter_.get(), | 176 url_request_context_getter_.get(), task_runner_.get(), |
176 BrowserThread::GetTaskRunnerForThread(BrowserThread::DB).get(), | |
177 test_server.GetURL("start?p2close=1"), "metadata", GetTestFilePath(), | 177 test_server.GetURL("start?p2close=1"), "metadata", GetTestFilePath(), |
178 base::Bind(&Delegate::ProgressCallback, base::Unretained(&delegate)), | 178 base::Bind(&Delegate::ProgressCallback, base::Unretained(&delegate)), |
179 base::Bind(&Delegate::FinishCallback, base::Unretained(&delegate), | 179 base::Bind(&Delegate::FinishCallback, base::Unretained(&delegate), |
180 runner), | 180 runner), |
181 TRAFFIC_ANNOTATION_FOR_TESTS)); | 181 TRAFFIC_ANNOTATION_FOR_TESTS)); |
182 uploader->Start(); | 182 uploader->Start(); |
183 runner->Run(); | 183 runner->Run(); |
184 EXPECT_EQ(TwoPhaseUploader::UPLOAD_FILE, delegate.state_); | 184 EXPECT_EQ(TwoPhaseUploader::UPLOAD_FILE, delegate.state_); |
185 EXPECT_EQ(net::ERR_EMPTY_RESPONSE, delegate.net_error_); | 185 EXPECT_EQ(net::ERR_EMPTY_RESPONSE, delegate.net_error_); |
186 EXPECT_EQ(net::URLFetcher::RESPONSE_CODE_INVALID, delegate.response_code_); | 186 EXPECT_EQ(net::URLFetcher::RESPONSE_CODE_INVALID, delegate.response_code_); |
187 EXPECT_EQ("", delegate.response_); | 187 EXPECT_EQ("", delegate.response_); |
188 } | 188 } |
189 | 189 |
190 } // namespace safe_browsing | 190 } // namespace safe_browsing |
OLD | NEW |