Rename browser/sync/test/live_sync directory to browser/sync/test/integration

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

 // Copyright (c) 2011 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/live_sync/live_sync_test.h"
+#include "chrome/browser/sync/test/integration/sync_test.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/password_manager/encryptor.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/notifier/p2p_notifier.h"
 #include "chrome/browser/sync/profile_sync_service_harness.h"
-#include "chrome/browser/sync/test/live_sync/sync_datatype_helper.h"
+#include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/url_fetcher.h"
 #include "content/test/test_url_fetcher_factory.h"
@@ skipping 64 matching lines @@
         new net::ProxyConfigServiceFixed(proxy_config_));
     done_->Signal();
   }
 
  private:
   base::WaitableEvent* done_;
   net::URLRequestContextGetter* url_request_context_getter_;
   net::ProxyConfig proxy_config_;
 };
 
-LiveSyncTest::LiveSyncTest(TestType test_type)
+SyncTest::SyncTest(TestType test_type)
     : sync_server_(net::TestServer::TYPE_SYNC, FilePath()),
       test_type_(test_type),
       server_type_(SERVER_TYPE_UNDECIDED),
       num_clients_(-1),
       use_verifier_(true),
       test_server_handle_(base::kNullProcessHandle) {
   InProcessBrowserTest::set_show_window(true);
   sync_datatype_helper::AssociateWithTest(this);
   switch (test_type_) {
     case SINGLE_CLIENT: {
       num_clients_ = 1;
       break;
     }
     case TWO_CLIENT: {
       num_clients_ = 2;
       break;
     }
     case MULTIPLE_CLIENT: {
       num_clients_ = 3;
       break;
     }
     case MANY_CLIENT: {
       num_clients_ = 10;
       break;
     }
   }
 }
 
-LiveSyncTest::~LiveSyncTest() {}
+SyncTest::~SyncTest() {}
 
