Home | History | Annotate | Download | only in proxy 
      1 // Copyright (c) 2012 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/proxy/multi_threaded_proxy_resolver.h"
      6 
      7 #include "base/message_loop/message_loop.h"
      8 #include "base/stl_util.h"
      9 #include "base/strings/string_util.h"
     10 #include "base/strings/stringprintf.h"
     11 #include "base/strings/utf_string_conversions.h"
     12 #include "base/synchronization/waitable_event.h"
     13 #include "base/threading/platform_thread.h"
     14 #include "net/base/net_errors.h"
     15 #include "net/base/net_log.h"
     16 #include "net/base/net_log_unittest.h"
     17 #include "net/base/test_completion_callback.h"
     18 #include "net/proxy/proxy_info.h"
     19 #include "testing/gtest/include/gtest/gtest.h"
     20 #include "url/gurl.h"
     21 
     22 using base::ASCIIToUTF16;
     23 
     24 namespace net {
     25 
     26 namespace {
     27 
     28 // A synchronous mock ProxyResolver implementation, which can be used in
     29 // conjunction with MultiThreadedProxyResolver.
     30 //       - returns a single-item proxy list with the query's host.
     31 class MockProxyResolver : public ProxyResolver {
     32  public:
     33   MockProxyResolver()
     34       : ProxyResolver(true /*expects_pac_bytes*/),
     35         wrong_loop_(base::MessageLoop::current()),
     36         request_count_(0) {}
     37 
     38   // ProxyResolver implementation.
     39   virtual int GetProxyForURL(const GURL& query_url,
     40                              ProxyInfo* results,
     41                              const CompletionCallback& callback,
     42                              RequestHandle* request,
     43                              const BoundNetLog& net_log) OVERRIDE {
     44     if (resolve_latency_ != base::TimeDelta())
     45       base::PlatformThread::Sleep(resolve_latency_);
     46 
     47     CheckIsOnWorkerThread();
     48 
     49     EXPECT_TRUE(callback.is_null());
     50     EXPECT_TRUE(request == NULL);
     51 
     52     // Write something into |net_log| (doesn't really have any meaning.)
     53     net_log.BeginEvent(NetLog::TYPE_PAC_JAVASCRIPT_ALERT);
     54 
     55     results->UseNamedProxy(query_url.host());
     56 
     57     // Return a success code which represents the request's order.
     58     return request_count_++;
     59   }
     60 
     61   virtual void CancelRequest(RequestHandle request) OVERRIDE {
     62     NOTREACHED();
     63   }
     64 
     65   virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
     66     NOTREACHED();
     67     return LOAD_STATE_IDLE;
     68   }
     69 
     70   virtual void CancelSetPacScript() OVERRIDE {
     71     NOTREACHED();
     72   }
     73 
     74   virtual int SetPacScript(
     75       const scoped_refptr<ProxyResolverScriptData>& script_data,
     76       const CompletionCallback& callback) OVERRIDE {
     77     CheckIsOnWorkerThread();
     78     last_script_data_ = script_data;
     79     return OK;
     80   }
     81 
     82   int request_count() const { return request_count_; }
     83 
     84   const ProxyResolverScriptData* last_script_data() const {
     85     return last_script_data_.get();
     86   }
     87 
     88   void SetResolveLatency(base::TimeDelta latency) {
     89     resolve_latency_ = latency;
     90   }
     91 
     92  private:
     93   void CheckIsOnWorkerThread() {
     94     // We should be running on the worker thread -- while we don't know the
     95     // message loop of MultiThreadedProxyResolver's worker thread, we do
     96     // know that it is going to be distinct from the loop running the
     97     // test, so at least make sure it isn't the main loop.
     98     EXPECT_NE(base::MessageLoop::current(), wrong_loop_);
     99   }
    100 
    101   base::MessageLoop* wrong_loop_;
    102   int request_count_;
    103   scoped_refptr<ProxyResolverScriptData> last_script_data_;
    104   base::TimeDelta resolve_latency_;
    105 };
    106 
    107 
    108 // A mock synchronous ProxyResolver which can be set to block upon reaching
    109 // GetProxyForURL().
    110 // TODO(eroman): WaitUntilBlocked() *must* be called before calling Unblock(),
    111 //               otherwise there will be a race on |should_block_| since it is
    112 //               read without any synchronization.
    113 class BlockableProxyResolver : public MockProxyResolver {
    114  public:
    115   BlockableProxyResolver()
    116       : should_block_(false),
    117         unblocked_(true, true),
    118         blocked_(true, false) {
    119   }
    120 
    121   void Block() {
    122     should_block_ = true;
    123     unblocked_.Reset();
    124   }
    125 
    126   void Unblock() {
    127     should_block_ = false;
    128     blocked_.Reset();
    129     unblocked_.Signal();
    130   }
    131 
    132   void WaitUntilBlocked() {
    133     blocked_.Wait();
    134   }
    135 
    136   virtual int GetProxyForURL(const GURL& query_url,
    137                              ProxyInfo* results,
    138                              const CompletionCallback& callback,
    139                              RequestHandle* request,
    140                              const BoundNetLog& net_log) OVERRIDE {
    141     if (should_block_) {
    142       blocked_.Signal();
    143       unblocked_.Wait();
    144     }
    145 
    146     return MockProxyResolver::GetProxyForURL(
    147         query_url, results, callback, request, net_log);
    148   }
    149 
    150  private:
    151   bool should_block_;
    152   base::WaitableEvent unblocked_;
    153   base::WaitableEvent blocked_;
    154 };
    155 
    156 // ForwardingProxyResolver forwards all requests to |impl|.
    157 class ForwardingProxyResolver : public ProxyResolver {
    158  public:
    159   explicit ForwardingProxyResolver(ProxyResolver* impl)
    160       : ProxyResolver(impl->expects_pac_bytes()),
    161         impl_(impl) {}
    162 
    163   virtual int GetProxyForURL(const GURL& query_url,
    164                              ProxyInfo* results,
    165                              const CompletionCallback& callback,
    166                              RequestHandle* request,
    167                              const BoundNetLog& net_log) OVERRIDE {
    168     return impl_->GetProxyForURL(
    169         query_url, results, callback, request, net_log);
    170   }
    171 
    172   virtual void CancelRequest(RequestHandle request) OVERRIDE {
    173     impl_->CancelRequest(request);
    174   }
    175 
    176   virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
    177     NOTREACHED();
    178     return LOAD_STATE_IDLE;
    179   }
    180 
    181   virtual void CancelSetPacScript() OVERRIDE {
    182     impl_->CancelSetPacScript();
    183   }
    184 
    185   virtual int SetPacScript(
    186       const scoped_refptr<ProxyResolverScriptData>& script_data,
    187       const CompletionCallback& callback) OVERRIDE {
    188     return impl_->SetPacScript(script_data, callback);
    189   }
    190 
    191  private:
    192   ProxyResolver* impl_;
    193 };
    194 
    195 // This factory returns ProxyResolvers that forward all requests to
    196 // |resolver|.
    197 class ForwardingProxyResolverFactory : public ProxyResolverFactory {
    198  public:
    199   explicit ForwardingProxyResolverFactory(ProxyResolver* resolver)
    200       : ProxyResolverFactory(resolver->expects_pac_bytes()),
    201         resolver_(resolver) {}
    202 
    203   virtual ProxyResolver* CreateProxyResolver() OVERRIDE {
    204     return new ForwardingProxyResolver(resolver_);
    205   }
    206 
    207  private:
    208   ProxyResolver* resolver_;
    209 };
    210 
    211 // This factory returns new instances of BlockableProxyResolver.
    212 class BlockableProxyResolverFactory : public ProxyResolverFactory {
    213  public:
    214   BlockableProxyResolverFactory() : ProxyResolverFactory(true) {}
    215 
    216   virtual ~BlockableProxyResolverFactory() {
    217     STLDeleteElements(&resolvers_);
    218   }
    219 
    220   virtual ProxyResolver* CreateProxyResolver() OVERRIDE {
    221     BlockableProxyResolver* resolver = new BlockableProxyResolver;
    222     resolvers_.push_back(resolver);
    223     return new ForwardingProxyResolver(resolver);
    224   }
    225 
    226   std::vector<BlockableProxyResolver*> resolvers() {
    227     return resolvers_;
    228   }
    229 
    230  private:
    231   std::vector<BlockableProxyResolver*> resolvers_;
    232 };
    233 
    234 TEST(MultiThreadedProxyResolverTest, SingleThread_Basic) {
    235   const size_t kNumThreads = 1u;
    236   scoped_ptr<MockProxyResolver> mock(new MockProxyResolver);
    237   MultiThreadedProxyResolver resolver(
    238       new ForwardingProxyResolverFactory(mock.get()), kNumThreads);
    239 
    240   int rv;
    241 
    242   EXPECT_TRUE(resolver.expects_pac_bytes());
    243 
    244   // Call SetPacScriptByData() -- verify that it reaches the synchronous
    245   // resolver.
    246   TestCompletionCallback set_script_callback;
    247   rv = resolver.SetPacScript(
    248       ProxyResolverScriptData::FromUTF8("pac script bytes"),
    249       set_script_callback.callback());
    250   EXPECT_EQ(ERR_IO_PENDING, rv);
    251   EXPECT_EQ(OK, set_script_callback.WaitForResult());
    252   EXPECT_EQ(ASCIIToUTF16("pac script bytes"),
    253             mock->last_script_data()->utf16());
    254 
    255   // Start request 0.
    256   TestCompletionCallback callback0;
    257   CapturingBoundNetLog log0;
    258   ProxyInfo results0;
    259   rv = resolver.GetProxyForURL(GURL("http://request0"), &results0,
    260                                callback0.callback(), NULL, log0.bound());
    261   EXPECT_EQ(ERR_IO_PENDING, rv);
    262 
    263   // Wait for request 0 to finish.
    264   rv = callback0.WaitForResult();
    265   EXPECT_EQ(0, rv);
    266   EXPECT_EQ("PROXY request0:80", results0.ToPacString());
    267 
    268   // The mock proxy resolver should have written 1 log entry. And
    269   // on completion, this should have been copied into |log0|.
    270   // We also have 1 log entry that was emitted by the
    271   // MultiThreadedProxyResolver.
    272   CapturingNetLog::CapturedEntryList entries0;
    273   log0.GetEntries(&entries0);
    274 
    275   ASSERT_EQ(2u, entries0.size());
    276   EXPECT_EQ(NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD, entries0[0].type);
    277 
    278   // Start 3 more requests (request1 to request3).
    279 
    280   TestCompletionCallback callback1;
    281   ProxyInfo results1;
    282   rv = resolver.GetProxyForURL(GURL("http://request1"), &results1,
    283                                callback1.callback(), NULL, BoundNetLog());
    284   EXPECT_EQ(ERR_IO_PENDING, rv);
    285 
    286   TestCompletionCallback callback2;
    287   ProxyInfo results2;
    288   rv = resolver.GetProxyForURL(GURL("http://request2"), &results2,
    289                                callback2.callback(), NULL, BoundNetLog());
    290   EXPECT_EQ(ERR_IO_PENDING, rv);
    291 
    292   TestCompletionCallback callback3;
    293   ProxyInfo results3;
    294   rv = resolver.GetProxyForURL(GURL("http://request3"), &results3,
    295                                callback3.callback(), NULL, BoundNetLog());
    296   EXPECT_EQ(ERR_IO_PENDING, rv);
    297 
    298   // Wait for the requests to finish (they must finish in the order they were
    299   // started, which is what we check for from their magic return value)
    300 
    301   rv = callback1.WaitForResult();
    302   EXPECT_EQ(1, rv);
    303   EXPECT_EQ("PROXY request1:80", results1.ToPacString());
    304 
    305   rv = callback2.WaitForResult();
    306   EXPECT_EQ(2, rv);
    307   EXPECT_EQ("PROXY request2:80", results2.ToPacString());
    308 
    309   rv = callback3.WaitForResult();
    310   EXPECT_EQ(3, rv);
    311   EXPECT_EQ("PROXY request3:80", results3.ToPacString());
    312 }
    313 
    314 // Tests that the NetLog is updated to include the time the request was waiting
    315 // to be scheduled to a thread.
    316 TEST(MultiThreadedProxyResolverTest,
    317      SingleThread_UpdatesNetLogWithThreadWait) {
    318   const size_t kNumThreads = 1u;
    319   scoped_ptr<BlockableProxyResolver> mock(new BlockableProxyResolver);
    320   MultiThreadedProxyResolver resolver(
    321       new ForwardingProxyResolverFactory(mock.get()), kNumThreads);
    322 
    323   int rv;
    324 
    325   // Initialize the resolver.
    326   TestCompletionCallback init_callback;
    327   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("foo"),
    328                              init_callback.callback());
    329   EXPECT_EQ(OK, init_callback.WaitForResult());
    330 
    331   // Block the proxy resolver, so no request can complete.
    332   mock->Block();
    333 
    334   // Start request 0.
    335   ProxyResolver::RequestHandle request0;
    336   TestCompletionCallback callback0;
    337   ProxyInfo results0;
    338   CapturingBoundNetLog log0;
    339   rv = resolver.GetProxyForURL(GURL("http://request0"), &results0,
    340                                callback0.callback(), &request0, log0.bound());
    341   EXPECT_EQ(ERR_IO_PENDING, rv);
    342 
    343   // Start 2 more requests (request1 and request2).
    344 
    345   TestCompletionCallback callback1;
    346   ProxyInfo results1;
    347   CapturingBoundNetLog log1;
    348   rv = resolver.GetProxyForURL(GURL("http://request1"), &results1,
    349                                callback1.callback(), NULL, log1.bound());
    350   EXPECT_EQ(ERR_IO_PENDING, rv);
    351 
    352   ProxyResolver::RequestHandle request2;
    353   TestCompletionCallback callback2;
    354   ProxyInfo results2;
    355   CapturingBoundNetLog log2;
    356   rv = resolver.GetProxyForURL(GURL("http://request2"), &results2,
    357                                callback2.callback(), &request2, log2.bound());
    358   EXPECT_EQ(ERR_IO_PENDING, rv);
    359 
    360   // Unblock the worker thread so the requests can continue running.
    361   mock->WaitUntilBlocked();
    362   mock->Unblock();
    363 
    364   // Check that request 0 completed as expected.
    365   // The NetLog has 1 entry that came from the MultiThreadedProxyResolver, and
    366   // 1 entry from the mock proxy resolver.
    367   EXPECT_EQ(0, callback0.WaitForResult());
    368   EXPECT_EQ("PROXY request0:80", results0.ToPacString());
    369 
    370   CapturingNetLog::CapturedEntryList entries0;
    371   log0.GetEntries(&entries0);
    372 
    373   ASSERT_EQ(2u, entries0.size());
    374   EXPECT_EQ(NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD,
    375             entries0[0].type);
    376 
    377   // Check that request 1 completed as expected.
    378   EXPECT_EQ(1, callback1.WaitForResult());
    379   EXPECT_EQ("PROXY request1:80", results1.ToPacString());
    380 
    381   CapturingNetLog::CapturedEntryList entries1;
    382   log1.GetEntries(&entries1);
    383 
    384   ASSERT_EQ(4u, entries1.size());
    385   EXPECT_TRUE(LogContainsBeginEvent(
    386       entries1, 0,
    387       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
    388   EXPECT_TRUE(LogContainsEndEvent(
    389       entries1, 1,
    390       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
    391 
    392   // Check that request 2 completed as expected.
    393   EXPECT_EQ(2, callback2.WaitForResult());
    394   EXPECT_EQ("PROXY request2:80", results2.ToPacString());
    395 
    396   CapturingNetLog::CapturedEntryList entries2;
    397   log2.GetEntries(&entries2);
    398 
    399   ASSERT_EQ(4u, entries2.size());
    400   EXPECT_TRUE(LogContainsBeginEvent(
    401       entries2, 0,
    402       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
    403   EXPECT_TRUE(LogContainsEndEvent(
    404       entries2, 1,
    405       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
    406 }
    407 
    408 // Cancel a request which is in progress, and then cancel a request which
    409 // is pending.
    410 TEST(MultiThreadedProxyResolverTest, SingleThread_CancelRequest) {
    411   const size_t kNumThreads = 1u;
    412   scoped_ptr<BlockableProxyResolver> mock(new BlockableProxyResolver);
    413   MultiThreadedProxyResolver resolver(
    414       new ForwardingProxyResolverFactory(mock.get()),
    415                                       kNumThreads);
    416 
    417   int rv;
    418 
    419   // Initialize the resolver.
    420   TestCompletionCallback init_callback;
    421   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("foo"),
    422                              init_callback.callback());
    423   EXPECT_EQ(OK, init_callback.WaitForResult());
    424 
    425   // Block the proxy resolver, so no request can complete.
    426   mock->Block();
    427 
    428   // Start request 0.
    429   ProxyResolver::RequestHandle request0;
    430   TestCompletionCallback callback0;
    431   ProxyInfo results0;
    432   rv = resolver.GetProxyForURL(GURL("http://request0"), &results0,
    433                                callback0.callback(), &request0, BoundNetLog());
    434   EXPECT_EQ(ERR_IO_PENDING, rv);
    435 
    436   // Wait until requests 0 reaches the worker thread.
    437   mock->WaitUntilBlocked();
    438 
    439   // Start 3 more requests (request1 : request3).
    440 
    441   TestCompletionCallback callback1;
    442   ProxyInfo results1;
    443   rv = resolver.GetProxyForURL(GURL("http://request1"), &results1,
    444                                callback1.callback(), NULL, BoundNetLog());
    445   EXPECT_EQ(ERR_IO_PENDING, rv);
    446 
    447   ProxyResolver::RequestHandle request2;
    448   TestCompletionCallback callback2;
    449   ProxyInfo results2;
    450   rv = resolver.GetProxyForURL(GURL("http://request2"), &results2,
    451                                callback2.callback(), &request2, BoundNetLog());
    452   EXPECT_EQ(ERR_IO_PENDING, rv);
    453 
    454   TestCompletionCallback callback3;
    455   ProxyInfo results3;
    456   rv = resolver.GetProxyForURL(GURL("http://request3"), &results3,
    457                                callback3.callback(), NULL, BoundNetLog());
    458   EXPECT_EQ(ERR_IO_PENDING, rv);
    459 
    460   // Cancel request0 (inprogress) and request2 (pending).
    461   resolver.CancelRequest(request0);
    462   resolver.CancelRequest(request2);
    463 
    464   // Unblock the worker thread so the requests can continue running.
    465   mock->Unblock();
    466 
    467   // Wait for requests 1 and 3 to finish.
    468 
    469   rv = callback1.WaitForResult();
    470   EXPECT_EQ(1, rv);
    471   EXPECT_EQ("PROXY request1:80", results1.ToPacString());
    472 
    473   rv = callback3.WaitForResult();
    474   // Note that since request2 was cancelled before reaching the resolver,
    475   // the request count is 2 and not 3 here.
    476   EXPECT_EQ(2, rv);
    477   EXPECT_EQ("PROXY request3:80", results3.ToPacString());
    478 
    479   // Requests 0 and 2 which were cancelled, hence their completion callbacks
    480   // were never summoned.
    481   EXPECT_FALSE(callback0.have_result());
    482   EXPECT_FALSE(callback2.have_result());
    483 }
    484 
    485 // Test that deleting MultiThreadedProxyResolver while requests are
    486 // outstanding cancels them (and doesn't leak anything).
    487 TEST(MultiThreadedProxyResolverTest, SingleThread_CancelRequestByDeleting) {
    488   const size_t kNumThreads = 1u;
    489   scoped_ptr<BlockableProxyResolver> mock(new BlockableProxyResolver);
    490   scoped_ptr<MultiThreadedProxyResolver> resolver(
    491       new MultiThreadedProxyResolver(
    492           new ForwardingProxyResolverFactory(mock.get()), kNumThreads));
    493 
    494   int rv;
    495 
    496   // Initialize the resolver.
    497   TestCompletionCallback init_callback;
    498   rv = resolver->SetPacScript(ProxyResolverScriptData::FromUTF8("foo"),
    499                               init_callback.callback());
    500   EXPECT_EQ(OK, init_callback.WaitForResult());
    501 
    502   // Block the proxy resolver, so no request can complete.
    503   mock->Block();
    504 
    505   // Start 3 requests.
    506 
    507   TestCompletionCallback callback0;
    508   ProxyInfo results0;
    509   rv = resolver->GetProxyForURL(GURL("http://request0"), &results0,
    510                                 callback0.callback(), NULL, BoundNetLog());
    511   EXPECT_EQ(ERR_IO_PENDING, rv);
    512 
    513   TestCompletionCallback callback1;
    514   ProxyInfo results1;
    515   rv = resolver->GetProxyForURL(GURL("http://request1"), &results1,
    516                                 callback1.callback(), NULL, BoundNetLog());
    517   EXPECT_EQ(ERR_IO_PENDING, rv);
    518 
    519   TestCompletionCallback callback2;
    520   ProxyInfo results2;
    521   rv = resolver->GetProxyForURL(GURL("http://request2"), &results2,
    522                                 callback2.callback(), NULL, BoundNetLog());
    523   EXPECT_EQ(ERR_IO_PENDING, rv);
    524 
    525   // Wait until request 0 reaches the worker thread.
    526   mock->WaitUntilBlocked();
    527 
    528   // Add some latency, to improve the chance that when
    529   // MultiThreadedProxyResolver is deleted below we are still running inside
    530   // of the worker thread. The test will pass regardless, so this race doesn't
    531   // cause flakiness. However the destruction during execution is a more
    532   // interesting case to test.
    533   mock->SetResolveLatency(base::TimeDelta::FromMilliseconds(100));
    534 
    535   // Unblock the worker thread and delete the underlying
    536   // MultiThreadedProxyResolver immediately.
    537   mock->Unblock();
    538   resolver.reset();
    539 
    540   // Give any posted tasks a chance to run (in case there is badness).
    541   base::MessageLoop::current()->RunUntilIdle();
    542 
    543   // Check that none of the outstanding requests were completed.
    544   EXPECT_FALSE(callback0.have_result());
    545   EXPECT_FALSE(callback1.have_result());
    546   EXPECT_FALSE(callback2.have_result());
    547 }
    548 
    549 // Cancel an outstanding call to SetPacScriptByData().
    550 TEST(MultiThreadedProxyResolverTest, SingleThread_CancelSetPacScript) {
    551   const size_t kNumThreads = 1u;
    552   scoped_ptr<BlockableProxyResolver> mock(new BlockableProxyResolver);
    553   MultiThreadedProxyResolver resolver(
    554       new ForwardingProxyResolverFactory(mock.get()), kNumThreads);
    555 
    556   int rv;
    557 
    558   TestCompletionCallback set_pac_script_callback;
    559   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("data"),
    560                              set_pac_script_callback.callback());
    561   EXPECT_EQ(ERR_IO_PENDING, rv);
    562 
    563   // Cancel the SetPacScriptByData request.
    564   resolver.CancelSetPacScript();
    565 
    566   // Start another SetPacScript request
    567   TestCompletionCallback set_pac_script_callback2;
    568   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("data2"),
    569                              set_pac_script_callback2.callback());
    570   EXPECT_EQ(ERR_IO_PENDING, rv);
    571 
    572   // Wait for the initialization to complete.
    573 
    574   rv = set_pac_script_callback2.WaitForResult();
    575   EXPECT_EQ(0, rv);
    576   EXPECT_EQ(ASCIIToUTF16("data2"), mock->last_script_data()->utf16());
    577 
    578   // The first SetPacScript callback should never have been completed.
    579   EXPECT_FALSE(set_pac_script_callback.have_result());
    580 }
    581 
    582 // Tests setting the PAC script once, lazily creating new threads, and
    583 // cancelling requests.
    584 TEST(MultiThreadedProxyResolverTest, ThreeThreads_Basic) {
    585   const size_t kNumThreads = 3u;
    586   BlockableProxyResolverFactory* factory = new BlockableProxyResolverFactory;
    587   MultiThreadedProxyResolver resolver(factory, kNumThreads);
    588 
    589   int rv;
    590 
    591   EXPECT_TRUE(resolver.expects_pac_bytes());
    592 
    593   // Call SetPacScriptByData() -- verify that it reaches the synchronous
    594   // resolver.
    595   TestCompletionCallback set_script_callback;
    596   rv = resolver.SetPacScript(
    597       ProxyResolverScriptData::FromUTF8("pac script bytes"),
    598       set_script_callback.callback());
    599   EXPECT_EQ(ERR_IO_PENDING, rv);
    600   EXPECT_EQ(OK, set_script_callback.WaitForResult());
    601   // One thread has been provisioned (i.e. one ProxyResolver was created).
    602   ASSERT_EQ(1u, factory->resolvers().size());
    603   EXPECT_EQ(ASCIIToUTF16("pac script bytes"),
    604             factory->resolvers()[0]->last_script_data()->utf16());
    605 
    606   const int kNumRequests = 9;
    607   TestCompletionCallback callback[kNumRequests];
    608   ProxyInfo results[kNumRequests];
    609   ProxyResolver::RequestHandle request[kNumRequests];
    610 
    611   // Start request 0 -- this should run on thread 0 as there is nothing else
    612   // going on right now.
    613   rv = resolver.GetProxyForURL(
    614       GURL("http://request0"), &results[0], callback[0].callback(), &request[0],
    615       BoundNetLog());
    616   EXPECT_EQ(ERR_IO_PENDING, rv);
    617 
    618   // Wait for request 0 to finish.
    619   rv = callback[0].WaitForResult();
    620   EXPECT_EQ(0, rv);
    621   EXPECT_EQ("PROXY request0:80", results[0].ToPacString());
    622   ASSERT_EQ(1u, factory->resolvers().size());
    623   EXPECT_EQ(1, factory->resolvers()[0]->request_count());
    624 
    625   base::MessageLoop::current()->RunUntilIdle();
    626 
    627   // We now start 8 requests in parallel -- this will cause the maximum of
    628   // three threads to be provisioned (an additional two from what we already
    629   // have).
    630 
    631   for (int i = 1; i < kNumRequests; ++i) {
    632     rv = resolver.GetProxyForURL(
    633         GURL(base::StringPrintf("http://request%d", i)), &results[i],
    634         callback[i].callback(), &request[i], BoundNetLog());
    635     EXPECT_EQ(ERR_IO_PENDING, rv);
    636   }
    637 
    638   // We should now have a total of 3 threads, each with its own ProxyResolver
    639   // that will get initialized with the same data. (We check this later since
    640   // the assignment happens on the worker threads and may not have occurred
    641   // yet.)
    642   ASSERT_EQ(3u, factory->resolvers().size());
    643 
    644   // Cancel 3 of the 8 oustanding requests.
    645   resolver.CancelRequest(request[1]);
    646   resolver.CancelRequest(request[3]);
    647   resolver.CancelRequest(request[6]);
    648 
    649   // Wait for the remaining requests to complete.
    650   int kNonCancelledRequests[] = {2, 4, 5, 7, 8};
    651   for (size_t i = 0; i < arraysize(kNonCancelledRequests); ++i) {
    652     int request_index = kNonCancelledRequests[i];
    653     EXPECT_GE(callback[request_index].WaitForResult(), 0);
    654   }
    655 
    656   // Check that the cancelled requests never invoked their callback.
    657   EXPECT_FALSE(callback[1].have_result());
    658   EXPECT_FALSE(callback[3].have_result());
    659   EXPECT_FALSE(callback[6].have_result());
    660 
    661   // We call SetPacScript again, solely to stop the current worker threads.
    662   // (That way we can test to see the values observed by the synchronous
    663   // resolvers in a non-racy manner).
    664   TestCompletionCallback set_script_callback2;
    665   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("xyz"),
    666                              set_script_callback2.callback());
    667   EXPECT_EQ(ERR_IO_PENDING, rv);
    668   EXPECT_EQ(OK, set_script_callback2.WaitForResult());
    669   ASSERT_EQ(4u, factory->resolvers().size());
    670 
    671   for (int i = 0; i < 3; ++i) {
    672     EXPECT_EQ(
    673         ASCIIToUTF16("pac script bytes"),
    674         factory->resolvers()[i]->last_script_data()->utf16()) << "i=" << i;
    675   }
    676 
    677   EXPECT_EQ(ASCIIToUTF16("xyz"),
    678             factory->resolvers()[3]->last_script_data()->utf16());
    679 
    680   // We don't know the exact ordering that requests ran on threads with,
    681   // but we do know the total count that should have reached the threads.
    682   // 8 total were submitted, and three were cancelled. Of the three that
    683   // were cancelled, one of them (request 1) was cancelled after it had
    684   // already been posted to the worker thread. So the resolvers will
    685   // have seen 6 total (and 1 from the run prior).
    686   ASSERT_EQ(4u, factory->resolvers().size());
    687   int total_count = 0;
    688   for (int i = 0; i < 3; ++i) {
    689     total_count += factory->resolvers()[i]->request_count();
    690   }
    691   EXPECT_EQ(7, total_count);
    692 }
    693 
    694 // Tests using two threads. The first request hangs the first thread. Checks
    695 // that other requests are able to complete while this first request remains
    696 // stalled.
    697 TEST(MultiThreadedProxyResolverTest, OneThreadBlocked) {
    698   const size_t kNumThreads = 2u;
    699   BlockableProxyResolverFactory* factory = new BlockableProxyResolverFactory;
    700   MultiThreadedProxyResolver resolver(factory, kNumThreads);
    701 
    702   int rv;
    703 
    704   EXPECT_TRUE(resolver.expects_pac_bytes());
    705 
    706   // Initialize the resolver.
    707   TestCompletionCallback set_script_callback;
    708   rv = resolver.SetPacScript(
    709       ProxyResolverScriptData::FromUTF8("pac script bytes"),
    710       set_script_callback.callback());
    711   EXPECT_EQ(ERR_IO_PENDING, rv);
    712   EXPECT_EQ(OK, set_script_callback.WaitForResult());
    713   // One thread has been provisioned (i.e. one ProxyResolver was created).
    714   ASSERT_EQ(1u, factory->resolvers().size());
    715   EXPECT_EQ(ASCIIToUTF16("pac script bytes"),
    716             factory->resolvers()[0]->last_script_data()->utf16());
    717 
    718   const int kNumRequests = 4;
    719   TestCompletionCallback callback[kNumRequests];
    720   ProxyInfo results[kNumRequests];
    721   ProxyResolver::RequestHandle request[kNumRequests];
    722 
    723   // Start a request that will block the first thread.
    724 
    725   factory->resolvers()[0]->Block();
    726 
    727   rv = resolver.GetProxyForURL(
    728       GURL("http://request0"), &results[0], callback[0].callback(), &request[0],
    729       BoundNetLog());
    730 
    731   EXPECT_EQ(ERR_IO_PENDING, rv);
    732   factory->resolvers()[0]->WaitUntilBlocked();
    733 
    734   // Start 3 more requests -- they should all be serviced by thread #2
    735   // since thread #1 is blocked.
    736 
    737   for (int i = 1; i < kNumRequests; ++i) {
    738     rv = resolver.GetProxyForURL(
    739         GURL(base::StringPrintf("http://request%d", i)),
    740         &results[i], callback[i].callback(), &request[i], BoundNetLog());
    741     EXPECT_EQ(ERR_IO_PENDING, rv);
    742   }
    743 
    744   // Wait for the three requests to complete (they should complete in FIFO
    745   // order).
    746   for (int i = 1; i < kNumRequests; ++i) {
    747     EXPECT_EQ(i - 1, callback[i].WaitForResult());
    748   }
    749 
    750   // Unblock the first thread.
    751   factory->resolvers()[0]->Unblock();
    752   EXPECT_EQ(0, callback[0].WaitForResult());
    753 
    754   // All in all, the first thread should have seen just 1 request. And the
    755   // second thread 3 requests.
    756   ASSERT_EQ(2u, factory->resolvers().size());
    757   EXPECT_EQ(1, factory->resolvers()[0]->request_count());
    758   EXPECT_EQ(3, factory->resolvers()[1]->request_count());
    759 }
    760 
    761 }  // namespace
    762 
    763 }  // namespace net
    764