Disable CertNetFetcherImplTest tests on Android

net/cert_net/cert_net_fetcher_impl_unittest.cc

 // Copyright 2015 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/cert_net/cert_net_fetcher_impl.h"
 
 #include <string>
 #include <utility>
 
 #include "base/compiler_specific.h"
@@ skipping 151 matching lines @@
 
 // Helper to start an AIA fetch using default parameters.
 WARN_UNUSED_RESULT std::unique_ptr<CertNetFetcher::Request> StartRequest(
     CertNetFetcher* fetcher,
     const GURL& url,
     const TestFetchCallback& callback) {
   return fetcher->FetchCaIssuers(url, CertNetFetcher::DEFAULT,
                                  CertNetFetcher::DEFAULT, callback.callback());
 }
 
+// Flaky on Android. See http://crbug.com/646147.
+#if defined(OS_ANDROID)
+#define MAYBE_ParallelFetchNoDuplicates DISABLED_ParallelFetchNoDuplicates
+#else
+#define MAYBE_ParallelFetchNoDuplicates ParallelFetchNoDuplicates
+#endif
 // Fetch a few unique URLs using GET in parallel. Each URL has a different body
 // and Content-Type.
-TEST_F(CertNetFetcherImplTest, ParallelFetchNoDuplicates) {
+TEST_F(CertNetFetcherImplTest, MAYBE_ParallelFetchNoDuplicates) {
   ASSERT_TRUE(test_server_.Start());
 
   CertNetFetcherImpl fetcher(&context_);
   TestFetchCallback callback1;
   TestFetchCallback callback2;
   TestFetchCallback callback3;
 
   // Request a URL with Content-Type "application/pkix-cert"
   GURL url1 = test_server_.GetURL("/cert.crt");
   std::unique_ptr<CertNetFetcher::Request> request1 =
@@ skipping 219 matching lines @@
   // Spin the message loop to increase chance of catching a bug.
   base::RunLoop().RunUntilIdle();
 
   // Should NOT complete synchronously despite being a test that could be done
   // immediately.
   EXPECT_FALSE(callback.HasResult());
 
   EXPECT_EQ(0, network_delegate_.created_requests());
 }
 
+// Flaky on Android. See http://crbug.com/646147.
+#if defined(OS_ANDROID)
+#define MAYBE_CancelBeforeRunningMessageLoop \
+  DISABLED_CancelBeforeRunningMessageLoop
+#else
+#define MAYBE_CancelBeforeRunningMessageLoop CancelBeforeRunningMessageLoop
+#endif
 // Start a few requests, and cancel one of them before running the message loop
 // again.
-TEST_F(CertNetFetcherImplTest, CancelBeforeRunningMessageLoop) {
+TEST_F(CertNetFetcherImplTest, MAYBE_CancelBeforeRunningMessageLoop) {
   ASSERT_TRUE(test_server_.Start());
 
   CertNetFetcherImpl fetcher(&context_);
   TestFetchCallback callback1;
   TestFetchCallback callback2;
   TestFetchCallback callback3;
 
   GURL url1 = test_server_.GetURL("/cert.crt");
   std::unique_ptr<CertNetFetcher::Request> request1 =
       StartRequest(&fetcher, url1, callback1);
@@ skipping 87 matching lines @@
 
   GURL url(test_server_.GetURL("/slow/certs.p7c?20"));
   TestFetchCallback callback;
   std::unique_ptr<CertNetFetcher::Request> request =
       StartRequest(fetcher.get(), url, callback);
 
   // Destroy the fetcher before the outstanding request.
   fetcher.reset();
 }
 
+// Flaky on Android. See http://crbug.com/646147.
+#if defined(OS_ANDROID)
+#define MAYBE_ParallelFetchDuplicates DISABLED_ParallelFetchDuplicates
+#else
+#define MAYBE_ParallelFetchDuplicates ParallelFetchDuplicates
+#endif
 // Fetch the same URLs in parallel and verify that only 1 request is made per
 // URL.
-TEST_F(CertNetFetcherImplTest, ParallelFetchDuplicates) {
+TEST_F(CertNetFetcherImplTest, MAYBE_ParallelFetchDuplicates) {
   ASSERT_TRUE(test_server_.Start());
 
   CertNetFetcherImpl fetcher(&context_);
 
   GURL url1 = test_server_.GetURL("/cert.crt");
   GURL url2 = test_server_.GetURL("/root.crl");
 
   // Issue 3 requests for url1, and 3 requests for url2
   TestFetchCallback callback1;
   std::unique_ptr<CertNetFetcher::Request> request1 =
@@ skipping 38 matching lines @@
   result2->VerifySuccess("-root.crl-\n");
   result4->VerifySuccess("-root.crl-\n");
   result5->VerifySuccess("-root.crl-\n");
   result6->VerifySuccess("-cert.crt-\n");
 
   // Verify that only 2 URLRequests were started even though 6 requests were
   // issued.
   EXPECT_EQ(2, network_delegate_.created_requests());
 }
 
+// Flaky on Android. See http://crbug.com/646147.
+#if defined(OS_ANDROID)
+#define MAYBE_CancelThenStart DISABLED_CancelThenStart
+#else
+#define MAYBE_CancelThenStart CancelThenStart
+#endif
 // Cancel a request and then start another one for the same URL.
-TEST_F(CertNetFetcherImplTest, CancelThenStart) {
+TEST_F(CertNetFetcherImplTest, MAYBE_CancelThenStart) {
   ASSERT_TRUE(test_server_.Start());
 
   CertNetFetcherImpl fetcher(&context_);
   TestFetchCallback callback1;
   TestFetchCallback callback2;
   TestFetchCallback callback3;
 
   GURL url = test_server_.GetURL("/cert.crt");
 
   std::unique_ptr<CertNetFetcher::Request> request1 =
@@ skipping 73 matching lines @@
   EXPECT_FALSE(callback[3].HasResult());
 }
 
 void FetchRequest(CertNetFetcher* fetcher,
                   const GURL& url,
                   TestFetchCallback* callback,
                   std::unique_ptr<CertNetFetcher::Request>* request) {
   *request = StartRequest(fetcher, url, *callback);
 }
 
+// Flaky on Android. See http://crbug.com/646147.
+#if defined(OS_ANDROID)
+#define MAYBE_FetchWithinCallback DISABLED_FetchWithinCallback
+#else
+#define MAYBE_FetchWithinCallback FetchWithinCallback
+#endif
 // Make a request during callback for the same URL.
-TEST_F(CertNetFetcherImplTest, FetchWithinCallback) {
+TEST_F(CertNetFetcherImplTest, MAYBE_FetchWithinCallback) {
   ASSERT_TRUE(test_server_.Start());
 
   CertNetFetcherImpl fetcher(&context_);
 
   GURL url = test_server_.GetURL("/cert.crt");
 
   TestFetchCallback callback[5];
   std::unique_ptr<CertNetFetcher::Request> req[5];
   callback[1].set_extra_closure(
       base::Bind(FetchRequest, &fetcher, url, &callback[4], &req[4]));
@@ skipping 41 matching lines @@
       continue;
 
     std::unique_ptr<FetchResult> result = callback[i].WaitForResult();
     result->VerifySuccess("-cert.crt-\n");
   }
 
   // request[2] was cancelled.
   EXPECT_FALSE(callback[2].HasResult());
 }
 
+// Flaky on Android. See http://crbug.com/646147.
+#if defined(OS_ANDROID)
+#define MAYBE_CancelLastRequestWithinCallback \
+  DISABLED_CancelLastRequestWithinCallback
+#else
+#define MAYBE_CancelLastRequestWithinCallback CancelLastRequestWithinCallback
+#endif
 // Cancel the final request while executing a callback for the same job. Ensure
 // that the job is not deleted twice.
-TEST_F(CertNetFetcherImplTest, CancelLastRequestWithinCallback) {
+TEST_F(CertNetFetcherImplTest, MAYBE_CancelLastRequestWithinCallback) {
   ASSERT_TRUE(test_server_.Start());
 
   CertNetFetcherImpl fetcher(&context_);
 
   GURL url = test_server_.GetURL("/cert.crt");
 
   TestFetchCallback callback1;
   std::unique_ptr<CertNetFetcher::Request> request1 =
       StartRequest(&fetcher, url, callback1);
 
   TestFetchCallback callback2;
   std::unique_ptr<CertNetFetcher::Request> request2 =
       StartRequest(&fetcher, url, callback1);
 
   // Cancel request2 when the callback for request1 runs.
   callback1.set_extra_closure(base::Bind(CancelRequest, &request2));
 
   EXPECT_EQ(1, network_delegate_.created_requests());
 
   std::unique_ptr<FetchResult> result = callback1.WaitForResult();
   result->VerifySuccess("-cert.crt-\n");
 
   // request2 was cancelled.
   EXPECT_FALSE(callback2.HasResult());
 }
 
 }  // namespace net