Deflake MultiThreadedProxyResolverTest.ThreeThreads_Basic.

net/proxy/multi_threaded_proxy_resolver_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/proxy/multi_threaded_proxy_resolver.h"
 
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 508 matching lines @@
 // Tests setting the PAC script once, lazily creating new threads, and
 // cancelling requests.
 TEST_F(MultiThreadedProxyResolverTest, ThreeThreads_Basic) {
   const size_t kNumThreads = 3u;
   ASSERT_NO_FATAL_FAILURE(Init(kNumThreads));
 
   // Verify that it reaches the synchronous resolver.
   // One thread has been provisioned (i.e. one ProxyResolver was created).
   ASSERT_EQ(1u, factory().resolvers().size());
 
-  const int kNumRequests = 9;
+  const int kNumRequests = 8;
   int rv;
   TestCompletionCallback callback[kNumRequests];
   ProxyInfo results[kNumRequests];
   ProxyResolver::RequestHandle request[kNumRequests];
 
   // Start request 0 -- this should run on thread 0 as there is nothing else
   // going on right now.
   rv = resolver().GetProxyForURL(GURL("http://request0"), &results[0],
                                  callback[0].callback(), &request[0],
                                  BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait for request 0 to finish.
   rv = callback[0].WaitForResult();
   EXPECT_EQ(0, rv);
   EXPECT_EQ("PROXY request0:80", results[0].ToPacString());
   ASSERT_EQ(1u, factory().resolvers().size());
   EXPECT_EQ(1, factory().resolvers()[0]->request_count());
 
   base::MessageLoop::current()->RunUntilIdle();
 
-  // We now start 8 requests in parallel -- this will cause the maximum of
-  // three threads to be provisioned (an additional two from what we already
-  // have).
+  // We now block the first resolver to ensure a request is sent to the second
+  // thread.
+  factory().resolvers()[0]->Block();
+  rv = resolver().GetProxyForURL(GURL("http://request1"), &results[1],
+                                 callback[1].callback(), &request[1],
+                                 BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  rv = resolver().GetProxyForURL(GURL("http://request2"), &results[2],
+                                 callback[2].callback(), &request[2],
+                                 BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_EQ(0, callback[2].WaitForResult());
+  ASSERT_EQ(2u, factory().resolvers().size());
 
-  for (int i = 1; i < kNumRequests; ++i) {
-    rv = resolver().GetProxyForURL(
-        GURL(base::StringPrintf("http://request%d", i)), &results[i],
-        callback[i].callback(), &request[i], BoundNetLog());
-    EXPECT_EQ(ERR_IO_PENDING, rv);
-  }
-
-  // Cancel 3 of the 8 oustanding requests.
-  resolver().CancelRequest(request[1]);
-  resolver().CancelRequest(request[3]);
-  resolver().CancelRequest(request[6]);
-
-  // Wait for the remaining requests to complete.
-  int kNonCancelledRequests[] = {2, 4, 5, 7, 8};
-  for (size_t i = 0; i < arraysize(kNonCancelledRequests); ++i) {
-    int request_index = kNonCancelledRequests[i];
-    EXPECT_GE(callback[request_index].WaitForResult(), 0);
-  }
-
-  // Check that the cancelled requests never invoked their callback.
-  EXPECT_FALSE(callback[1].have_result());
-  EXPECT_FALSE(callback[3].have_result());
-  EXPECT_FALSE(callback[6].have_result());
+  // We now block the second resolver as well to ensure a request is sent to the
+  // third thread.
+  factory().resolvers()[1]->Block();
+  rv = resolver().GetProxyForURL(GURL("http://request3"), &results[3],
+                                 callback[3].callback(), &request[3],
+                                 BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  rv = resolver().GetProxyForURL(GURL("http://request4"), &results[4],
+                                 callback[4].callback(), &request[4],
+                                 BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_EQ(0, callback[4].WaitForResult());
 
   // We should now have a total of 3 threads, each with its own ProxyResolver
   // that will get initialized with the same data.
   ASSERT_EQ(3u, factory().resolvers().size());
 
   ASSERT_EQ(3u, factory().script_data().size());
   for (int i = 0; i < 3; ++i) {
     EXPECT_EQ(ASCIIToUTF16("pac script bytes"),
               factory().script_data()[i]->utf16())
         << "i=" << i;
   }
 
-  // We don't know the exact ordering that requests ran on threads with,
-  // but we do know the total count that should have reached the threads.
-  // 8 total were submitted, and three were cancelled. Of the three that
-  // were cancelled, one of them (request 1) was cancelled after it had
-  // already been posted to the worker thread. So the resolvers will
-  // have seen 6 total (and 1 from the run prior).
-  int total_count = 0;
-  for (int i = 0; i < 3; ++i) {
-    total_count += factory().resolvers()[i]->request_count();
-  }
-  EXPECT_EQ(7, total_count);
+  // Start and cancel two requests. Since the first two threads are still
+  // blocked, they'll both be serviced by the third thread. The first request
+  // will reach the resolver, but the second will still be queued when canceled.
+  // Start a third request so we can be sure the resolver has completed running
+  // the first request.
+  rv = resolver().GetProxyForURL(GURL("http://request5"), &results[5],
+                                 callback[5].callback(), &request[5],
+                                 BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  rv = resolver().GetProxyForURL(GURL("http://request6"), &results[6],
+                                 callback[6].callback(), &request[6],
+                                 BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  rv = resolver().GetProxyForURL(GURL("http://request7"), &results[7],
+                                 callback[7].callback(), &request[7],
+                                 BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  resolver().CancelRequest(request[5]);
+  resolver().CancelRequest(request[6]);
+
+  EXPECT_EQ(2, callback[7].WaitForResult());
+
+  // Check that the cancelled requests never invoked their callback.
+  EXPECT_FALSE(callback[5].have_result());
+  EXPECT_FALSE(callback[6].have_result());
+
+  // Unblock the first two threads and wait for their requests to complete.
+  factory().resolvers()[0]->Unblock();
+  factory().resolvers()[1]->Unblock();
+  EXPECT_EQ(1, callback[1].WaitForResult());
+  EXPECT_EQ(1, callback[3].WaitForResult());
+
+  EXPECT_EQ(2, factory().resolvers()[0]->request_count());
+  EXPECT_EQ(2, factory().resolvers()[1]->request_count());
+  EXPECT_EQ(3, factory().resolvers()[2]->request_count());
 }
 
 // Tests using two threads. The first request hangs the first thread. Checks
 // that other requests are able to complete while this first request remains
 // stalled.
 TEST_F(MultiThreadedProxyResolverTest, OneThreadBlocked) {
   const size_t kNumThreads = 2u;
   ASSERT_NO_FATAL_FAILURE(Init(kNumThreads));
 
   int rv;
@@ skipping 144 matching lines @@
   }
   // The factory destructor will block until the worker thread stops, but it may
   // post tasks to the origin message loop which are still pending. Run them
   // now to ensure it works as expected.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 
 }  // namespace net