Mark more of BackgroundTracingManagerBrowserTest flaky

content/browser/tracing/background_tracing_manager_browsertest.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 <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 136 matching lines @@
   content::BackgroundTracingManager::GetInstance()
       ->InvalidateTriggerHandlesForTesting();
 }
 
 void DisableScenarioWhenIdle() {
   BackgroundTracingManager::GetInstance()->SetActiveScenario(
       NULL, BackgroundTracingManager::ReceiveCallback(),
       BackgroundTracingManager::NO_DATA_FILTERING);
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_ReceiveTraceFinalContentsOnTrigger \
+        DISABLED_ReceiveTraceFinalContentsOnTrigger
+#else
+#define MAYBE_ReceiveTraceFinalContentsOnTrigger \
+        ReceiveTraceFinalContentsOnTrigger
+#endif
+
 // This tests that the endpoint receives the final trace data.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       ReceiveTraceFinalContentsOnTrigger) {
+                       MAYBE_ReceiveTraceFinalContentsOnTrigger) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
             GetInstance()->RegisterTriggerType("preemptive_test");
 
     EXPECT_TRUE(BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING));
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
         base::Bind(&DisableScenarioWhenIdle));
 
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_CallTriggersMoreThanOnceOnlyGatherOnce \
+        DISABLED_CallTriggersMoreThanOnceOnlyGatherOnce
+#else
+#define MAYBE_CallTriggersMoreThanOnceOnlyGatherOnce \
+        CallTriggersMoreThanOnceOnlyGatherOnce
+#endif
+
 // This tests triggering more than once still only gathers once.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       CallTriggersMoreThanOnceOnlyGatherOnce) {
+                       MAYBE_CallTriggersMoreThanOnceOnlyGatherOnce) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
@@ skipping 27 matching lines @@
   if (base::MatchPattern(category_group_name, "benchmark") &&
       base::MatchPattern(event_name, "whitelisted")) {
     return true;
   }
 
   return false;
 }
 
 }  // namespace
 
+#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
+// Flaky on android, chromeos: https://crbug.com/639706
+#define MAYBE_NoWhitelistedArgsStripped DISABLED_NoWhitelistedArgsStripped
+#else
+#define MAYBE_NoWhitelistedArgsStripped NoWhitelistedArgsStripped
+#endif
+
 // This tests that non-whitelisted args get stripped if required.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       NoWhitelistedArgsStripped) {
+                       MAYBE_NoWhitelistedArgsStripped) {
   SetupBackgroundTracingManager();
 
   base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate(
       base::Bind(&IsTraceEventArgsWhitelisted));
 
   base::RunLoop wait_for_upload;
   BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
       wait_for_upload.QuitClosure());
 
   std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
@@ skipping 21 matching lines @@
       handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 
   wait_for_upload.Run();
 
   EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("{"));
   EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("find_this"));
   EXPECT_FALSE(upload_config_wrapper.TraceHasMatchingString("this_not_found"));
 }
 
+#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
+// Flaky on android, chromeos: https://crbug.com/639706
+#define MAYBE_TraceMetadataInTrace DISABLED_TraceMetadataInTrace
+#else
+#define MAYBE_TraceMetadataInTrace TraceMetadataInTrace
+#endif
+
 // This tests that browser metadata gets included in the trace.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       TraceMetadataInTrace) {
+                       MAYBE_TraceMetadataInTrace) {
   SetupBackgroundTracingManager();
 
   base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate(
       base::Bind(&IsTraceEventArgsWhitelisted));
 
   base::RunLoop wait_for_upload;
   BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
       wait_for_upload.QuitClosure());
 
   std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
@@ skipping 18 matching lines @@
       handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 
   wait_for_upload.Run();
 
   EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("cpu-brand"));
   EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("network-type"));
   EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("user-agent"));
 }
 
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(OS_LINUX)
 // Flaky on android: https://crbug.com/639706
+// Flaky on android, linux: https://crbug.com/639706
 #define MAYBE_CrashWhenSubprocessWithoutArgumentFilter \
         DISABLED_CrashWhenSubprocessWithoutArgumentFilter
 #else
 #define MAYBE_CrashWhenSubprocessWithoutArgumentFilter \
         CrashWhenSubprocessWithoutArgumentFilter
 #endif
 
 // This tests subprocesses (like a navigating renderer) which gets told to
 // provide a argument-filtered trace and has no predicate in place to do the
 // filtering (in this case, only the browser process gets it set), will crash
