[Sync] Fix EnableDisableSingleClientTest

chrome/browser/sync/test/integration/sync_test.cc

 // Copyright (c) 2012 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/sync/test/integration/sync_test.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 71 matching lines @@
 #include "net/base/load_flags.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/port_util.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "url/gurl.h"
 
 #if defined(OS_CHROMEOS)
+#include "chrome/browser/sync/test/integration/sync_arc_package_helper.h"
+#include "chrome/browser/ui/app_list/arc/arc_app_list_prefs_factory.h"
 #include "chromeos/chromeos_switches.h"
+#include "components/arc/arc_util.h"
 #endif
 
 using browser_sync::ProfileSyncService;
 using content::BrowserThread;
 
 namespace switches {
 const char kPasswordFileForTest[] = "password-file-for-test";
 const char kSyncUserForTest[] = "sync-user-for-test";
 const char kSyncPasswordForTest[] = "sync-password-for-test";
 const char kSyncServerCommandLine[] = "sync-server-command-line";
@@ skipping 188 matching lines @@
 
   fake_server_.reset();
 }
 
 void SyncTest::SetUpCommandLine(base::CommandLine* cl) {
   AddTestSwitches(cl);
   AddOptionalTypesToCommandLine(cl);
 
 #if defined(OS_CHROMEOS)
   cl->AppendSwitch(chromeos::switches::kIgnoreUserProfileMappingForTests);
+  arc::SetArcAvailableCommandLineForTesting(cl);
 #endif
 }
 
 void SyncTest::AddTestSwitches(base::CommandLine* cl) {
   // Disable non-essential access of external network resources.
   if (!cl->HasSwitch(switches::kDisableBackgroundNetworking))
     cl->AppendSwitch(switches::kDisableBackgroundNetworking);
 
   if (!cl->HasSwitch(switches::kSyncShortInitialRetryOverride))
     cl->AppendSwitch(switches::kSyncShortInitialRetryOverride);
@@ skipping 195 matching lines @@
   sync_refreshers_.resize(num_clients_);
   fake_server_invalidation_services_.resize(num_clients_);
 
   if (create_gaia_account_at_runtime_) {
     CHECK(UsingExternalServers()) <<
         "Cannot create Gaia accounts without external authentication servers";
     if (!CreateGaiaAccount(username_, password_))
       LOG(FATAL) << "Could not create Gaia account.";
   }
 
+#if defined(OS_CHROMEOS)
+  const auto* cl = base::CommandLine::ForCurrentProcess();
+  // ARC_PACKAGE do not support supervised users, switches::kSupervisedUserId
+  // need to be set in SetUpCommandLine() when a test will use supervise users.
+  if (!cl->HasSwitch(switches::kSupervisedUserId))

[skym, 2017/03/17 19:51:17]

can you add a { } here, the comment makes this weird to not have { }

[Gang Wu, 2017/03/17 20:00:29]

Done.

+    // Sets Arc flags, need to be called before create test profiles.
+    ArcAppListPrefsFactory::SetFactoryForSyncTest();
+#endif
+
   for (int i = 0; i < num_clients_; ++i) {
     CreateProfile(i);
   }
 
   // Verifier account is not useful when running against external servers.
   if (UsingExternalServers())
     DisableVerifier();
 
   // Create the verifier profile.
   if (use_verifier_) {
     base::FilePath user_data_dir;
     PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
     profile_delegates_[num_clients_] =
         base::MakeUnique<SyncProfileDelegate>(base::Callback<void(Profile*)>());
     verifier_ = MakeTestProfile(
         user_data_dir.Append(FILE_PATH_LITERAL("Verifier")), num_clients_);
     WaitForDataModels(verifier());
   }
+
+#if defined(OS_CHROMEOS)
+  if (ArcAppListPrefsFactory::IsFactorySetForSyncTest()) {
+    // Init SyncArcPackageHelper to ensure that the arc services are initialized
+    // for each Profile, only can be called after test profiles are created.
+    if (!sync_arc_helper())
+      return false;
+  }
+#endif
+
   // Error cases are all handled by LOG(FATAL) messages. So there is not really
   // a case that returns false.  In case we failed to create a verifier profile,
   // any call to the verifier() would fail.
   return true;
 }
 
 void SyncTest::InitializeProfile(int index, Profile* profile) {
   DCHECK(profile);
   profiles_[index] = profile;
 
@@ skipping 622 matching lines @@
 
 fake_server::FakeServer* SyncTest::GetFakeServer() const {
   return fake_server_.get();
 }
 
 void SyncTest::TriggerSyncForModelTypes(int index,
                                         syncer::ModelTypeSet model_types) {
   GetSyncService(index)->TriggerRefresh(model_types);
 }
 
+arc::SyncArcPackageHelper* SyncTest::sync_arc_helper() {
+#if defined(OS_CHROMEOS)
+  return arc::SyncArcPackageHelper::GetInstance();
+#else
+  return nullptr;
+#endif
+}
+
 void SyncTest::SetPreexistingPreferencesFileContents(
     const std::string& contents) {
   preexisting_preferences_file_contents_ = contents;
 }
 
 bool SyncTest::ClearServerData(ProfileSyncServiceHarness* harness) {
   // At this point our birthday is good.
   base::RunLoop run_loop;
   harness->service()->ClearServerDataForTest(run_loop.QuitClosure());
   run_loop.Run();
 
   // Our birthday is invalidated on the server here so restart sync to get
   // the new birthday from the server.
   return harness->RestartSyncService();
 }