-void LiveSyncTest::SetUp() {
+void SyncTest::SetUp() {
   CommandLine* cl = CommandLine::ForCurrentProcess();
   if (cl->HasSwitch(switches::kPasswordFileForTest)) {
     ReadPasswordFile();
   } else if (cl->HasSwitch(switches::kSyncUserForTest) &&
              cl->HasSwitch(switches::kSyncPasswordForTest)) {
     username_ = cl->GetSwitchValueASCII(switches::kSyncUserForTest);
     password_ = cl->GetSwitchValueASCII(switches::kSyncPasswordForTest);
   } else {
     SetupMockGaiaResponses();
   }
 
   if (!cl->HasSwitch(switches::kSyncServiceURL) &&
       !cl->HasSwitch(switches::kSyncServerCommandLine)) {
-   // If neither a sync server URL nor a sync server command line is
-   // provided, start up a local python sync test server and point Chrome
-   // to its URL.  This is the most common configuration, and the only
-   // one that makes sense for most developers.
-   server_type_ = LOCAL_PYTHON_SERVER;
+    // If neither a sync server URL nor a sync server command line is
+    // provided, start up a local python sync test server and point Chrome
+    // to its URL.  This is the most common configuration, and the only
+    // one that makes sense for most developers.
+    server_type_ = LOCAL_PYTHON_SERVER;
   } else if (cl->HasSwitch(switches::kSyncServiceURL) &&
-              cl->HasSwitch(switches::kSyncServerCommandLine)) {
+             cl->HasSwitch(switches::kSyncServerCommandLine)) {
     // If a sync server URL and a sync server command line are provided,
     // start up a local sync server by running the command line. Chrome
     // will connect to the server at the URL that was provided.
     server_type_ = LOCAL_LIVE_SERVER;
   } else if (cl->HasSwitch(switches::kSyncServiceURL) &&
              !cl->HasSwitch(switches::kSyncServerCommandLine)) {
     // If a sync server URL is provided, but not a server command line,
     // it is assumed that the server is already running. Chrome will
     // automatically connect to it at the URL provided. There is nothing
     // to do here.
     server_type_ = EXTERNAL_LIVE_SERVER;
   } else {
     // If a sync server command line is provided, but not a server URL,
     // we flag an error.
     LOG(FATAL) << "Can't figure out how to run a server.";
   }
 
   if (username_.empty() || password_.empty())
     LOG(FATAL) << "Cannot run sync tests without GAIA credentials.";
 
   // Mock the Mac Keychain service.  The real Keychain can block on user input.
 #if defined(OS_MACOSX)
   Encryptor::UseMockKeychain(true);
 #endif
 
   // Yield control back to the InProcessBrowserTest framework.
   InProcessBrowserTest::SetUp();
 }
 
-void LiveSyncTest::TearDown() {
+void SyncTest::TearDown() {
   // Allow the InProcessBrowserTest framework to perform its tear down.
   InProcessBrowserTest::TearDown();
 
   // Stop the local python test server. This is a no-op if one wasn't started.
   TearDownLocalPythonTestServer();
 
   // Stop the local sync test server. This is a no-op if one wasn't started.
   TearDownLocalTestServer();
 }
 
-void LiveSyncTest::SetUpCommandLine(CommandLine* cl) {
+void SyncTest::SetUpCommandLine(CommandLine* cl) {
   AddTestSwitches(cl);
   AddOptionalTypesToCommandLine(cl);
 }
 
-void LiveSyncTest::AddTestSwitches(CommandLine* cl) {
+void SyncTest::AddTestSwitches(CommandLine* cl) {
   // TODO(rsimha): Until we implement a fake Tango server against which tests
   // can run, we need to set the --sync-notification-method to "p2p".
   if (!cl->HasSwitch(switches::kSyncNotificationMethod))
     cl->AppendSwitchASCII(switches::kSyncNotificationMethod, "p2p");
 
   // Disable non-essential access of external network resources.
   if (!cl->HasSwitch(switches::kDisableBackgroundNetworking))
     cl->AppendSwitch(switches::kDisableBackgroundNetworking);
 }
 
-void LiveSyncTest::AddOptionalTypesToCommandLine(CommandLine* cl) {
+void SyncTest::AddOptionalTypesToCommandLine(CommandLine* cl) {
   // TODO(sync): Remove this once sessions sync is enabled by default.
   if (!cl->HasSwitch(switches::kEnableSyncSessions))
     cl->AppendSwitch(switches::kEnableSyncSessions);
 }
 
 // static
-Profile* LiveSyncTest::MakeProfile(const FilePath::StringType name) {
+Profile* SyncTest::MakeProfile(const FilePath::StringType name) {
   FilePath path;
   PathService::Get(chrome::DIR_USER_DATA, &path);
   path = path.Append(name);
 
   if (!file_util::PathExists(path))
     CHECK(file_util::CreateDirectory(path));
 
   return Profile::CreateProfile(path);
 }
 
-Profile* LiveSyncTest::GetProfile(int index) {
+Profile* SyncTest::GetProfile(int index) {
   if (profiles_.empty())
     LOG(FATAL) << "SetupClients() has not yet been called.";
   if (index < 0 || index >= static_cast<int>(profiles_.size()))
     LOG(FATAL) << "GetProfile(): Index is out of bounds.";
   return profiles_[index];
 }
 
-Browser* LiveSyncTest::GetBrowser(int index) {
+Browser* SyncTest::GetBrowser(int index) {
   if (browsers_.empty())
     LOG(FATAL) << "SetupClients() has not yet been called.";
   if (index < 0 || index >= static_cast<int>(browsers_.size()))
     LOG(FATAL) << "GetBrowser(): Index is out of bounds.";
   return browsers_[index];
 }
 
-ProfileSyncServiceHarness* LiveSyncTest::GetClient(int index) {
+ProfileSyncServiceHarness* SyncTest::GetClient(int index) {
   if (clients_.empty())
     LOG(FATAL) << "SetupClients() has not yet been called.";
   if (index < 0 || index >= static_cast<int>(clients_.size()))
     LOG(FATAL) << "GetClient(): Index is out of bounds.";
   return clients_[index];
 }
 
-Profile* LiveSyncTest::verifier() {
+Profile* SyncTest::verifier() {
   if (verifier_.get() == NULL)
     LOG(FATAL) << "SetupClients() has not yet been called.";
   return verifier_.get();
 }
 
-void LiveSyncTest::DisableVerifier() {
+void SyncTest::DisableVerifier() {
   use_verifier_ = false;
 }
 
-bool LiveSyncTest::SetupClients() {
+bool SyncTest::SetupClients() {
   if (num_clients_ <= 0)
     LOG(FATAL) << "num_clients_ incorrectly initialized.";
   if (!profiles_.empty() || !browsers_.empty() || !clients_.empty())
     LOG(FATAL) << "SetupClients() has already been called.";
 
   // Start up a sync test server if one is needed.
   SetUpTestServerIfRequired();
 
   // Create the required number of sync profiles, browsers and clients.
   for (int i = 0; i < num_clients_; ++i) {
@@ skipping 11 matching lines @@
     ui_test_utils::WaitForBookmarkModelToLoad(
         GetProfile(i)->GetBookmarkModel());
   }
 
   // Create the verifier profile.
   verifier_.reset(MakeProfile(FILE_PATH_LITERAL("Verifier")));
   ui_test_utils::WaitForBookmarkModelToLoad(verifier()->GetBookmarkModel());
   return (verifier_.get() != NULL);
 }
 
-bool LiveSyncTest::SetupSync() {
+bool SyncTest::SetupSync() {
   // Create sync profiles and clients if they haven't already been created.
   if (profiles_.empty()) {
     if (!SetupClients())
       LOG(FATAL) << "SetupClients() failed.";
   }
 
   // Sync each of the profiles.
   for (int i = 0; i < num_clients_; ++i) {
     if (!GetClient(i)->SetupSync())
       LOG(FATAL) << "SetupSync() failed.";
   }
 
   return true;
 }
 
-void LiveSyncTest::CleanUpOnMainThread() {
+void SyncTest::CleanUpOnMainThread() {
   // Close all browser windows.
   BrowserList::CloseAllBrowsers();
   ui_test_utils::RunAllPendingInMessageLoop();
 
   // All browsers should be closed at this point, or else we could see memory
   // corruption in QuitBrowser().
   CHECK_EQ(0U, BrowserList::size());
 
   profiles_.reset();
   clients_.reset();
   verifier_.reset(NULL);
 }
 
-void LiveSyncTest::SetUpInProcessBrowserTestFixture() {
+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");
   // On Linux, we use Chromium's NSS implementation which uses the following
   // hosts for certificate verification. Without these overrides, running the
   // integration tests on Linux causes error as we make external DNS lookups.
   resolver->AllowDirectLookup("*.thawte.com");
   resolver->AllowDirectLookup("*.geotrust.com");
   resolver->AllowDirectLookup("*.gstatic.com");
   mock_host_resolver_override_.reset(
       new net::ScopedDefaultHostResolverProc(resolver));
 }
 
-void LiveSyncTest::TearDownInProcessBrowserTestFixture() {
+void SyncTest::TearDownInProcessBrowserTestFixture() {
   mock_host_resolver_override_.reset();
 }
 
-void LiveSyncTest::ReadPasswordFile() {
+void SyncTest::ReadPasswordFile() {
   CommandLine* cl = CommandLine::ForCurrentProcess();
   password_file_ = cl->GetSwitchValuePath(switches::kPasswordFileForTest);
   if (password_file_.empty())
     LOG(FATAL) << "Can't run live server test without specifying --"
                << switches::kPasswordFileForTest << "=<filename>";
   std::string file_contents;
   file_util::ReadFileToString(password_file_, &file_contents);
   ASSERT_NE(file_contents, "") << "Password file \""
       << password_file_.value() << "\" does not exist.";
   std::vector<std::string> tokens;
   std::string delimiters = "\r\n";
   Tokenize(file_contents, delimiters, &tokens);
   ASSERT_EQ(2U, tokens.size()) << "Password file \""
       << password_file_.value()
       << "\" must contain exactly two lines of text.";
   username_ = tokens[0];
   password_ = tokens[1];
 }
 
-void LiveSyncTest::SetupMockGaiaResponses() {
+void SyncTest::SetupMockGaiaResponses() {
   username_ = "user@gmail.com";
   password_ = "password";
   factory_.reset(new URLFetcherFactory());
   fake_factory_.reset(new FakeURLFetcherFactory(factory_.get()));
   fake_factory_->SetFakeResponse(kClientLoginUrl, "SID=sid\nLSID=lsid", true);
   fake_factory_->SetFakeResponse(kGetUserInfoUrl, "email=user@gmail.com", true);
   fake_factory_->SetFakeResponse(kIssueAuthTokenUrl, "auth", true);
   fake_factory_->SetFakeResponse(kSearchDomainCheckUrl, ".google.com", true);
 }
 
 // Start up a local sync server based on the value of server_type_, which
 // was determined from the command line parameters.
-void LiveSyncTest::SetUpTestServerIfRequired() {
+void SyncTest::SetUpTestServerIfRequired() {
   if (server_type_ == LOCAL_PYTHON_SERVER) {
     if (!SetUpLocalPythonTestServer())
       LOG(FATAL) << "Failed to set up local python sync and XMPP servers";
   } else if (server_type_ == LOCAL_LIVE_SERVER) {
     // Using mock gaia credentials requires the use of a mock XMPP server.
     if (username_ == "user@gmail.com" && !SetUpLocalPythonTestServer())
       LOG(FATAL) << "Failed to set up local python XMPP server";
     if (!SetUpLocalTestServer())
       LOG(FATAL) << "Failed to set up local test server";
   } else if (server_type_ == EXTERNAL_LIVE_SERVER) {
     // Nothing to do; we'll just talk to the URL we were given.
   } else {
     LOG(FATAL) << "Don't know which server environment to run test in.";
   }
 }
 
-bool LiveSyncTest::SetUpLocalPythonTestServer() {
+bool SyncTest::SetUpLocalPythonTestServer() {
   EXPECT_TRUE(sync_server_.Start())
       << "Could not launch local python test server.";
 
   CommandLine* cl = CommandLine::ForCurrentProcess();
   if (server_type_ == LOCAL_PYTHON_SERVER) {
     std::string sync_service_url = sync_server_.GetURL("chromiumsync").spec();
     cl->AppendSwitchASCII(switches::kSyncServiceURL, sync_service_url);
     VLOG(1) << "Started local python sync server at " << sync_service_url;
   }
 
@@ skipping 16 matching lines @@
                           xmpp_host_port_pair.ToString());
     // The local XMPP server only supports insecure connections.
     cl->AppendSwitch(switches::kSyncAllowInsecureXmppConnection);
   }
   VLOG(1) << "Started local python XMPP server at "
           << xmpp_host_port_pair.ToString();
 
   return true;
 }
 
-bool LiveSyncTest::SetUpLocalTestServer() {
+bool SyncTest::SetUpLocalTestServer() {
   CommandLine* cl = CommandLine::ForCurrentProcess();
   CommandLine::StringType server_cmdline_string = cl->GetSwitchValueNative(
       switches::kSyncServerCommandLine);
   CommandLine::StringVector server_cmdline_vector;
   CommandLine::StringType delimiters(FILE_PATH_LITERAL(" "));
   Tokenize(server_cmdline_string, delimiters, &server_cmdline_vector);
   CommandLine server_cmdline(server_cmdline_vector);
   base::LaunchOptions options;
 #if defined(OS_WIN)
   options.start_hidden = true;
 #endif
   if (!base::LaunchProcess(server_cmdline, options, &test_server_handle_))
     LOG(ERROR) << "Could not launch local test server.";
 
   const int kMaxWaitTime = TestTimeouts::action_max_timeout_ms();
   const int kNumIntervals = 15;
   if (WaitForTestServerToStart(kMaxWaitTime, kNumIntervals)) {
     VLOG(1) << "Started local test server at "
             << cl->GetSwitchValueASCII(switches::kSyncServiceURL) << ".";
     return true;
   } else {
     LOG(ERROR) << "Could not start local test server at "
                << cl->GetSwitchValueASCII(switches::kSyncServiceURL) << ".";
     return false;
   }
 }
 
-bool LiveSyncTest::TearDownLocalPythonTestServer() {
+bool SyncTest::TearDownLocalPythonTestServer() {
   if (!sync_server_.Stop()) {
     LOG(ERROR) << "Could not stop local python test server.";
     return false;
   }
   xmpp_port_.reset();
   return true;
 }
 
-bool LiveSyncTest::TearDownLocalTestServer() {
+bool SyncTest::TearDownLocalTestServer() {
   if (test_server_handle_ != base::kNullProcessHandle) {
     EXPECT_TRUE(base::KillProcess(test_server_handle_, 0, false))
         << "Could not stop local test server.";
     base::CloseProcessHandle(test_server_handle_);
     test_server_handle_ = base::kNullProcessHandle;
   }
   return true;
 }
 
-bool LiveSyncTest::WaitForTestServerToStart(int time_ms, int intervals) {
+bool SyncTest::WaitForTestServerToStart(int time_ms, int intervals) {
   for (int i = 0; i < intervals; ++i) {
     if (IsTestServerRunning())
       return true;
     base::PlatformThread::Sleep(time_ms / intervals);
   }
   return false;
 }
 
-bool LiveSyncTest::IsTestServerRunning() {
+bool SyncTest::IsTestServerRunning() {
   CommandLine* cl = CommandLine::ForCurrentProcess();
   std::string sync_url = cl->GetSwitchValueASCII(switches::kSyncServiceURL);
   GURL sync_url_status(sync_url.append("/healthz"));
   SyncServerStatusChecker delegate;
   URLFetcher fetcher(sync_url_status, URLFetcher::GET, &delegate);
   fetcher.set_request_context(Profile::Deprecated::GetDefaultRequestContext());
   fetcher.Start();
   ui_test_utils::RunMessageLoop();
   return delegate.running();
 }
 
-void LiveSyncTest::EnableNetwork(Profile* profile) {
+void SyncTest::EnableNetwork(Profile* profile) {
   SetProxyConfig(profile->GetRequestContext(),
                  net::ProxyConfig::CreateDirect());
   // TODO(rsimha): Remove this line once http://crbug.com/53857 is fixed.
   net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
 }
 
-void LiveSyncTest::DisableNetwork(Profile* profile) {
+void SyncTest::DisableNetwork(Profile* profile) {
   // Set the current proxy configuration to a nonexistent proxy to effectively
   // disable networking.
   net::ProxyConfig config;
   config.proxy_rules().ParseFromString("http=127.0.0.1:0");
   SetProxyConfig(profile->GetRequestContext(), config);
   // TODO(rsimha): Remove this line once http://crbug.com/53857 is fixed.
   net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
 }
 
-bool LiveSyncTest::EnableEncryption(int index, syncable::ModelType type) {
+bool SyncTest::EnableEncryption(int index, syncable::ModelType type) {
   return GetClient(index)->EnableEncryptionForType(type);
 }
 
-bool LiveSyncTest::IsEncrypted(int index, syncable::ModelType type) {
+bool SyncTest::IsEncrypted(int index, syncable::ModelType type) {
   return GetClient(index)->IsTypeEncrypted(type);
 }
 
-bool LiveSyncTest::AwaitQuiescence() {
+bool SyncTest::AwaitQuiescence() {
   return ProfileSyncServiceHarness::AwaitQuiescence(clients());
 }
 
-bool LiveSyncTest::ServerSupportsNotificationControl() const {
+bool SyncTest::ServerSupportsNotificationControl() const {
   EXPECT_NE(SERVER_TYPE_UNDECIDED, server_type_);
 
   // Supported only if we're using the python testserver.
   return server_type_ == LOCAL_PYTHON_SERVER;
 }
 
-void LiveSyncTest::DisableNotifications() {
+void SyncTest::DisableNotifications() {
   ASSERT_TRUE(ServerSupportsNotificationControl());
   std::string path = "chromiumsync/disablenotifications";
   ui_test_utils::NavigateToURL(browser(), sync_server_.GetURL(path));
   ASSERT_EQ("Notifications disabled",
             UTF16ToASCII(browser()->GetSelectedTabContents()->GetTitle()));
 }
 
-void LiveSyncTest::EnableNotifications() {
+void SyncTest::EnableNotifications() {
   ASSERT_TRUE(ServerSupportsNotificationControl());
   std::string path = "chromiumsync/enablenotifications";
   ui_test_utils::NavigateToURL(browser(), sync_server_.GetURL(path));
   ASSERT_EQ("Notifications enabled",
             UTF16ToASCII(browser()->GetSelectedTabContents()->GetTitle()));
 }
 
-void LiveSyncTest::TriggerNotification(
+void SyncTest::TriggerNotification(
     const syncable::ModelTypeSet& changed_types) {
   ASSERT_TRUE(ServerSupportsNotificationControl());
   const std::string& data =
       sync_notifier::P2PNotificationData("from_server",
                                          sync_notifier::NOTIFY_ALL,
                                          changed_types).ToString();
   const std::string& path =
       std::string("chromiumsync/sendnotification?channel=") +
       sync_notifier::kSyncP2PNotificationChannel + "&data=" + data;
   ui_test_utils::NavigateToURL(browser(), sync_server_.GetURL(path));
   ASSERT_EQ("Notification sent",
             UTF16ToASCII(browser()->GetSelectedTabContents()->GetTitle()));
 }
 
-bool LiveSyncTest::ServerSupportsErrorTriggering() const {
+bool SyncTest::ServerSupportsErrorTriggering() const {
   EXPECT_NE(SERVER_TYPE_UNDECIDED, server_type_);
 
   // Supported only if we're using the python testserver.
   return server_type_ == LOCAL_PYTHON_SERVER;
 }
 
-void LiveSyncTest::TriggerMigrationDoneError(
+void SyncTest::TriggerMigrationDoneError(
     const syncable::ModelTypeSet& model_types) {
   ASSERT_TRUE(ServerSupportsErrorTriggering());
   std::string path = "chromiumsync/migrate";
   char joiner = '?';
   for (syncable::ModelTypeSet::const_iterator it = model_types.begin();
        it != model_types.end(); ++it) {
     path.append(base::StringPrintf("%ctype=%d", joiner,
         syncable::GetExtensionFieldNumberFromModelType(*it)));
     joiner = '&';
   }
   ui_test_utils::NavigateToURL(browser(), sync_server_.GetURL(path));
   ASSERT_EQ("Migration: 200",
             UTF16ToASCII(browser()->GetSelectedTabContents()->GetTitle()));
 }
 
-void LiveSyncTest::TriggerBirthdayError() {
+void SyncTest::TriggerBirthdayError() {
   ASSERT_TRUE(ServerSupportsErrorTriggering());
   std::string path = "chromiumsync/birthdayerror";
   ui_test_utils::NavigateToURL(browser(), sync_server_.GetURL(path));
   ASSERT_EQ("Birthday error",
             UTF16ToASCII(browser()->GetSelectedTabContents()->GetTitle()));
 }
 
-void LiveSyncTest::TriggerTransientError() {
+void SyncTest::TriggerTransientError() {
   ASSERT_TRUE(ServerSupportsErrorTriggering());
   std::string path = "chromiumsync/transienterror";
   ui_test_utils::NavigateToURL(browser(), sync_server_.GetURL(path));
   ASSERT_EQ("Transient error",
             UTF16ToASCII(browser()->GetSelectedTabContents()->GetTitle()));
 }
 
-void LiveSyncTest::TriggerSetSyncTabs() {
+void SyncTest::TriggerSetSyncTabs() {
   ASSERT_TRUE(ServerSupportsErrorTriggering());
   std::string path = "chromiumsync/synctabs";
   ui_test_utils::NavigateToURL(browser(), sync_server_.GetURL(path));
   ASSERT_EQ("Sync Tabs",
             UTF16ToASCII(browser()->GetSelectedTabContents()->GetTitle()));
 }
 
-void LiveSyncTest::SetProxyConfig(net::URLRequestContextGetter* context_getter,
-                                  const net::ProxyConfig& proxy_config) {
+void SyncTest::SetProxyConfig(net::URLRequestContextGetter* context_getter,
+                              const net::ProxyConfig& proxy_config) {
   base::WaitableEvent done(false, false);
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       new SetProxyConfigTask(&done,
                              context_getter,
                              proxy_config));
   done.Wait();
 }