content/browser/resolve_proxy_msg_helper_unittest.cc

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