Disable flaky origin trial tests on Android

content/common/origin_trials/trial_token_validator_unittest.cc

 // Copyright 2016 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 "content/common/origin_trials/trial_token_validator.h"
 
 #include <memory>
 #include <set>
 #include <string>
 
@@ skipping 167 matching lines @@
   const url::Origin appropriate_origin_;
   const url::Origin inappropriate_origin_;
   const url::Origin insecure_origin_;
 
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
 
  private:
   TestContentClient test_content_client_;
 };
 
-TEST_F(TrialTokenValidatorTest, ValidateValidToken) {
+// Flaky on Android swarming bots: crbug.com/672294
+#if defined(OS_ANDROID)
+#define MAYBE_ValidateValidToken DISABLED_ValidateValidToken
+#else
+#define MAYBE_ValidateValidToken ValidateValidToken
+#endif
+TEST_F(TrialTokenValidatorTest, MAYBE_ValidateValidToken) {
   std::string feature;
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::Success,
             TrialTokenValidator::ValidateToken(kSampleToken,
                                                appropriate_origin_, &feature));
   EXPECT_EQ(kAppropriateFeatureName, feature);
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateInappropriateOrigin) {
   std::string feature;
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongOrigin,
@@ skipping 26 matching lines @@
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateValidTokenWithIncorrectKey) {
   std::string feature;
   SetPublicKey(kTestPublicKey2);
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::InvalidSignature,
             TrialTokenValidator::ValidateToken(kSampleToken,
                                                appropriate_origin_, &feature));
 }
 
-TEST_F(TrialTokenValidatorTest, ValidatorRespectsDisabledFeatures) {
+// Flaky on Android swarming bots: crbug.com/672294
+#if defined(OS_ANDROID)
+#define MAYBE_ValidatorRespectsDisabledFeatures DISABLED_ValidatorRespectsDisabledFeatures
+#else
+#define MAYBE_ValidatorRespectsDisabledFeatures ValidatorRespectsDisabledFeatures
+#endif
+TEST_F(TrialTokenValidatorTest, MAYBE_ValidatorRespectsDisabledFeatures) {
   std::string feature;
   // Disable an irrelevant feature; token should still validate
   DisableFeature(kInappropriateFeatureName);
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::Success,
             TrialTokenValidator::ValidateToken(kSampleToken,
                                                appropriate_origin_, &feature));
   EXPECT_EQ(kAppropriateFeatureName, feature);
   // Disable the token's feature; it should no longer be valid
   DisableFeature(kAppropriateFeatureName);
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::FeatureDisabled,
             TrialTokenValidator::ValidateToken(kSampleToken,
                                                appropriate_origin_, &feature));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateRequestInsecure) {
   response_headers_->AddHeader(std::string("Origin-Trial: ") +
                                kInsecureOriginToken);
   EXPECT_FALSE(TrialTokenValidator::RequestEnablesFeature(
       GURL(kInsecureOrigin), response_headers_.get(), kAppropriateFeatureName));
 }
 
-TEST_F(TrialTokenValidatorTest, ValidateRequestValidToken) {
+// Flaky on Android swarming bots: crbug.com/672294
+#if defined(OS_ANDROID)
+#define MAYBE_ValidateRequestValidToken DISABLED_ValidateRequestValidToken
+#else
+#define MAYBE_ValidateRequestValidToken ValidateRequestValidToken
+#endif
+TEST_F(TrialTokenValidatorTest, MAYBE_ValidateRequestValidToken) {
   response_headers_->AddHeader(std::string("Origin-Trial: ") + kSampleToken);
   EXPECT_TRUE(TrialTokenValidator::RequestEnablesFeature(
       GURL(kAppropriateOrigin), response_headers_.get(),
       kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateRequestNoTokens) {
   EXPECT_FALSE(TrialTokenValidator::RequestEnablesFeature(
       GURL(kAppropriateOrigin), response_headers_.get(),
       kAppropriateFeatureName));
 }
 
-TEST_F(TrialTokenValidatorTest, ValidateRequestMultipleHeaders) {
+// Flaky on Android swarming bots: crbug.com/672294
+#if defined(OS_ANDROID)
+#define MAYBE_ValidateRequestMultipleHeaders DISABLED_ValidateRequestMultipleHeaders
+#else
+#define MAYBE_ValidateRequestMultipleHeaders ValidateRequestMultipleHeaders
+#endif
+TEST_F(TrialTokenValidatorTest, MAYBE_ValidateRequestMultipleHeaders) {
   response_headers_->AddHeader(std::string("Origin-Trial: ") + kSampleToken);
   response_headers_->AddHeader(std::string("Origin-Trial: ") + kExpiredToken);
   EXPECT_TRUE(TrialTokenValidator::RequestEnablesFeature(
       GURL(kAppropriateOrigin), response_headers_.get(),
       kAppropriateFeatureName));
   EXPECT_FALSE(TrialTokenValidator::RequestEnablesFeature(
       GURL(kAppropriateOrigin), response_headers_.get(),
       kInappropriateFeatureName));
   EXPECT_FALSE(TrialTokenValidator::RequestEnablesFeature(
       GURL(kInappropriateOrigin), response_headers_.get(),
       kAppropriateFeatureName));
 }
 
-TEST_F(TrialTokenValidatorTest, ValidateRequestMultipleHeaderValues) {
+// Flaky on Android swarming bots: crbug.com/672294
+#if defined(OS_ANDROID)
+#define MAYBE_ValidateRequestMultipleHeaderValues DISABLED_ValidateRequestMultipleHeaderValues
+#else
+#define MAYBE_ValidateRequestMultipleHeaderValues ValidateRequestMultipleHeaderValues
+#endif
+TEST_F(TrialTokenValidatorTest, MAYBE_ValidateRequestMultipleHeaderValues) {
   response_headers_->AddHeader(std::string("Origin-Trial: ") + kExpiredToken +
                                ", " + kSampleToken);
   EXPECT_TRUE(TrialTokenValidator::RequestEnablesFeature(
       GURL(kAppropriateOrigin), response_headers_.get(),
       kAppropriateFeatureName));
   EXPECT_FALSE(TrialTokenValidator::RequestEnablesFeature(
       GURL(kAppropriateOrigin), response_headers_.get(),
       kInappropriateFeatureName));
   EXPECT_FALSE(TrialTokenValidator::RequestEnablesFeature(
       GURL(kInappropriateOrigin), response_headers_.get(),
       kAppropriateFeatureName));
 }
 
 }  // namespace content