| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 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 "chrome/browser/net/resolve_proxy_msg_helper.h" | |
| 6 | |
| 7 #include "content/common/child_process_messages.h" | |
| 8 #include "ipc/ipc_test_sink.h" | |
| 9 #include "net/base/net_errors.h" | |
| 10 #include "net/proxy/mock_proxy_resolver.h" | |
| 11 #include "net/proxy/proxy_config_service.h" | |
| 12 #include "net/proxy/proxy_service.h" | |
| 13 #include "testing/gtest/include/gtest/gtest.h" | |
| 14 | |
| 15 // This ProxyConfigService always returns "http://pac" as the PAC url to use. | |
| 16 class MockProxyConfigService : public net::ProxyConfigService { | |
| 17 public: | |
| 18 virtual void AddObserver(Observer* observer) {} | |
| 19 virtual void RemoveObserver(Observer* observer) {} | |
| 20 virtual ConfigAvailability GetLatestProxyConfig(net::ProxyConfig* results) { | |
| 21 *results = net::ProxyConfig::CreateFromCustomPacURL(GURL("http://pac")); | |
| 22 return CONFIG_VALID; | |
| 23 } | |
| 24 }; | |
| 25 | |
| 26 class ResolveProxyMsgHelperTest : public testing::Test, | |
| 27 public IPC::Channel::Listener { | |
| 28 public: | |
| 29 struct PendingResult { | |
| 30 PendingResult(int error_code, | |
| 31 const std::string& proxy_list) | |
| 32 : error_code(error_code), proxy_list(proxy_list) { | |
| 33 } | |
| 34 | |
| 35 int error_code; | |
| 36 std::string proxy_list; | |
| 37 }; | |
| 38 | |
| 39 ResolveProxyMsgHelperTest() | |
| 40 : resolver_(new net::MockAsyncProxyResolver), | |
| 41 service_(new net::ProxyService( | |
| 42 new MockProxyConfigService, resolver_, NULL)), | |
| 43 helper_(new ResolveProxyMsgHelper(service_.get())), | |
| 44 message_loop_(MessageLoop::TYPE_IO), | |
| 45 io_thread_(BrowserThread::IO, &message_loop_) { | |
| 46 test_sink_.AddFilter(this); | |
| 47 helper_->OnFilterAdded(&test_sink_); | |
| 48 } | |
| 49 | |
| 50 protected: | |
| 51 const PendingResult* pending_result() const { return pending_result_.get(); } | |
| 52 | |
| 53 void clear_pending_result() { | |
| 54 pending_result_.reset(); | |
| 55 } | |
| 56 | |
| 57 IPC::Message* GenerateReply() { | |
| 58 int temp_int; | |
| 59 std::string temp_string; | |
| 60 ChildProcessHostMsg_ResolveProxy message(GURL(), &temp_int, &temp_string); | |
| 61 return IPC::SyncMessage::GenerateReply(&message); | |
| 62 } | |
| 63 | |
| 64 net::MockAsyncProxyResolver* resolver_; | |
| 65 scoped_ptr<net::ProxyService> service_; | |
| 66 scoped_refptr<ResolveProxyMsgHelper> helper_; | |
| 67 scoped_ptr<PendingResult> pending_result_; | |
| 68 | |
| 69 private: | |
| 70 virtual bool OnMessageReceived(const IPC::Message& msg) { | |
| 71 TupleTypes<ChildProcessHostMsg_ResolveProxy::ReplyParam>::ValueTuple | |
| 72 reply_data; | |
| 73 EXPECT_TRUE( | |
| 74 ChildProcessHostMsg_ResolveProxy::ReadReplyParam(&msg, &reply_data)); | |
| 75 DCHECK(!pending_result_.get()); | |
| 76 pending_result_.reset(new PendingResult(reply_data.a, reply_data.b)); | |
| 77 test_sink_.ClearMessages(); | |
| 78 return true; | |
| 79 } | |
| 80 | |
| 81 MessageLoop message_loop_; | |
| 82 BrowserThread io_thread_; | |
| 83 IPC::TestSink test_sink_; | |
| 84 }; | |
| 85 | |
| 86 // Issue three sequential requests -- each should succeed. | |
| 87 TEST_F(ResolveProxyMsgHelperTest, Sequential) { | |
| 88 GURL url1("http://www.google1.com/"); | |
| 89 GURL url2("http://www.google2.com/"); | |
| 90 GURL url3("http://www.google3.com/"); | |
| 91 | |
| 92 // Messages are deleted by the sink. | |
| 93 IPC::Message* msg1 = GenerateReply(); | |
| 94 IPC::Message* msg2 = GenerateReply(); | |
| 95 IPC::Message* msg3 = GenerateReply(); | |
| 96 | |
| 97 // Execute each request sequentially (so there are never 2 requests | |
| 98 // outstanding at the same time). | |
| 99 | |
| 100 helper_->OnResolveProxy(url1, msg1); | |
| 101 | |
| 102 // Finish ProxyService's initialization. | |
| 103 resolver_->pending_set_pac_script_request()->CompleteNow(net::OK); | |
| 104 | |
| 105 ASSERT_EQ(1u, resolver_->pending_requests().size()); | |
| 106 EXPECT_EQ(url1, resolver_->pending_requests()[0]->url()); | |
| 107 resolver_->pending_requests()[0]->results()->UseNamedProxy("result1:80"); | |
| 108 resolver_->pending_requests()[0]->CompleteNow(net::OK); | |
| 109 | |
| 110 // Check result. | |
| 111 EXPECT_EQ(net::OK, pending_result()->error_code); | |
| 112 EXPECT_EQ("PROXY result1:80", pending_result()->proxy_list); | |
| 113 clear_pending_result(); | |
| 114 | |
| 115 helper_->OnResolveProxy(url2, msg2); | |
| 116 | |
| 117 ASSERT_EQ(1u, resolver_->pending_requests().size()); | |
| 118 EXPECT_EQ(url2, resolver_->pending_requests()[0]->url()); | |
| 119 resolver_->pending_requests()[0]->results()->UseNamedProxy("result2:80"); | |
| 120 resolver_->pending_requests()[0]->CompleteNow(net::OK); | |
| 121 | |
| 122 // Check result. | |
| 123 EXPECT_EQ(net::OK, pending_result()->error_code); | |
| 124 EXPECT_EQ("PROXY result2:80", pending_result()->proxy_list); | |
| 125 clear_pending_result(); | |
| 126 | |
| 127 helper_->OnResolveProxy(url3, msg3); | |
| 128 | |
| 129 ASSERT_EQ(1u, resolver_->pending_requests().size()); | |
| 130 EXPECT_EQ(url3, resolver_->pending_requests()[0]->url()); | |
| 131 resolver_->pending_requests()[0]->results()->UseNamedProxy("result3:80"); | |
| 132 resolver_->pending_requests()[0]->CompleteNow(net::OK); | |
| 133 | |
| 134 // Check result. | |
| 135 EXPECT_EQ(net::OK, pending_result()->error_code); | |
| 136 EXPECT_EQ("PROXY result3:80", pending_result()->proxy_list); | |
| 137 clear_pending_result(); | |
| 138 } | |
| 139 | |
| 140 // Issue a request while one is already in progress -- should be queued. | |
| 141 TEST_F(ResolveProxyMsgHelperTest, QueueRequests) { | |
| 142 GURL url1("http://www.google1.com/"); | |
| 143 GURL url2("http://www.google2.com/"); | |
| 144 GURL url3("http://www.google3.com/"); | |
| 145 | |
| 146 IPC::Message* msg1 = GenerateReply(); | |
| 147 IPC::Message* msg2 = GenerateReply(); | |
| 148 IPC::Message* msg3 = GenerateReply(); | |
| 149 | |
| 150 // Start three requests. Since the proxy resolver is async, all the | |
| 151 // requests will be pending. | |
| 152 | |
| 153 helper_->OnResolveProxy(url1, msg1); | |
| 154 | |
| 155 // Finish ProxyService's initialization. | |
| 156 resolver_->pending_set_pac_script_request()->CompleteNow(net::OK); | |
| 157 | |
| 158 helper_->OnResolveProxy(url2, msg2); | |
| 159 helper_->OnResolveProxy(url3, msg3); | |
| 160 | |
| 161 // ResolveProxyHelper only keeps 1 request outstanding in ProxyService | |
| 162 // at a time. | |
| 163 ASSERT_EQ(1u, resolver_->pending_requests().size()); | |
| 164 EXPECT_EQ(url1, resolver_->pending_requests()[0]->url()); | |
| 165 | |
| 166 resolver_->pending_requests()[0]->results()->UseNamedProxy("result1:80"); | |
| 167 resolver_->pending_requests()[0]->CompleteNow(net::OK); | |
| 168 | |
| 169 // Check result. | |
| 170 EXPECT_EQ(net::OK, pending_result()->error_code); | |
| 171 EXPECT_EQ("PROXY result1:80", pending_result()->proxy_list); | |
| 172 clear_pending_result(); | |
| 173 | |
| 174 ASSERT_EQ(1u, resolver_->pending_requests().size()); | |
| 175 EXPECT_EQ(url2, resolver_->pending_requests()[0]->url()); | |
| 176 | |
| 177 resolver_->pending_requests()[0]->results()->UseNamedProxy("result2:80"); | |
| 178 resolver_->pending_requests()[0]->CompleteNow(net::OK); | |
| 179 | |
| 180 // Check result. | |
| 181 EXPECT_EQ(net::OK, pending_result()->error_code); | |
| 182 EXPECT_EQ("PROXY result2:80", pending_result()->proxy_list); | |
| 183 clear_pending_result(); | |
| 184 | |
| 185 ASSERT_EQ(1u, resolver_->pending_requests().size()); | |
| 186 EXPECT_EQ(url3, resolver_->pending_requests()[0]->url()); | |
| 187 | |
| 188 resolver_->pending_requests()[0]->results()->UseNamedProxy("result3:80"); | |
| 189 resolver_->pending_requests()[0]->CompleteNow(net::OK); | |
| 190 | |
| 191 // Check result. | |
| 192 EXPECT_EQ(net::OK, pending_result()->error_code); | |
| 193 EXPECT_EQ("PROXY result3:80", pending_result()->proxy_list); | |
| 194 clear_pending_result(); | |
| 195 } | |
| 196 | |
| 197 // Delete the helper while a request is in progress, and others are pending. | |
| 198 TEST_F(ResolveProxyMsgHelperTest, CancelPendingRequests) { | |
| 199 GURL url1("http://www.google1.com/"); | |
| 200 GURL url2("http://www.google2.com/"); | |
| 201 GURL url3("http://www.google3.com/"); | |
| 202 | |
| 203 // They will be deleted by the request's cancellation. | |
| 204 IPC::Message* msg1 = GenerateReply(); | |
| 205 IPC::Message* msg2 = GenerateReply(); | |
| 206 IPC::Message* msg3 = GenerateReply(); | |
| 207 | |
| 208 // Start three requests. Since the proxy resolver is async, all the | |
| 209 // requests will be pending. | |
| 210 | |
| 211 helper_->OnResolveProxy(url1, msg1); | |
| 212 | |
| 213 // Finish ProxyService's initialization. | |
| 214 resolver_->pending_set_pac_script_request()->CompleteNow(net::OK); | |
| 215 | |
| 216 helper_->OnResolveProxy(url2, msg2); | |
| 217 helper_->OnResolveProxy(url3, msg3); | |
| 218 | |
| 219 // ResolveProxyHelper only keeps 1 request outstanding in ProxyService | |
| 220 // at a time. | |
| 221 ASSERT_EQ(1u, resolver_->pending_requests().size()); | |
| 222 EXPECT_EQ(url1, resolver_->pending_requests()[0]->url()); | |
| 223 | |
| 224 // Delete the underlying ResolveProxyMsgHelper -- this should cancel all | |
| 225 // the requests which are outstanding. | |
| 226 helper_ = NULL; | |
| 227 | |
| 228 // The pending requests sent to the proxy resolver should have been cancelled. | |
| 229 | |
| 230 EXPECT_EQ(0u, resolver_->pending_requests().size()); | |
| 231 | |
| 232 EXPECT_TRUE(pending_result() == NULL); | |
| 233 | |
| 234 // It should also be the case that msg1, msg2, msg3 were deleted by the | |
| 235 // cancellation. (Else will show up as a leak in Purify/Valgrind). | |
| 236 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 7036025:
Get rid of chrome dependencies from PluginProcessHost by moving dispatching of chrome specific me... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/