chromeos: Remove old LockScreen signal.

chrome/browser/chromeos/login/screen_locker.cc

 // 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 "chrome/browser/chromeos/login/screen_locker.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 51 matching lines @@
 
 namespace chromeos {
 
 namespace {
 
 // Timeout for unlock animation guard - some animations may be required to run
 // on successful authentication before unlocking, but we want to be sure that
 // unlock happens even if animations are broken.
 const int kUnlockGuardTimeoutMs = 400;
 
-// Observer to start ScreenLocker when the screen lock
-class ScreenLockObserver : public SessionManagerClient::Observer,
+// Observer to start ScreenLocker when locking the screen is requested.
+class ScreenLockObserver : public SessionManagerClient::StubDelegate,
                            public content::NotificationObserver,
                            public UserAddingScreen::Observer {
  public:
   ScreenLockObserver() : session_started_(false) {
     registrar_.Add(this,
-                   chrome::NOTIFICATION_LOGIN_USER_CHANGED,
-                   content::NotificationService::AllSources());
-    registrar_.Add(this,
                    chrome::NOTIFICATION_SESSION_STARTED,
                    content::NotificationService::AllSources());
+    DBusThreadManager::Get()->GetSessionManagerClient()->SetStubDelegate(this);
+  }
+
+  ~ScreenLockObserver() {
+    if (DBusThreadManager::IsInitialized()) {
+      DBusThreadManager::Get()->GetSessionManagerClient()->SetStubDelegate(
+          NULL);
+    }
   }
 
   bool session_started() const { return session_started_; }
 
+  // SessionManagerClient::StubDelegate overrides:
+  virtual void LockScreenForStub() OVERRIDE {
+    ScreenLocker::HandleLockScreenRequest();
+  }
+
   // NotificationObserver overrides:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
-    switch (type) {
-      case chrome::NOTIFICATION_LOGIN_USER_CHANGED: {
-        // Register Screen Lock only after a user has logged in.
-        SessionManagerClient* session_manager =
-            DBusThreadManager::Get()->GetSessionManagerClient();
-        if (!session_manager->HasObserver(this))
-          session_manager->AddObserver(this);
-        break;
-      }
-
-      case chrome::NOTIFICATION_SESSION_STARTED: {
-        session_started_ = true;
-        break;
-      }
-
-      default:
-        NOTREACHED();
-    }
+    if (type == chrome::NOTIFICATION_SESSION_STARTED)
+      session_started_ = true;
+    else
+      NOTREACHED() << "Unexpected notification " << type;
   }
 
-  // TODO(derat): Remove this once the session manager is calling the LockScreen
-  // method instead of emitting a signal.
-  virtual void LockScreen() OVERRIDE {
-    VLOG(1) << "Received LockScreen D-Bus signal from session manager";
+  // UserAddingScreen::Observer overrides:
+  virtual void OnUserAddingFinished() OVERRIDE {
+    UserAddingScreen::Get()->RemoveObserver(this);
     ScreenLocker::HandleLockScreenRequest();
   }
 
-  virtual void OnUserAddingFinished() OVERRIDE {
-    UserAddingScreen::Get()->RemoveObserver(this);
-    LockScreen();
-  }
-
  private:
   bool session_started_;
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenLockObserver);
 };
 
-static base::LazyInstance<ScreenLockObserver> g_screen_lock_observer =
-    LAZY_INSTANCE_INITIALIZER;
+ScreenLockObserver* g_screen_lock_observer = NULL;
 
 }  // namespace
 
 // static
 ScreenLocker* ScreenLocker::screen_locker_ = NULL;
 
 //////////////////////////////////////////////////////////////////////////////
 // ScreenLocker, public:
 
 ScreenLocker::ScreenLocker(const UserList& users)
@@ skipping 225 matching lines @@
   delegate_->ShowErrorMessage(error_msg_id, help_topic_id);
 }
 
 void ScreenLocker::SetLoginStatusConsumer(
     chromeos::LoginStatusConsumer* consumer) {
   login_status_consumer_ = consumer;
 }
 
 // static
 void ScreenLocker::InitClass() {
-  g_screen_lock_observer.Get();
+  DCHECK(!g_screen_lock_observer);
+  g_screen_lock_observer = new ScreenLockObserver;
+}
+
+// static
+void ScreenLocker::ShutDownClass() {
+  DCHECK(g_screen_lock_observer);
+  delete g_screen_lock_observer;
+  g_screen_lock_observer = NULL;
 }
 
 // static
 void ScreenLocker::HandleLockScreenRequest() {
   VLOG(1) << "Received LockScreen request from session manager";
+  DCHECK(g_screen_lock_observer);
   if (UserAddingScreen::Get()->IsRunning()) {
     VLOG(1) << "Waiting for user adding screen to stop";
-    UserAddingScreen::Get()->AddObserver(g_screen_lock_observer.Pointer());
+    UserAddingScreen::Get()->AddObserver(g_screen_lock_observer);
     UserAddingScreen::Get()->Cancel();
     return;
   }
-  if (g_screen_lock_observer.Get().session_started() &&
+  if (g_screen_lock_observer->session_started() &&
       UserManager::Get()->CanCurrentUserLock()) {
     ScreenLocker::Show();
+    ash::Shell::GetInstance()->lock_state_controller()->OnStartingLock();

[Daniel Erat, 2014/03/12 00:30:44]

note that this was previously getting called unconditionally after
HandleLockScreenRequest() returned, which means it would get called in the
UserAddingScreen::Get()->IsRunning() case and then get called again after the
screen was dismissed. this seems wrong, so i'm it only get called when the lock
screen is actually shown. let me know if i'm misunderstanding how this works.

   } else {
     // If the current user's session cannot be locked or the user has not
     // completed all sign-in steps yet, log out instead. The latter is done to
     // avoid complications with displaying the lock screen over the login
     // screen while remaining secure in the case the user walks away during
     // the sign-in steps. See crbug.com/112225 and crbug.com/110933.
     VLOG(1) << "Calling session manager's StopSession D-Bus method";
     DBusThreadManager::Get()->GetSessionManagerClient()->StopSession();
   }
 }
@@ skipping 82 matching lines @@
       desktop_background_controller()->MoveDesktopToUnlockedContainer();
 
   screen_locker_ = NULL;
   bool state = false;
   VLOG(1) << "Emitting SCREEN_LOCK_STATE_CHANGED with state=" << state;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
       content::Source<ScreenLocker>(this),
       content::Details<bool>(&state));
   VLOG(1) << "Calling session manager's HandleLockScreenDismissed D-Bus method";
+
   DBusThreadManager::Get()->GetSessionManagerClient()->
       NotifyLockScreenDismissed();
 }
 
 void ScreenLocker::SetAuthenticator(Authenticator* authenticator) {
   authenticator_ = authenticator;
 }
 
 void ScreenLocker::ScreenLockReady() {
   locked_ = true;
@@ skipping 22 matching lines @@
 
 bool ScreenLocker::IsUserLoggedIn(const std::string& username) {
   for (UserList::const_iterator it = users_.begin(); it != users_.end(); ++it) {
     if ((*it)->email() == username)
       return true;
   }
   return false;
 }
 
 }  // namespace chromeos