Disabled flaky DeviceLocalAccountTest-s and TermsOfServiceDownloadTest.

chrome/browser/chromeos/policy/device_local_account_browsertest.cc

 // Copyright (c) 2013 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 <map>
 #include <string>
 
 #include "apps/app_window_registry.h"
 #include "apps/ui/native_app_window.h"
 #include "ash/shell.h"
@@ skipping 757 matching lines @@
   test_server_.UpdatePolicy(dm_protocol::kChromeDevicePolicyType, std::string(),
                             policy.SerializeAsString());
   g_browser_process->policy_service()->RefreshPolicies(base::Closure());
 
   // Make sure the second device-local account disappears.
   content::WindowedNotificationObserver(chrome::NOTIFICATION_USER_LIST_CHANGED,
                                         base::Bind(&IsNotKnownUser, user_id_2_))
       .Wait();
 }
 
-IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, StartSession) {
+IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, DISABLED_StartSession) {
   // Specify startup pages.
   device_local_account_policy_.payload().mutable_restoreonstartup()->set_value(
       SessionStartupPref::kPrefValueURLs);
   em::StringListPolicyProto* startup_urls_proto =
       device_local_account_policy_.payload().mutable_restoreonstartupurls();
   for (size_t i = 0; i < arraysize(kStartupURLs); ++i)
     startup_urls_proto->mutable_value()->add_entries(kStartupURLs[i]);
   UploadAndInstallDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
@@ skipping 19 matching lines @@
   }
 
   // Verify that the session is not considered to be logged in with a GAIA
   // account.
   Profile* profile = GetProfileForTest();
   ASSERT_TRUE(profile);
   EXPECT_FALSE(profile->GetPrefs()->HasPrefPath(
       prefs::kGoogleServicesUsername));
 }
 
-IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, FullscreenDisallowed) {
+IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, DISABLED_FullscreenDisallowed) {
   UploadAndInstallDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
   WaitForPolicy();
   ASSERT_NO_FATAL_FAILURE(WaitForLoginUI());
   ASSERT_NO_FATAL_FAILURE(StartLogin(std::string(), std::string()));
   WaitForSessionStart();
 
   BrowserList* browser_list =
     BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH);
   EXPECT_EQ(1U, browser_list->size());
   Browser* browser = browser_list->get(0);
   ASSERT_TRUE(browser);
   BrowserWindow* browser_window = browser->window();
   ASSERT_TRUE(browser_window);
 
   // Verify that an attempt to enter fullscreen mode is denied.
   EXPECT_FALSE(browser_window->IsFullscreen());
   chrome::ToggleFullscreenMode(browser);
   EXPECT_FALSE(browser_window->IsFullscreen());
 }
 
-IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, ExtensionsUncached) {
+IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, DISABLED_ExtensionsUncached) {
   // Make it possible to force-install a hosted app and an extension.
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
   TestingUpdateManifestProvider testing_update_manifest_provider(
       kRelativeUpdateURL);
   testing_update_manifest_provider.AddUpdate(
       kHostedAppID,
       kHostedAppVersion,
       embedded_test_server()->GetURL(std::string("/") + kHostedAppCRXPath));
   testing_update_manifest_provider.AddUpdate(
       kGoodExtensionID,
@@ skipping 59 matching lines @@
   DeviceLocalAccountPolicyBroker* broker =
       g_browser_process->platform_part()->browser_policy_connector_chromeos()->
           GetDeviceLocalAccountPolicyService()->GetBrokerForUser(user_id_1_);
   ASSERT_TRUE(broker);
   chromeos::ExternalCache* cache =
       broker->extension_loader()->GetExternalCacheForTesting();
   ASSERT_TRUE(cache);
   EXPECT_FALSE(cache->GetExtension(kGoodExtensionID, NULL, NULL));
 }
 
-IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, ExtensionsCached) {
+IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, DISABLED_ExtensionsCached) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Pre-populate the device local account's extension cache with a hosted app
   // and an extension.
   EXPECT_TRUE(base::CreateDirectory(
       GetExtensionCacheDirectoryForAccountID(kAccountId1)));
   base::FilePath test_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_dir));
   const base::FilePath cached_hosted_app =
       GetCacheCRXFile(kAccountId1, kHostedAppID, kHostedAppVersion);
@@ skipping 53 matching lines @@
   DeviceLocalAccountPolicyBroker* broker =
       g_browser_process->platform_part()->browser_policy_connector_chromeos()->
           GetDeviceLocalAccountPolicyService()->GetBrokerForUser(user_id_1_);
   ASSERT_TRUE(broker);
   chromeos::ExternalCache* cache =
       broker->extension_loader()->GetExternalCacheForTesting();
   ASSERT_TRUE(cache);
   EXPECT_FALSE(cache->GetExtension(kGoodExtensionID, NULL, NULL));
 }
 
-IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, ExternalData) {
+IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, DISABLED_ExternalData) {
   // chromeos::UserManager requests an external data fetch whenever
   // the key::kUserAvatarImage policy is set. Since this test wants to
   // verify that the underlying policy subsystem will start a fetch
   // without this request as well, the chromeos::UserManager must be
   // prevented from seeing the policy change.
   reinterpret_cast<chromeos::ChromeUserManager*>(chromeos::UserManager::Get())
       ->StopPolicyObserverForTesting();
 
   UploadDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
@@ skipping 154 matching lines @@
 
   scoped_ptr<gfx::ImageSkia> saved_image =
       chromeos::test::ImageLoader(saved_image_path).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(policy_image->width(), saved_image->width());
   EXPECT_EQ(policy_image->height(), saved_image->height());
 }
 
-IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, LastWindowClosedLogoutReminder) {
+IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest,
+                       DISABLED_LastWindowClosedLogoutReminder) {
   UploadAndInstallDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
   WaitForPolicy();
   ASSERT_NO_FATAL_FAILURE(WaitForLoginUI());
   ASSERT_NO_FATAL_FAILURE(StartLogin(std::string(), std::string()));
   WaitForSessionStart();
 
   Profile* profile = GetProfileForTest();
   ASSERT_TRUE(profile);
@@ skipping 133 matching lines @@
   ASSERT_TRUE(dialog);
 
   // Deny the logout.
   dialog->GetWidget()->Close();
   dialog = NULL;
   base::RunLoop().RunUntilIdle();
 
   app_window_registry->RemoveObserver(this);
 };
 
-IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, DoNotSelectLanguageAndKeyboard) {
+IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest,
+                       DISABLED_DoNotSelectLanguageAndKeyboard) {
   chromeos::input_method::InputMethodManager* input_method_manager =
       chromeos::input_method::InputMethodManager::Get();
   const std::string initial_locale = g_browser_process->GetApplicationLocale();
   const std::string initial_input_method =
       input_method_manager->GetCurrentInputMethod().id();
 
   UploadAndInstallDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
   WaitForPolicy();
   ASSERT_NO_FATAL_FAILURE(WaitForLoginUI());
   ASSERT_NO_FATAL_FAILURE(StartLogin(std::string(), std::string()));
   WaitForSessionStart();
 
   EXPECT_EQ(initial_locale, g_browser_process->GetApplicationLocale());
   EXPECT_EQ(initial_input_method,
             input_method_manager->GetCurrentInputMethod().id());
 }
 
-IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, SelectLanguageAndKeyboard) {
+IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest,
+                       DISABLED_SelectLanguageAndKeyboard) {
   // Specify startup pages.
   device_local_account_policy_.payload().mutable_restoreonstartup()->set_value(
       SessionStartupPref::kPrefValueURLs);
   em::StringListPolicyProto* startup_urls_proto =
       device_local_account_policy_.payload().mutable_restoreonstartupurls();
   for (size_t i = 0; i < arraysize(kStartupURLs); ++i)
     startup_urls_proto->mutable_value()->add_entries(kStartupURLs[i]);
   UploadAndInstallDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
   // Log in to the device-local account with a specific locale and keyboard
   // layout.
   WaitForPolicy();
   ASSERT_NO_FATAL_FAILURE(WaitForLoginUI());
   ASSERT_NO_FATAL_FAILURE(
       StartLogin(kPublicSessionLocale, public_session_input_method_id_));
   WaitForSessionStart();
 
   // Verify that the locale and keyboard layout have been applied.
   EXPECT_EQ(kPublicSessionLocale, g_browser_process->GetApplicationLocale());
   EXPECT_EQ(public_session_input_method_id_,
             chromeos::input_method::InputMethodManager::Get()->
                 GetCurrentInputMethod().id());
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest,
-                       SelectLanguageAndKeyboardWithTermsOfService) {
+                       DISABLED_SelectLanguageAndKeyboardWithTermsOfService) {
   // Specify Terms of Service URL.
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
   device_local_account_policy_.payload().mutable_termsofserviceurl()->set_value(
       embedded_test_server()->GetURL(
           std::string("/") + kExistentTermsOfServicePath).spec());
   UploadAndInstallDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
   // Log in to the device-local account with a specific locale and keyboard
   // layout.
@@ skipping 61 matching lines @@
   EXPECT_EQ(kPublicSessionLocale, g_browser_process->GetApplicationLocale());
   EXPECT_EQ(public_session_input_method_id_,
             chromeos::input_method::InputMethodManager::Get()->
                 GetCurrentInputMethod().id());
 }
 
 class TermsOfServiceDownloadTest : public DeviceLocalAccountTest,
                                    public testing::WithParamInterface<bool> {
 };
 
-IN_PROC_BROWSER_TEST_P(TermsOfServiceDownloadTest, TermsOfServiceScreen) {
+IN_PROC_BROWSER_TEST_P(TermsOfServiceDownloadTest,
+                       DISABLED_TermsOfServiceScreen) {
   // Specify Terms of Service URL.
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
   device_local_account_policy_.payload().mutable_termsofserviceurl()->set_value(
       embedded_test_server()->GetURL(
             std::string("/") +
                 (GetParam() ? kExistentTermsOfServicePath
                             : kNonexistentTermsOfServicePath)).spec());
   UploadAndInstallDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
@@ skipping 109 matching lines @@
   ASSERT_TRUE(content::ExecuteScript(contents,
                                      "$('tos-accept-button').click();"));
 
   WaitForSessionStart();
 }
 
 INSTANTIATE_TEST_CASE_P(TermsOfServiceDownloadTestInstance,
                         TermsOfServiceDownloadTest, testing::Bool());
 
 }  // namespace policy