@@ skipping 33 matching lines @@
       handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 
   wait_for_upload.Run();
 
   EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   // We should *not* receive anything at all from the renderer,
   // the process should've crashed rather than letting that happen.
   EXPECT_TRUE(!upload_config_wrapper.TraceHasMatchingString("CrRendererMain"));
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_CallMultipleTriggersOnlyGatherOnce \
+        DISABLED_CallMultipleTriggersOnlyGatherOnce
+#else
+#define MAYBE_CallMultipleTriggersOnlyGatherOnce \
+        CallMultipleTriggersOnlyGatherOnce
+#endif
+
 // This tests multiple triggers still only gathers once.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       CallMultipleTriggersOnlyGatherOnce) {
+                       MAYBE_CallMultipleTriggersOnlyGatherOnce) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
@@ skipping 37 matching lines @@
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle2,
         base::Bind(&StartedFinalizingCallback, base::Closure(), false));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_ToggleBlinkScenarios DISABLED_ToggleBlinkScenarios
+#else
+#define MAYBE_ToggleBlinkScenarios ToggleBlinkScenarios
+#endif
+
 // This tests that toggling Blink scenarios in the config alters the
 // command-line.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       ToggleBlinkScenarios) {
+                       MAYBE_ToggleBlinkScenarios) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
@@ skipping 25 matching lines @@
     EXPECT_TRUE(command_line);
 
     EXPECT_EQ(command_line->GetSwitchValueASCII(switches::kEnableBlinkFeatures),
               "FasterWeb1,FasterWeb2");
     EXPECT_EQ(
         command_line->GetSwitchValueASCII(switches::kDisableBlinkFeatures),
         "SlowerWeb1,SlowerWeb2");
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_ToggleBlinkScenariosNotOverridingSwitches \
+        DISABLED_ToggleBlinkScenariosNotOverridingSwitches
+#else
+#define MAYBE_ToggleBlinkScenariosNotOverridingSwitches \
+        ToggleBlinkScenariosNotOverridingSwitches
+#endif
+
 // This tests that toggling Blink scenarios in a scenario won't activate
 // if there's already Blink features toggled by something else (about://flags)
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       ToggleBlinkScenariosNotOverridingSwitches) {
+                       MAYBE_ToggleBlinkScenariosNotOverridingSwitches) {
   SetupBackgroundTracingManager();
 
   base::RunLoop run_loop;
   BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
       run_loop.QuitClosure());
 
   base::DictionaryValue dict;
   dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
   dict.SetString("category", "BENCHMARK");
 
@@ skipping 17 matching lines @@
       switches::kEnableBlinkFeatures, "FooFeature");
 
   bool scenario_activated =
       BackgroundTracingManager::GetInstance()->SetActiveScenario(
           std::move(config), upload_config_wrapper.get_receive_callback(),
           BackgroundTracingManager::NO_DATA_FILTERING);
 
   EXPECT_FALSE(scenario_activated);
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_CallPreemptiveTriggerWithDelay \
+        DISABLED_CallPreemptiveTriggerWithDelay
+#else
+#define MAYBE_CallPreemptiveTriggerWithDelay CallPreemptiveTriggerWithDelay
+#endif
+
 // This tests that delayed histogram triggers triggers work as expected
 // with preemptive scenarios.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       CallPreemptiveTriggerWithDelay) {
+                       MAYBE_CallPreemptiveTriggerWithDelay) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
@@ skipping 42 matching lines @@
     BackgroundTracingManagerImpl::GetInstance()->FireTimerForTesting();
     EXPECT_FALSE(
         BackgroundTracingManagerImpl::GetInstance()->IsTracingForTesting());
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_CannotTriggerWithoutScenarioSet \
+        DISABLED_CannotTriggerWithoutScenarioSet
+#else
+#define MAYBE_CannotTriggerWithoutScenarioSet CannotTriggerWithoutScenarioSet
+#endif
+
 // This tests that you can't trigger without a scenario set.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       CannotTriggerWithoutScenarioSet) {
+                       MAYBE_CannotTriggerWithoutScenarioSet) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
     std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "preemptive_test");
 
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle,
         base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_DoesNotTriggerWithWrongHandle \
