Disallow Easy Unlock in secondary user profiles.

chrome/browser/signin/easy_unlock_service_browsertest_chromeos.cc

 // Copyright 2014 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 "base/command_line.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/values.h"
+#include "chrome/browser/chromeos/login/login_manager_test.h"
+#include "chrome/browser/chromeos/login/startup_utils.h"
+#include "chrome/browser/chromeos/login/ui/user_adding_screen.h"
+#include "chrome/browser/chromeos/login/users/user_manager.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/easy_unlock_service.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_types.h"
 #include "content/public/common/content_switches.h"
 #include "extensions/browser/extension_system.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
+using chromeos::ProfileHelper;
+using chromeos::LoginManagerTest;
+using chromeos::StartupUtils;
+using chromeos::UserAddingScreen;
+using chromeos::UserManager;
 using testing::_;
 using testing::Return;
 
+namespace {
+
+static const char kTestUser1[] = "primary.user@example.com";
+static const char kTestUser2[] = "secondary.user@example.com";

[xiyuan, 2014/08/06 21:50:33]

nit: "static" not needed

[Tim Song, 2014/08/06 21:55:55]

Done.

+
+#if defined(GOOGLE_CHROME_BUILD)
+bool HasEasyUnlockAppForProfile(Profile* profile) {
+  extensions::ExtensionSystem* extension_system =
+      extensions::ExtensionSystem::Get(profile);
+  ExtensionService* extension_service = extension_system->extension_service();
+  return !!extension_service->GetExtensionById(
+      extension_misc::kEasyUnlockAppId, false);
+}
+#endif
+
+} //namespace
+
 class EasyUnlockServiceTest : public InProcessBrowserTest {
  public:
   EasyUnlockServiceTest() {}
   virtual ~EasyUnlockServiceTest() {}
 
   void SetEasyUnlockAllowedPolicy(bool allowed) {
     policy::PolicyMap policy;
     policy.Set(policy::key::kEasyUnlockAllowed,
                policy::POLICY_LEVEL_MANDATORY,
                policy::POLICY_SCOPE_USER,
                new base::FundamentalValue(allowed),
                NULL);
     provider_.UpdateChromePolicy(policy);
     base::RunLoop().RunUntilIdle();
   }
 
 #if defined(GOOGLE_CHROME_BUILD)
   bool HasEasyUnlockApp() const {
-    extensions::ExtensionSystem* extension_system =
-        extensions::ExtensionSystem::Get(profile());
-    ExtensionService* extension_service = extension_system->extension_service();
-    return !!extension_service->GetExtensionById(
-        extension_misc::kEasyUnlockAppId, false);
+    return HasEasyUnlockAppForProfile(profile());
   }
 #endif
 
   // InProcessBrowserTest:
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     EXPECT_CALL(provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
     policy::BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
   }
 
@@ skipping 76 matching lines @@
   EXPECT_FALSE(HasEasyUnlockApp());
 #endif
 
   // Easy unlock stays off even when it is allowed by policy.
   SetEasyUnlockAllowedPolicy(true);
   EXPECT_FALSE(service()->IsAllowed());
 #if defined(GOOGLE_CHROME_BUILD)
   EXPECT_FALSE(HasEasyUnlockApp());
 #endif
 }
+
+class EasyUnlockServiceMultiProfileTest : public LoginManagerTest {
+ public:
+  EasyUnlockServiceMultiProfileTest() : LoginManagerTest(false) {}
+  virtual ~EasyUnlockServiceMultiProfileTest() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(EasyUnlockServiceMultiProfileTest);
+};
+
+IN_PROC_BROWSER_TEST_F(EasyUnlockServiceMultiProfileTest,
+                       PRE_DisallowedOnSecondaryProfile) {
+  RegisterUser(kTestUser1);
+  RegisterUser(kTestUser2);
+  StartupUtils::MarkOobeCompleted();
+}
+
+IN_PROC_BROWSER_TEST_F(EasyUnlockServiceMultiProfileTest,
+                       DisallowedOnSecondaryProfile) {
+  LoginUser(kTestUser1);
+  chromeos::UserAddingScreen::Get()->Start();
+  base::RunLoop().RunUntilIdle();
+  AddUser(kTestUser2);
+  const user_manager::User* primary_user =
+      UserManager::Get()->FindUser(kTestUser1);
+  const user_manager::User* secondary_user =
+      UserManager::Get()->FindUser(kTestUser2);
+
+  Profile* primary_profile = ProfileHelper::Get()->GetProfileByUserIdHash(
+      primary_user->username_hash());
+  Profile* secondary_profile = ProfileHelper::Get()->GetProfileByUserIdHash(
+      secondary_user->username_hash());
+
+  EXPECT_TRUE(EasyUnlockService::Get(primary_profile)->IsAllowed());
+  EXPECT_FALSE(EasyUnlockService::Get(secondary_profile)->IsAllowed());
+#if defined(GOOGLE_CHROME_BUILD)
+  EXPECT_TRUE(HasEasyUnlockAppForProfile(primary_profile));
+  EXPECT_FALSE(HasEasyUnlockAppForProfile(secondary_profile));
+#endif
+}