Add new E2E sync multi profiles tests. This should not affect any existing

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 <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 16 matching lines @@
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/signin/profile_identity_provider.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/glue/invalidation_helper.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/test/integration/fake_server_invalidation_service.h"
 #include "chrome/browser/sync/test/integration/p2p_invalidation_forwarder.h"
+#include "chrome/browser/sync/test/integration/p2p_sync_refresher.h"
 #include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
 #include "chrome/browser/sync/test/integration/single_client_status_change_checker.h"
 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
 #include "chrome/browser/sync/test/integration/sync_integration_test_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 334 matching lines @@
   if (num_clients_ <= 0)
     LOG(FATAL) << "num_clients_ incorrectly initialized.";
   if (!profiles_.empty() || !browsers_.empty() || !clients_.empty())
     LOG(FATAL) << "SetupClients() has already been called.";
 
   // Create the required number of sync profiles, browsers and clients.
   profiles_.resize(num_clients_);
   browsers_.resize(num_clients_);
   clients_.resize(num_clients_);
   invalidation_forwarders_.resize(num_clients_);
+  sync_refreshers_.resize(num_clients_);
   fake_server_invalidation_services_.resize(num_clients_);
   for (int i = 0; i < num_clients_; ++i) {
     InitializeInstance(i);
   }
 
   // Create the verifier profile.
   verifier_ = MakeProfile(FILE_PATH_LITERAL("Verifier"));
   bookmarks::test::WaitForBookmarkModelToLoad(
       BookmarkModelFactory::GetForProfile(verifier()));
   ui_test_utils::WaitForHistoryToLoad(HistoryServiceFactory::GetForProfile(
@@ skipping 75 matching lines @@
                             GetInvalidationService());
     fake_server_->AddObserver(invalidation_service);
     if (TestUsesSelfNotifications()) {
       invalidation_service->EnableSelfNotifications();
     } else {
       invalidation_service->DisableSelfNotifications();
     }
     fake_server_invalidation_services_[index] = invalidation_service;
   } else if (server_type_ == EXTERNAL_LIVE_SERVER) {
     // DO NOTHING. External live sync servers use GCM to notify profiles of any
-    // invalidations in sync'ed data.
+    // invalidations in sync'ed data. In this case, to notify other profiles of
+    // invalidations, we use sync refresh notifications instead.
   } else {
     invalidation::P2PInvalidationService* p2p_invalidation_service =
         static_cast<invalidation::P2PInvalidationService*>(
             static_cast<invalidation::ProfileInvalidationProvider*>(
                 invalidation::ProfileInvalidationProviderFactory::
                     GetInstance()->SetTestingFactoryAndUse(
                         GetProfile(index),
                         TestUsesSelfNotifications() ?
                             BuildSelfNotifyingP2PProfileInvalidationProvider :
                             BuildRealisticP2PProfileInvalidationProvider))->
@@ skipping 23 matching lines @@
   // session-releated data is rewritten), we need to ensure all startup-based
   // changes have propagated between the clients.
   //
   // Tests that don't use self-notifications can't await quiescense.  They'll
   // have to find their own way of waiting for an initial state if they really
   // need such guarantees.
   if (TestUsesSelfNotifications()) {
     AwaitQuiescence();
   }
 
+  // SyncRefresher is used instead of invalidations to notify other profiles to
+  // do a sync refresh on committed data sets. This is only needed when running
+  // tests against external live server, otherwise invalidation service is used.
+  // With external live servers, the profiles commit data on first sync cycle
+  // automatically after signing in. To avoid misleading sync commit
+  // notifications at start up, we start the SyncRefresher observers post
+  // client set up.
+  if (server_type_ == EXTERNAL_LIVE_SERVER) {
+    for (int i = 0; i < num_clients_; ++i) {
+      sync_refreshers_[i] = new P2PSyncRefresher(clients_[i]->service());
+    }
+  }
+
   return true;
 }
 
 void SyncTest::TearDownOnMainThread() {
   for (size_t i = 0; i < clients_.size(); ++i) {
     clients_[i]->service()->DisableForUser();
   }
 
   // Some of the pending messages might rely on browser windows still being
   // around, so run messages both before and after closing all browsers.
   content::RunAllPendingInMessageLoop();
   // Close all browser windows.
   chrome::CloseAllBrowsers();
   content::RunAllPendingInMessageLoop();
 
   if (fake_server_.get()) {
     std::vector<fake_server::FakeServerInvalidationService*>::const_iterator it;
     for (it = fake_server_invalidation_services_.begin();
          it != fake_server_invalidation_services_.end(); ++it) {
       fake_server_->RemoveObserver(*it);
     }
   }
 
   // All browsers should be closed at this point, or else we could see memory
   // corruption in QuitBrowser().
   CHECK_EQ(0U, chrome::GetTotalBrowserCount());
   invalidation_forwarders_.clear();
+  sync_refreshers_.clear();
   fake_server_invalidation_services_.clear();
   clients_.clear();
 }
 
 void SyncTest::SetUpInProcessBrowserTestFixture() {
   // We don't take a reference to |resolver|, but mock_host_resolver_override_
   // does, so effectively assumes ownership.
   net::RuleBasedHostResolverProc* resolver =
       new net::RuleBasedHostResolverProc(host_resolver());
   resolver->AllowDirectLookup("*.google.com");
@@ skipping 418 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SetupNetworkCallback, &done,
                  make_scoped_refptr(context_getter)));
   done.Wait();
 }
 
 fake_server::FakeServer* SyncTest::GetFakeServer() const {
   return fake_server_.get();
 }