+        DISABLED_DoesNotTriggerWithWrongHandle
+#else
+#define MAYBE_DoesNotTriggerWithWrongHandle DoesNotTriggerWithWrongHandle
+#endif
+
 // This tests that no trace is triggered with a handle that isn't specified
 // in the config.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       DoesNotTriggerWithWrongHandle) {
+                       MAYBE_DoesNotTriggerWithWrongHandle) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
     std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
@@ skipping 10 matching lines @@
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle,
         base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_DoesNotTriggerWithInvalidHandle \
+        DISABLED_DoesNotTriggerWithInvalidHandle
+#else
+#define MAYBE_DoesNotTriggerWithInvalidHandle DoesNotTriggerWithInvalidHandle
+#endif
+
 // This tests that no trace is triggered with an invalid handle.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       DoesNotTriggerWithInvalidHandle) {
+                       MAYBE_DoesNotTriggerWithInvalidHandle) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
     std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
@@ skipping 13 matching lines @@
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle,
         base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_PreemptiveNotTriggerWithZeroChance \
+        DISABLED_PreemptiveNotTriggerWithZeroChance
+#else
+#define MAYBE_PreemptiveNotTriggerWithZeroChance \
+        PreemptiveNotTriggerWithZeroChance
+#endif
+
 // This tests that no preemptive trace is triggered with 0 chance set.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       PreemptiveNotTriggerWithZeroChance) {
+                       MAYBE_PreemptiveNotTriggerWithZeroChance) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
     base::DictionaryValue dict;
 
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
@@ skipping 29 matching lines @@
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle,
         base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_ReactiveNotTriggerWithZeroChance \
+        DISABLED_ReactiveNotTriggerWithZeroChance
+#else
+#define MAYBE_ReactiveNotTriggerWithZeroChance ReactiveNotTriggerWithZeroChance
+#endif
+
 // This tests that no reactive trace is triggered with 0 chance set.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       ReactiveNotTriggerWithZeroChance) {
+                       MAYBE_ReactiveNotTriggerWithZeroChance) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
     base::DictionaryValue dict;
 
     dict.SetString("mode", "REACTIVE_TRACING_MODE");
@@ skipping 31 matching lines @@
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle,
         base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_ReceiveTraceSucceedsOnHigherHistogramSample \
+        DISABLED_ReceiveTraceSucceedsOnHigherHistogramSample
+#else
+#define MAYBE_ReceiveTraceSucceedsOnHigherHistogramSample \
+        ReceiveTraceSucceedsOnHigherHistogramSample
+#endif
+
 // This tests that histogram triggers for preemptive mode configs.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       ReceiveTraceSucceedsOnHigherHistogramSample) {
+                       MAYBE_ReceiveTraceSucceedsOnHigherHistogramSample) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
 
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
@@ skipping 25 matching lines @@
 
     // Our reference value is "1", so a value of "2" should trigger a trace.
     LOCAL_HISTOGRAM_COUNTS("fake", 2);
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_ReceiveReactiveTraceSucceedsOnHigherHistogramSample \
+        DISABLED_ReceiveReactiveTraceSucceedsOnHigherHistogramSample
+#else
+#define MAYBE_ReceiveReactiveTraceSucceedsOnHigherHistogramSample \
+        ReceiveReactiveTraceSucceedsOnHigherHistogramSample
+#endif
+
 // This tests that histogram triggers for reactive mode configs.
-IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       ReceiveReactiveTraceSucceedsOnHigherHistogramSample) {
+IN_PROC_BROWSER_TEST_F(
+    BackgroundTracingManagerBrowserTest,
+    MAYBE_ReceiveReactiveTraceSucceedsOnHigherHistogramSample) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
 
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "REACTIVE_TRACING_MODE");
@@ skipping 25 matching lines @@
 
     // Our reference value is "1", so a value of "2" should trigger a trace.
     LOCAL_HISTOGRAM_COUNTS("fake", 2);
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_ReceiveTraceFailsOnLowerHistogramSample \
+        DISABLED_ReceiveTraceFailsOnLowerHistogramSample
+#else
+#define MAYBE_ReceiveTraceFailsOnLowerHistogramSample \
+        ReceiveTraceFailsOnLowerHistogramSample
+#endif
+
 // This tests that histogram values < reference value don't trigger.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       ReceiveTraceFailsOnLowerHistogramSample) {
