Disable sync in EphemeralAppBrowserTests on Windows due to flakiness

chrome/browser/apps/ephemeral_app_browsertest.cc

 // Copyright 2014 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 "chrome/browser/apps/ephemeral_app_browsertest.h"
 
 #include <vector>
 
 #include "apps/app_restore_service.h"
 #include "apps/saved_files_service.h"
@@ skipping 43 matching lines @@
 using extensions::ExtensionRegistryObserver;
 using extensions::ExtensionSystem;
 using extensions::Manifest;
 
 namespace {
 
 namespace alarms = extensions::api::alarms;
 
 const char kPowerTestApp[] = "ephemeral_apps/power";
 
+// Enabling sync causes these tests to be flaky on Windows. Disable sync so that
+// everything else can be tested. See crbug.com/401028

[benwells, 2014/08/26 03:09:54]

This makes me a bit uneasy. Is there some underlying problem that we're
ignoring?

[tmdiep, 2014/08/26 03:44:45]

Yes.
This patch is intended to be a temporary bandaid as I know more of these tests
are flaky, but not yet disabled. I'm leaving the bug open to fix the actual
problem later.

[benwells, 2014/08/26 03:58:12]

OK. It is probably that someone else that should be looking at the underlying
problem. Is it ephemeral app or sync related?

[tmdiep, 2014/08/26 04:29:39]

I think it's sync related. There are other browser tests that have tried to
enable sync, but have also been disabled due to flakiness (setting_apitest.cc).
I'm not sure whether it's due to the same problem, haven't had the chance to
investigate.

We probably just need to mock something in tests.

+#if defined(OS_WIN)
+const bool kEnableSync = false;
+#else
+const bool kEnableSync = true;
+#endif
+
 typedef std::vector<message_center::Notifier*> NotifierList;
 
 bool IsNotifierInList(const message_center::NotifierId& notifier_id,
                       const NotifierList& notifiers) {
   for (NotifierList::const_iterator it = notifiers.begin();
        it != notifiers.end(); ++it) {
     const message_center::Notifier* notifier = *it;
     if (notifier->notifier_id == notifier_id)
       return true;
   }
@@ skipping 424 matching lines @@
 
     // The sort ordinals from sync should not be overridden.
     ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
     extensions::AppSorting* app_sorting = prefs->app_sorting();
     EXPECT_TRUE(
         app_sorting->GetAppLaunchOrdinal(app_id).Equals(kAppLaunchOrdinal));
     EXPECT_TRUE(app_sorting->GetPageOrdinal(app_id).Equals(kPageOrdinal));
   }
 
   void InitSyncService() {
+    if (!kEnableSync)
+      return;
+
     ExtensionSyncService* sync_service = ExtensionSyncService::Get(profile());
     sync_service->MergeDataAndStartSyncing(
         syncer::APPS,
         syncer::SyncDataList(),
         scoped_ptr<syncer::SyncChangeProcessor>(
             new syncer::SyncChangeProcessorWrapperForTest(
                 &mock_sync_processor_)),
         scoped_ptr<syncer::SyncErrorFactory>(
             new syncer::SyncErrorFactoryMock()));
   }
 
   scoped_ptr<AppSyncData> GetLastSyncChangeForApp(const std::string& id) {
     scoped_ptr<AppSyncData> sync_data;
     for (syncer::SyncChangeList::iterator it =
              mock_sync_processor_.changes().begin();
          it != mock_sync_processor_.changes().end(); ++it) {
       scoped_ptr<AppSyncData> data(new AppSyncData(*it));
       if (data->id() == id)
         sync_data.reset(data.release());
     }
 
     return sync_data.Pass();
   }
 
   void VerifySyncChange(const AppSyncData* sync_change, bool expect_enabled) {
+    if (!kEnableSync)
+      return;
+
     ASSERT_TRUE(sync_change);
     EXPECT_TRUE(sync_change->page_ordinal().IsValid());
     EXPECT_TRUE(sync_change->app_launch_ordinal().IsValid());
     EXPECT_FALSE(sync_change->uninstalled());
     EXPECT_EQ(expect_enabled, sync_change->extension_sync_data().enabled());
   }
 
   void TestInstallEvent(bool close_app) {
     ExtensionTestMessageListener first_msg_listener(false);
     const Extension* app = InstallAndLaunchEphemeralApp(kDispatchEventTestApp);
@@ skipping 365 matching lines @@
   CloseAppWaitForUnload(app->id());
   VerifyInactiveEphemeralApp(app->id());
 
   PromoteEphemeralAppFromSyncAndVerify(app, false, ExtensionRegistry::DISABLED);
 }
 
 // In most cases, ExtensionService::PromoteEphemeralApp() will be called to
 // permanently install an ephemeral app. However, there may be cases where an
 // install occurs through the usual route of installing from the Web Store (due
 // to race conditions). Ensure that the app is still installed correctly.
-#if defined(OS_WIN)
-// Disabled on Windows due to failures. See crbug.com/401028
-#define MAYBE_ReplaceEphemeralAppWithInstalledApp \
-    DISABLED_ReplaceEphemeralAppWithInstalledApp
-#else
-#define MAYBE_ReplaceEphemeralAppWithInstalledApp \
-    ReplaceEphemeralAppWithInstalledApp
-#endif
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
-                       MAYBE_ReplaceEphemeralAppWithInstalledApp) {
+                       ReplaceEphemeralAppWithInstalledApp) {
   InitSyncService();
 
   const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
   CloseAppWaitForUnload(app->id());
   std::string app_id = app->id();
   app = NULL;
 
   InstallObserver installed_observer(profile());
   ReplaceEphemeralApp(app_id, kNotificationsTestApp, 1);
   VerifyPromotedApp(app_id, ExtensionRegistry::ENABLED);
 
   // Check the notification parameters.
   const InstallObserver::InstallParameters& params = installed_observer.Last();
   EXPECT_EQ(app_id, params.id);
   EXPECT_TRUE(params.is_update);
   EXPECT_TRUE(params.from_ephemeral);
 }
 
 // This is similar to ReplaceEphemeralAppWithInstalledApp, but installs will
 // be delayed until the app is idle.
-#if defined(OS_WIN)
-// Disabled on Windows due to failures. See crbug.com/401028
-#define MAYBE_ReplaceEphemeralAppWithDelayedInstalledApp \
-    DISABLED_ReplaceEphemeralAppWithDelayedInstalledApp
-#else
-#define MAYBE_ReplaceEphemeralAppWithDelayedInstalledApp \
-    ReplaceEphemeralAppWithDelayedInstalledApp
-#endif
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
-                       MAYBE_ReplaceEphemeralAppWithDelayedInstalledApp) {
+                       ReplaceEphemeralAppWithDelayedInstalledApp) {
   InitSyncService();
   const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
   std::string app_id = app->id();
   app = NULL;
 
   // Initiate install.
   ReplaceEphemeralApp(app_id, kNotificationsTestApp, 0);
 
   // The delayed installation will occur when the ephemeral app is closed.
@@ skipping 66 matching lines @@
       base::Bind(&PowerSaveBlockerStub::Create, &power_settings));
 
   const Extension* app = InstallAndLaunchEphemeralApp(kPowerTestApp);
   ASSERT_TRUE(app);
   EXPECT_EQ(1, power_settings.keep_awake_count());
 
   CloseAppWaitForUnload(app->id());
 
   EXPECT_EQ(0, power_settings.keep_awake_count());
 }