Remove workaround for to disable EasyUnlock in ephemeral mode for tests.

chrome/browser/signin/easy_unlock_service_unittest_chromeos.cc

 // Copyright 2015 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 "base/macros.h"
 #include "base/run_loop.h"
 #include "base/values.h"
@@ skipping 171 matching lines @@
 
   EasyUnlockService* service =
       new EasyUnlockServiceRegular(Profile::FromBrowserContext(context));
   service->Initialize(app_manager.Pass());
   return service;
 }
 
 class EasyUnlockServiceTest : public testing::Test {
  public:
   EasyUnlockServiceTest()
-      : mock_user_manager_(new chromeos::MockUserManager()),
+      : mock_user_manager_(new testing::NiceMock<chromeos::MockUserManager>()),
         scoped_user_manager_(mock_user_manager_),
         is_bluetooth_adapter_present_(true) {}
 
   ~EasyUnlockServiceTest() override {}
 
   void SetUp() override {
     app_manager_factory = new TestAppManagerFactory();
 
     mock_adapter_ = new testing::NiceMock<MockBluetoothAdapter>();
     device::BluetoothAdapterFactory::SetAdapterForTesting(mock_adapter_);
     EXPECT_CALL(*mock_adapter_, IsPresent())
         .WillRepeatedly(testing::Invoke(
             this, &EasyUnlockServiceTest::is_bluetooth_adapter_present));
 
     scoped_ptr<DBusThreadManagerSetter> dbus_setter =
         chromeos::DBusThreadManager::GetSetterForTesting();
     power_manager_client_ = new FakePowerManagerClient;
     dbus_setter->SetPowerManagerClient(
         scoped_ptr<PowerManagerClient>(power_manager_client_));
 
-    EXPECT_CALL(*mock_user_manager_, Shutdown()).Times(AnyNumber());
-    EXPECT_CALL(*mock_user_manager_, IsLoggedInAsUserWithGaiaAccount())
-        .WillRepeatedly(Return(true));
+    ON_CALL(*mock_user_manager_, Shutdown()).WillByDefault(Return());
+    ON_CALL(*mock_user_manager_, IsLoggedInAsUserWithGaiaAccount())
+        .WillByDefault(Return(true));
+    ON_CALL(*mock_user_manager_, IsCurrentUserNonCryptohomeDataEphemeral())
+        .WillByDefault(Return(false));
 
     SetUpProfile(&profile_, kTestUserPrimary);
   }
 
   void TearDown() override {
     delete app_manager_factory;
     app_manager_factory = NULL;
   }
 
   void SetEasyUnlockAllowedPolicy(bool allowed) {
@@ skipping 51 matching lines @@
     profile->get()->set_profile_name(user_id);
 
     SigninManagerBase* signin_manager =
         SigninManagerFactory::GetForProfile(profile->get());
     signin_manager->SetAuthenticatedUsername(user_id);
   }
 
  protected:
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<TestingProfile> secondary_profile_;
+  chromeos::MockUserManager* mock_user_manager_;
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
 
-  chromeos::MockUserManager* mock_user_manager_;
   chromeos::ScopedUserManagerEnabler scoped_user_manager_;
 
   FakePowerManagerClient* power_manager_client_;
 
   bool is_bluetooth_adapter_present_;
   scoped_refptr<testing::NiceMock<MockBluetoothAdapter>> mock_adapter_;
 
   DISALLOW_COPY_AND_ASSIGN(EasyUnlockServiceTest);
 };
 
@@ skipping 46 matching lines @@
 
   EasyUnlockService* secondary_service =
       EasyUnlockService::Get(secondary_profile_.get());
   ASSERT_TRUE(secondary_service);
 
   EXPECT_FALSE(secondary_service->IsAllowed());
   EXPECT_TRUE(EasyUnlockAppInState(secondary_profile_.get(),
                                    TestAppManager::STATE_NOT_LOADED));
 }
 
+TEST_F(EasyUnlockServiceTest, NotAllowedForEphemeralAccounts) {
+  ON_CALL(*mock_user_manager_, IsCurrentUserNonCryptohomeDataEphemeral())
+      .WillByDefault(Return(true));
+
+  SetAppManagerReady(profile_.get());
+  EXPECT_FALSE(EasyUnlockService::Get(profile_.get())->IsAllowed());
+  EXPECT_TRUE(
+      EasyUnlockAppInState(profile_.get(), TestAppManager::STATE_NOT_LOADED));
+}
+
 }  // namespace