Add LoginState class to src/chromeos/login

chromeos/login/login_state.cc

Index: chromeos/login/login_state.cc
diff --git a/chromeos/login/login_state.cc b/chromeos/login/login_state.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1be6df07ca1ead50a8abf1265dcf17a89f63fe88
--- /dev/null
+++ b/chromeos/login/login_state.cc
@@ -0,0 +1,131 @@
+// 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 "chromeos/login/login_state.h"
+
+#include "base/chromeos/chromeos_version.h"
+#include "base/command_line.h"
+#include "base/logging.h"
+#include "chromeos/chromeos_switches.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+
+namespace chromeos {
+
+namespace {
+
+// When running a Chrome OS build outside of a device (i.e. on a developer's
+// workstation) and not running as login-manager, pretend like we're always
+// logged in.
+bool AlwaysLoggedIn() {
+  return !base::chromeos::IsRunningOnChromeOS() &&
+      !CommandLine::ForCurrentProcess()->HasSwitch(switches::kLoginManager);
+}
+
+}  // namespace
+
+static LoginState* g_login_state = NULL;
+
+// static
+void LoginState::Initialize() {
+  CHECK(!g_login_state);
+  g_login_state = new LoginState();
+}
+
+// static
+void LoginState::Shutdown() {
+  CHECK(g_login_state);
+  delete g_login_state;
+  g_login_state = NULL;
+}
+
+// static
+LoginState* LoginState::Get() {
+  CHECK(g_login_state) << "LoginState::Get() called before Initialize()";
+  return g_login_state;
+}
+
+// static
+bool LoginState::IsInitialized() {
+  return !!g_login_state;

[bartfab (slow), 2013/04/05 13:16:33]

Nit: The !! for converting to a bool are useful in JavaScript. In C++, the
conversion will happen implicitly for you anyway.

[stevenjb, 2013/04/05 18:17:15]

We have this a lot in our code; I forget where I ran into this being required,
it might be an older compatibility issue. I spoke with jam@ and confirmed that
the implicit conversion is fine. Done.

+}
+
+void LoginState::AddObserver(Observer* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void LoginState::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
+void LoginState::SetLoginState(LoginState::State state) {
+  if (state == state_)
+    return;
+  VLOG(1) << "Login State: " << state;
+  state_ = state;
+  NotifyObservers();
+}
+
+LoginState::State LoginState::GetLoginState() const {
+  if (state_ == LOGGED_IN_OOBE || state_ == LOGGED_IN_NONE) {
+    if (AlwaysLoggedIn()) {

[Nikita (slow), 2013/04/05 04:08:53]

niut: I don't think that you specifically need this non-Chrome OS device
handling as when you run Chrome w/o parameter you're logged in as stub user and
it should initialize LoginState properly.

And it's better to rely on that functionality because it also configures User
instance. Otherwise just returning LoginState as logged in you may end up in
accessing User instance that has not been initialized.

[stevenjb, 2013/04/05 18:17:15]

I don't want to change this logic with this CL. I was careful to preserve the
existing logic, and a lot of us depend on it for testing on Linux. I can talk to
some of the other UI devs about changing this in the future. I think I'd
actually like to expand and improve our ability to fake various fake login
states on Linux.

+      // Fake a login state when running in a dev environment.
+      if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kGuestSession))
+        return LOGGED_IN_GUEST;
+      else
+        return LOGGED_IN_OWNER;
+    }
+    return state_;
+  }
+  // |state_| may get set before |session_started_|.

[bartfab (slow), 2013/04/05 13:16:33]

|state_| actually always gets set before |session_started_| from
UserManagerImpl::UpdateLoginState(). This will cause the observers to be
notified that the state changed to LOGGED_IN_NONE and then to be notified again
a moment later when |session_started_| is set.

I think the SetLoginState() and SetSessionStarted() methods should be joined
into one to avoid this spurious notification.

[stevenjb, 2013/04/05 18:17:15]

I didn't want to make any assumptions or change the existing logic with this CL.
I agree that this could and should be improved. What I'd really like to see is
UserManager split into pieces that allow the interface to be moved here, without
waiting for all of the Chrome dependent parts to be migrated.

[bartfab (slow), 2013/04/08 15:18:36]

I agree that changing existing functionality is always a challenge, especially
if the code is outside your regular field of expertise. But this here is new
code with new methods you implemented from scratch. Why not have |state_| and
|session_started_| be set at the same time?

+  if (!session_started_)
+    return LOGGED_IN_NONE;
+  if (screen_locked_)
+    return LOGGED_IN_LOCKED;
+  return state_;
+}
+
+bool LoginState::IsUserLoggedIn() {
+  State login_state = GetLoginState();
+  if (login_state == LOGGED_IN_OOBE || login_state == LOGGED_IN_NONE)

[bartfab (slow), 2013/04/05 13:16:33]

Another case where a consumer has to know about the various enum values when
really, it wants a boolean result that could be gotten directly from the
UserManager.

+    return false;
+  return true;
+}
+
+void LoginState::SetSessionStarted(bool session_started) {
+  session_started_ = session_started;
+  NotifyObservers();
+}
+
+bool LoginState::IsSessionStarted() const {
+  return session_started_;
+}
+
+// Private methods
+
+LoginState::LoginState() : state_(LOGGED_IN_OOBE),
+                           session_started_(false),
+                           screen_locked_(false) {
+  DBusThreadManager::Get()->GetSessionManagerClient()->AddObserver(this);
+}
+
+LoginState::~LoginState() {
+  DBusThreadManager::Get()->GetSessionManagerClient()->RemoveObserver(this);
+}
+
+void LoginState::LockScreen() {
+  screen_locked_ = true;
+  NotifyObservers();
+}
+
+void LoginState::UnlockScreen() {
+  screen_locked_ = false;
+  NotifyObservers();
+}
+
+void LoginState::NotifyObservers() {
+  FOR_EACH_OBSERVER(LoginState::Observer, observer_list_,
+                    LoginStateChanged(GetLoginState()));
+}
+
+}  // namespace chromeos