Update Chromium to beta version 37.0.2062.68

Change-Id: I188e3b5aff1bec75566014291b654eb19f5bc8ca
Reviewed-by: Andras Becsi <andras.becsi@digia.com>

1 files changed, 63 insertions, 47 deletions

diff --git a/chromium/net/dns/host_resolver_impl_unittest.cc b/chromium/net/dns/host_resolver_impl_unittest.cc
index 5d19fdcda12..4ab8fdf1c36 100644
--- a/chromium/net/dns/host_resolver_impl_unittest.cc
+++ b/chromium/net/dns/host_resolver_impl_unittest.cc
@@ -24,7 +24,6 @@
 #include "net/base/net_util.h"
 #include "net/dns/dns_client.h"
 #include "net/dns/dns_test_util.h"
-#include "net/dns/host_cache.h"
 #include "net/dns/mock_host_resolver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -35,9 +34,12 @@ namespace {
 const size_t kMaxJobs = 10u;
 const size_t kMaxRetryAttempts = 4u;
 
-PrioritizedDispatcher::Limits DefaultLimits() {
-  PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, kMaxJobs);
-  return limits;
+HostResolver::Options DefaultOptions() {
+  HostResolver::Options options;
+  options.max_concurrent_resolves = kMaxJobs;
+  options.max_retry_attempts = kMaxRetryAttempts;
+  options.enable_caching = true;
+  return options;
 }
 
 HostResolverImpl::ProcTaskParams DefaultParams(
@@ -422,7 +424,7 @@ class HostResolverImplTest : public testing::Test {
   HostResolverImplTest() : proc_(new MockHostResolverProc()) {}
 
   void CreateResolver() {
-    CreateResolverWithLimitsAndParams(DefaultLimits(),
+    CreateResolverWithLimitsAndParams(kMaxJobs,
                                       DefaultParams(proc_.get()));
   }
 
@@ -431,8 +433,7 @@ class HostResolverImplTest : public testing::Test {
   void CreateSerialResolver() {
     HostResolverImpl::ProcTaskParams params = DefaultParams(proc_.get());
     params.max_retry_attempts = 0u;
-    PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
-    CreateResolverWithLimitsAndParams(limits, params);
+    CreateResolverWithLimitsAndParams(1u, params);
   }
 
  protected:
@@ -470,10 +471,12 @@ class HostResolverImplTest : public testing::Test {
   }
 
   virtual void CreateResolverWithLimitsAndParams(
-      const PrioritizedDispatcher::Limits& limits,
+      size_t max_concurrent_resolves,
       const HostResolverImpl::ProcTaskParams& params) {
-    resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
-                                         limits, params, NULL));
+    HostResolverImpl::Options options = DefaultOptions();
+    options.max_concurrent_resolves = max_concurrent_resolves;
+    resolver_.reset(new HostResolverImpl(options, NULL));
+    resolver_->set_proc_params_for_test(params);
   }
 
   // The Request will not be made until a call to |Resolve()|, and the Job will
@@ -599,7 +602,13 @@ TEST_F(HostResolverImplTest, AbortedAsynchronousLookup) {
   EXPECT_FALSE(req0->completed());
 }
 
-TEST_F(HostResolverImplTest, NumericIPv4Address) {
+#if defined(THREAD_SANITIZER)
+// Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140
+#define MAYBE_NumericIPv4Address DISABLED_NumericIPv4Address
+#else
+#define MAYBE_NumericIPv4Address NumericIPv4Address
+#endif
+TEST_F(HostResolverImplTest, MAYBE_NumericIPv4Address) {
   // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in.
   Request* req = CreateRequest("127.1.2.3", 5555);
   EXPECT_EQ(OK, req->Resolve());
@@ -607,7 +616,13 @@ TEST_F(HostResolverImplTest, NumericIPv4Address) {
   EXPECT_TRUE(req->HasOneAddress("127.1.2.3", 5555));
 }
 
-TEST_F(HostResolverImplTest, NumericIPv6Address) {
+#if defined(THREAD_SANITIZER)
+// Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140
+#define MAYBE_NumericIPv6Address DISABLED_NumericIPv6Address
+#else
+#define MAYBE_NumericIPv6Address NumericIPv6Address
+#endif
+TEST_F(HostResolverImplTest, MAYBE_NumericIPv6Address) {
   // Resolve a plain IPv6 address.  Don't worry about [brackets], because
   // the caller should have removed them.
   Request* req = CreateRequest("2001:db8::1", 5555);
@@ -616,12 +631,27 @@ TEST_F(HostResolverImplTest, NumericIPv6Address) {
   EXPECT_TRUE(req->HasOneAddress("2001:db8::1", 5555));
 }
 
-TEST_F(HostResolverImplTest, EmptyHost) {
+#if defined(THREAD_SANITIZER)
+// Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140
+#define MAYBE_EmptyHost DISABLED_EmptyHost
+#else
+#define MAYBE_EmptyHost EmptyHost
+#endif
+TEST_F(HostResolverImplTest, MAYBE_EmptyHost) {
   Request* req = CreateRequest(std::string(), 5555);
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());
 }
 
-TEST_F(HostResolverImplTest, EmptyDotsHost) {
+#if defined(THREAD_SANITIZER)
+// There's a data race in this test that may lead to use-after-free.
+// If the test starts to crash without ThreadSanitizer it needs to be disabled
+// globally. See http://crbug.com/268946 (stacks for this test in
+// crbug.com/333567).
+#define MAYBE_EmptyDotsHost DISABLED_EmptyDotsHost
+#else
+#define MAYBE_EmptyDotsHost EmptyDotsHost
+#endif
+TEST_F(HostResolverImplTest, MAYBE_EmptyDotsHost) {
   for (int i = 0; i < 16; ++i) {
     Request* req = CreateRequest(std::string(i, '.'), 5555);
     EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());
@@ -808,10 +838,10 @@ TEST_F(HostResolverImplTest, StartWithinCallback) {
   set_handler(new MyHandler());
 
   // Turn off caching for this host resolver.
-  resolver_.reset(new HostResolverImpl(scoped_ptr<HostCache>(),
-                                       DefaultLimits(),
-                                       DefaultParams(proc_.get()),
-                                       NULL));
+  HostResolver::Options options = DefaultOptions();
+  options.enable_caching = false;
+  resolver_.reset(new HostResolverImpl(options, NULL));
+  resolver_->set_proc_params_for_test(DefaultParams(proc_.get()));
 
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
@@ -1245,11 +1275,8 @@ TEST_F(HostResolverImplTest, MultipleAttempts) {
   // (500ms * 3).
   params.unresponsive_delay = base::TimeDelta::FromMilliseconds(500);
 
-  resolver_.reset(
-      new HostResolverImpl(HostCache::CreateDefaultCache(),
-                           DefaultLimits(),
-                           params,
-                           NULL));
+  resolver_.reset(new HostResolverImpl(DefaultOptions(), NULL));
+  resolver_->set_proc_params_for_test(params);
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
@@ -1326,12 +1353,12 @@ class HostResolverImplDnsTest : public HostResolverImplTest {
 
   // HostResolverImplTest implementation:
   virtual void CreateResolverWithLimitsAndParams(
-      const PrioritizedDispatcher::Limits& limits,
+      size_t max_concurrent_resolves,
       const HostResolverImpl::ProcTaskParams& params) OVERRIDE {
-    resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
-                                         limits,
-                                         params,
-                                         NULL));
+    HostResolverImpl::Options options = DefaultOptions();
+    options.max_concurrent_resolves = max_concurrent_resolves;
+    resolver_.reset(new HostResolverImpl(options, NULL));
+    resolver_->set_proc_params_for_test(params);
     // Disable IPv6 support probing.
     resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
     dns_client_ = new MockDnsClient(DnsConfig(), dns_rules_);
@@ -1661,10 +1688,9 @@ TEST_F(HostResolverImplDnsTest, DontDisableDnsClientOnSporadicFailure) {
 TEST_F(HostResolverImplDnsTest, DualFamilyLocalhost) {
   // Use regular SystemHostResolverCall!
   scoped_refptr<HostResolverProc> proc(new SystemHostResolverProc());
-  resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
-                                       DefaultLimits(),
-                                       DefaultParams(proc.get()),
-                                       NULL));
+  resolver_.reset(new HostResolverImpl(DefaultOptions(), NULL));
+  resolver_->set_proc_params_for_test(DefaultParams(proc.get()));
+
   resolver_->SetDnsClient(
       scoped_ptr<DnsClient>(new MockDnsClient(DnsConfig(), dns_rules_)));
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
@@ -1759,9 +1785,7 @@ TEST_F(HostResolverImplDnsTest, CancelWithTwoTransactionsActive) {
 // Delete a resolver with some active requests and some queued requests.
 TEST_F(HostResolverImplDnsTest, DeleteWithActiveTransactions) {
   // At most 10 Jobs active at once.
-  CreateResolverWithLimitsAndParams(
-      PrioritizedDispatcher::Limits(NUM_PRIORITIES, 10u),
-      DefaultParams(proc_.get()));
+  CreateResolverWithLimitsAndParams(10u, DefaultParams(proc_.get()));
 
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
@@ -1872,9 +1896,7 @@ TEST_F(HostResolverImplDnsTest, SerialResolver) {
 // Test the case where the AAAA query is started when another transaction
 // completes.
 TEST_F(HostResolverImplDnsTest, AAAAStartsAfterOtherJobFinishes) {
-  CreateResolverWithLimitsAndParams(
-      PrioritizedDispatcher::Limits(NUM_PRIORITIES, 2),
-      DefaultParams(proc_.get()));
+  CreateResolverWithLimitsAndParams(2u, DefaultParams(proc_.get()));
   set_fallback_to_proctask(false);
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
@@ -1933,9 +1955,7 @@ TEST_F(HostResolverImplDnsTest, InvalidDnsConfigWithPendingRequests) {
   // make sure that aborting the first HostResolverImpl::Job does not trigger
   // another DnsTransaction on the second Job when it releases its second
   // prioritized dispatcher slot.
-  CreateResolverWithLimitsAndParams(
-      PrioritizedDispatcher::Limits(NUM_PRIORITIES, 3u),
-      DefaultParams(proc_.get()));
+  CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()));
 
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
@@ -1976,9 +1996,7 @@ TEST_F(HostResolverImplDnsTest,
   // occupying two slots has its DnsTask aborted is the case most likely to run
   // into problems.
   for (size_t limit = 1u; limit < 6u; ++limit) {
-    CreateResolverWithLimitsAndParams(
-        PrioritizedDispatcher::Limits(NUM_PRIORITIES, limit),
-        DefaultParams(proc_.get()));
+    CreateResolverWithLimitsAndParams(limit, DefaultParams(proc_.get()));
 
     resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
     ChangeDnsConfig(CreateValidDnsConfig());
@@ -2025,9 +2043,7 @@ TEST_F(HostResolverImplDnsTest, ManuallyDisableDnsClientWithPendingRequests) {
   // make sure that aborting the first HostResolverImpl::Job does not trigger
   // another DnsTransaction on the second Job when it releases its second
   // prioritized dispatcher slot.
-  CreateResolverWithLimitsAndParams(
-      PrioritizedDispatcher::Limits(NUM_PRIORITIES, 3u),
-      DefaultParams(proc_.get()));
+  CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()));
 
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());