Implement ephemeral users

chrome/browser/chromeos/login/user_manager_unittest.cc

Index: chrome/browser/chromeos/login/user_manager_unittest.cc
diff --git a/chrome/browser/chromeos/login/user_manager_unittest.cc b/chrome/browser/chromeos/login/user_manager_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2bfb199bbeb3f7a268d3266484ffaf876a2e7d0c
--- /dev/null
+++ b/chrome/browser/chromeos/login/user_manager_unittest.cc
@@ -0,0 +1,167 @@
+// 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 <cstdlib>
+#include <cstring>
+
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
+#include "base/values.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/cros_settings.h"
+#include "chrome/browser/chromeos/cros_settings_names.h"
+#include "chrome/browser/chromeos/cros_settings_provider.h"
+#include "chrome/browser/chromeos/login/user.h"
+#include "chrome/browser/chromeos/login/user_manager.h"
+#include "chrome/browser/chromeos/stub_cros_settings_provider.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chrome/test/base/testing_pref_service.h"
+#include "content/test/test_browser_thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+
+class UserManagerTest : public testing::Test {
+ public:
+  UserManagerTest()
+      : message_loop_(MessageLoop::TYPE_UI),
+        ui_thread_(content::BrowserThread::UI, &message_loop_),
+        file_thread_(content::BrowserThread::FILE, &message_loop_) {
+  }
+
+  virtual void SetUp() {
+    cros_settings_ = CrosSettings::Get();
+
+    // Replace the real DeviceSettingsProvider with a stub.
+    device_settings_provider_ =
+        cros_settings_->GetProvider(chromeos::kReportDeviceVersionInfo);
+    EXPECT_TRUE(device_settings_provider_ != NULL);
+    EXPECT_TRUE(
+        cros_settings_->RemoveSettingsProvider(device_settings_provider_));
+    cros_settings_->AddSettingsProvider(&stub_settings_provider_);
+
+    // Populate the stub DeviceSettingsProvider with valid values.
+    SetDeviceSettings(false, "");
+
+    // Register an in-memory local settings instance.
+    local_state_.reset(new TestingPrefService);
+    reinterpret_cast<TestingBrowserProcess*>(g_browser_process)
+        ->SetLocalState(local_state_.get());
+    UserManager::RegisterPrefs(local_state_.get());
+
+    user_manager_ = UserManager::Get();
+
+    // A stub user is automatically logged in by UserManager. Reset this.
+    ResetUserManagerLoggedInUser();
+  }
+
+  virtual void TearDown() {
+    // Unregister the in-memory local settings instance.
+    reinterpret_cast<TestingBrowserProcess*>(g_browser_process)
+        ->SetLocalState(0);
+
+    // Restore the real DeviceSettingsProvider.
+    EXPECT_TRUE(
+      cros_settings_->RemoveSettingsProvider(&stub_settings_provider_));
+    cros_settings_->AddSettingsProvider(device_settings_provider_);
+  }
+
+  scoped_ptr<bool>& GetUserManagerEphemeralUsersEnabled() {
+    return user_manager_->ephemeral_users_enabled_;
+  }
+
+  scoped_ptr<std::string>& GetUserManagerOwner() {
+    return user_manager_->owner_;
+  }
+
+  void ResetUserManagerLoggedInUser() {
+    // One does not simply log out of UserManager. The UserManager is normally
+    // torn down on logout along with the entire Chrome process. Since this is
+    // not possible in the test environment, UserManager's internal state is
+    // reset instead.
+    if (user_manager_->logged_in_user_ &&
+        user_manager_->current_user_is_ephemeral_)
+      delete user_manager_->logged_in_user_;
+    user_manager_->logged_in_user_ = NULL;
+    user_manager_->current_user_is_owner_ = false;
+    user_manager_->current_user_is_new_ = false;
+    user_manager_->current_user_is_ephemeral_ = false;
+    user_manager_->user_is_logged_in_ = false;
+  }
+
+  void SetDeviceSettings(bool ephemeral_users_enabled,
+                         const std::string &owner) {
+    stub_settings_provider_.Set(kAccountsPrefEphemeralUsersEnabled,
+        base::FundamentalValue(ephemeral_users_enabled));
+    stub_settings_provider_.Set(kDeviceOwner, base::StringValue(owner));

[Ivan Korotkov, 2012/03/01 20:16:30]

I'm not sure if clang is gonna like this. Previously it required you to write
base::StringValue smth(...); and then pass smth as argument.

[use bartfab instead, 2012/03/05 18:07:32]

Done.

+  }
+
+  void RetrieveTrustedDevicePolicies() {
+    user_manager_->RetrieveTrustedDevicePolicies();
+  }
+
+ protected:
+  UserManager* user_manager_;
+
+  MessageLoop message_loop_;
+  content::TestBrowserThread ui_thread_;
+  content::TestBrowserThread file_thread_;
+
+  CrosSettings* cros_settings_;
+  CrosSettingsProvider* device_settings_provider_;
+  StubCrosSettingsProvider stub_settings_provider_;
+  scoped_ptr<TestingPrefService> local_state_;
+};
+
+TEST_F(UserManagerTest, RetrieveTrustedDevicePolicies) {
+  GetUserManagerEphemeralUsersEnabled().reset(new bool(true));
+  GetUserManagerOwner().reset(NULL);
+
+  SetDeviceSettings(false, "owner@invalid.domain");
+  RetrieveTrustedDevicePolicies();
+
+  EXPECT_TRUE(GetUserManagerEphemeralUsersEnabled().get() != NULL);
+  EXPECT_FALSE(*GetUserManagerEphemeralUsersEnabled().get());
+  EXPECT_TRUE(GetUserManagerOwner().get() != NULL);
+  EXPECT_EQ(*GetUserManagerOwner().get(), "owner@invalid.domain");
+}
+
+TEST_F(UserManagerTest, RemoveAllExceptOwnerFromList) {
+  user_manager_->UserLoggedIn("owner@invalid.domain");
+  ResetUserManagerLoggedInUser();
+  user_manager_->UserLoggedIn("user0@invalid.domain");
+  ResetUserManagerLoggedInUser();
+  user_manager_->UserLoggedIn("user1@invalid.domain");
+  ResetUserManagerLoggedInUser();
+
+  const UserList* users = &user_manager_->GetUsers();
+  EXPECT_TRUE(users->size() == 3);
+  EXPECT_EQ((*users)[0]->email(), "user1@invalid.domain");
+  EXPECT_EQ((*users)[1]->email(), "user0@invalid.domain");
+  EXPECT_EQ((*users)[2]->email(), "owner@invalid.domain");
+
+  SetDeviceSettings(true, "owner@invalid.domain");
+  RetrieveTrustedDevicePolicies();
+
+  users = &user_manager_->GetUsers();
+  EXPECT_TRUE(users->size() == 1);
+  EXPECT_EQ((*users)[0]->email(), "owner@invalid.domain");
+}
+
+TEST_F(UserManagerTest, EphemeralUserLoggedIn) {
+  SetDeviceSettings(true, "owner@invalid.domain");
+  RetrieveTrustedDevicePolicies();
+
+  user_manager_->UserLoggedIn("owner@invalid.domain");
+  ResetUserManagerLoggedInUser();
+  user_manager_->UserLoggedIn("user0@invalid.domain");
+  ResetUserManagerLoggedInUser();
+
+  const UserList* users = &user_manager_->GetUsers();
+  EXPECT_TRUE(users->size() == 1);
+  EXPECT_EQ((*users)[0]->email(), "owner@invalid.domain");
+}
+
+}  // namespace chromeos