+                       MAYBE_ReceiveTraceFailsOnLowerHistogramSample) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
 
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
@@ skipping 26 matching lines @@
     // This should fail to trigger a trace since the sample value < the
     // the reference value above.
     LOCAL_HISTOGRAM_COUNTS("fake", 0);
 
     run_loop.RunUntilIdle();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_ReceiveTraceFailsOnHigherHistogramSample \
+        DISABLED_ReceiveTraceFailsOnHigherHistogramSample
+#else
+#define MAYBE_ReceiveTraceFailsOnHigherHistogramSample \
+        ReceiveTraceFailsOnHigherHistogramSample
+#endif
+
 // This tests that histogram values > upper reference value don't trigger.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       ReceiveTraceFailsOnHigherHistogramSample) {
+                       MAYBE_ReceiveTraceFailsOnHigherHistogramSample) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
 
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
@@ skipping 27 matching lines @@
     // This should fail to trigger a trace since the sample value > the
     // the upper reference value above.
     LOCAL_HISTOGRAM_COUNTS("fake", 0);
 
     run_loop.RunUntilIdle();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_SetActiveScenarioFailsWithInvalidPreemptiveConfig \
+        DISABLED_SetActiveScenarioFailsWithInvalidPreemptiveConfig
+#else
+#define MAYBE_SetActiveScenarioFailsWithInvalidPreemptiveConfig \
+        SetActiveScenarioFailsWithInvalidPreemptiveConfig
+#endif
+
 // This tests that invalid preemptive mode configs will fail.
-IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       SetActiveScenarioFailsWithInvalidPreemptiveConfig) {
+IN_PROC_BROWSER_TEST_F(
+    BackgroundTracingManagerBrowserTest,
+    MAYBE_SetActiveScenarioFailsWithInvalidPreemptiveConfig) {
   {
     SetupBackgroundTracingManager();
 
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
     std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
     {
       std::unique_ptr<base::DictionaryValue> rules_dict(
           new base::DictionaryValue());
       rules_dict->SetString("rule", "INVALID_RULE");
       rules_list->Append(std::move(rules_dict));
     }
 
     dict.Set("configs", std::move(rules_list));
 
     std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     // An invalid config should always return a nullptr here.
     EXPECT_FALSE(config);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_ReactiveTimeoutTermination DISABLED_ReactiveTimeoutTermination
+#else
+#define MAYBE_ReactiveTimeoutTermination ReactiveTimeoutTermination
+#endif
+
 // This tests that reactive mode records and terminates with timeout.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       ReactiveTimeoutTermination) {
+                       MAYBE_ReactiveTimeoutTermination) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     std::unique_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
@@ skipping 11 matching lines @@
         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 
     BackgroundTracingManager::GetInstance()->FireTimerForTesting();
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_ReactiveSecondTriggerTermination \
+        DISABLED_ReactiveSecondTriggerTermination
+#else
+#define MAYBE_ReactiveSecondTriggerTermination ReactiveSecondTriggerTermination
+#endif
+
 // This tests that reactive mode records and terminates with a second trigger.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       ReactiveSecondTriggerTermination) {
+                       MAYBE_ReactiveSecondTriggerTermination) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     std::unique_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
@@ skipping 12 matching lines @@
     // second trigger to terminate.
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_ReactiveSecondTriggerMustMatchForTermination \
+        DISABLED_ReactiveSecondTriggerMustMatchForTermination
+#else
+#define MAYBE_ReactiveSecondTriggerMustMatchForTermination \
+        ReactiveSecondTriggerMustMatchForTermination
+#endif
+
 // This tests that reactive mode only terminates with the same trigger.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       ReactiveSecondTriggerMustMatchForTermination) {
+                       MAYBE_ReactiveSecondTriggerMustMatchForTermination) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "REACTIVE_TRACING_MODE");
 
@@ skipping 46 matching lines @@
     // second trigger to terminate.
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle1, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   }
 }
 
+#if defined(OS_ANDROID)
+// Flaky on android: https://crbug.com/639706
+#define MAYBE_ReactiveThirdTriggerTimeout DISABLED_ReactiveThirdTriggerTimeout
+#else
+#define MAYBE_ReactiveThirdTriggerTimeout ReactiveThirdTriggerTimeout
+#endif
+
 // This tests a third trigger in reactive more does not start another trace.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
-                       ReactiveThirdTriggerTimeout) {
+                       MAYBE_ReactiveThirdTriggerTimeout) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     std::unique_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
@@ skipping 16 matching lines @@
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   }
 }
 
 }  // namespace content