Lock screen for Chrome-Athena

chrome/browser/chromeos/login/lock/screen_locker.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 "chrome/browser/chromeos/login/lock/screen_locker.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 342 matching lines @@
   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);
     UserAddingScreen::Get()->Cancel();
     return;
   }
   if (g_screen_lock_observer->session_started() &&
       user_manager::UserManager::Get()->CanCurrentUserLock()) {
     ScreenLocker::Show();
+#if !defined(USE_ATHENA)

[Jun Mukai, 2014/10/13 18:20:24]

Please note a crbug.com issue for the missing feature (crbug.com/413926 would be
fine)

[Dmitry Polukhin, 2014/10/14 11:20:34]

Done, but I'm not sure what should be do here. In Athena there is no Shell
instance that we should notify about locking.

     ash::Shell::GetInstance()->lock_state_controller()->OnStartingLock();
+#endif
   } 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();
   }
 }
 
 // static
 void ScreenLocker::Show() {
-#if defined(USE_ATHENA)
-  // crbug.com/413926
-  return;
-#endif
-
   content::RecordAction(UserMetricsAction("ScreenLocker_Show"));
   DCHECK(base::MessageLoopForUI::IsCurrent());
 
   // Check whether the currently logged in user is a guest account and if so,
   // refuse to lock the screen (crosbug.com/23764).
   // For a demo user, we should never show the lock screen (crosbug.com/27647).
   if (user_manager::UserManager::Get()->IsLoggedInAsGuest() ||
       user_manager::UserManager::Get()->IsLoggedInAsDemoUser()) {
     VLOG(1) << "Refusing to lock screen for guest/demo account";
     return;
   }
 
+#if !defined(USE_ATHENA)
   // If the active window is fullscreen, exit fullscreen to avoid the web page
   // or app mimicking the lock screen. Do not exit fullscreen if the shelf is
   // visible while in fullscreen because the shelf makes it harder for a web
   // page or app to mimick the lock screen.
   ash::wm::WindowState* active_window_state = ash::wm::GetActiveWindowState();
   if (active_window_state &&
       active_window_state->IsFullscreen() &&
       active_window_state->hide_shelf_when_fullscreen()) {
     const ash::wm::WMEvent event(ash::wm::WM_EVENT_TOGGLE_FULLSCREEN);
     active_window_state->OnWMEvent(&event);
   }
+#endif
 
   if (!screen_locker_) {
     ScreenLocker* locker =
         new ScreenLocker(user_manager::UserManager::Get()->GetUnlockUsers());
     VLOG(1) << "Created ScreenLocker " << locker;
     locker->Init();
   } else {
     VLOG(1) << "ScreenLocker " << screen_locker_ << " already exists; "
             << " calling session manager's HandleLockScreenShown D-Bus method";
     DBusThreadManager::Get()->GetSessionManagerClient()->
         NotifyLockScreenShown();
   }
 }
 
 // static
 void ScreenLocker::Hide() {
-#if defined(USE_ATHENA)
-  // crbug.com/413926
-  return;
-#endif
-
   DCHECK(base::MessageLoopForUI::IsCurrent());
   // For a guest/demo user, screen_locker_ would have never been initialized.
   if (user_manager::UserManager::Get()->IsLoggedInAsGuest() ||
       user_manager::UserManager::Get()->IsLoggedInAsDemoUser()) {
     VLOG(1) << "Refusing to hide lock screen for guest/demo account";
     return;
   }
 
   DCHECK(screen_locker_);
   base::Callback<void(void)> callback =
       base::Bind(&ScreenLocker::ScheduleDeletion);
+#if !defined(USE_ATHENA)
   ash::Shell::GetInstance()->lock_state_controller()->
     OnLockScreenHide(callback);
+#else
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
+#endif
 }
 
 void ScreenLocker::ScheduleDeletion() {
   // Avoid possible multiple calls.
   if (screen_locker_ == NULL)
     return;
   VLOG(1) << "Deleting ScreenLocker " << screen_locker_;
 
+#if !defined(USE_ATHENA)
   ash::PlaySystemSoundIfSpokenFeedback(SOUND_UNLOCK);
+#endif
 
   delete screen_locker_;
   screen_locker_ = NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ScreenLocker, private:
 
 ScreenLocker::~ScreenLocker() {
   VLOG(1) << "Destroying ScreenLocker " << this;
   DCHECK(base::MessageLoopForUI::IsCurrent());
 
   if (authenticator_.get())
     authenticator_->SetConsumer(NULL);
   ClearErrors();
 
+#if !defined(USE_ATHENA)
+  // TOOD(dpolukhin): we need to to something similar for Athena.

[oshima, 2014/10/13 18:52:20]

we probably should simply make containers in between invisible (by setting 0
opacity) instead of updating structure.

[Dmitry Polukhin, 2014/10/14 11:20:33]

I don't like approach with invisible windows on lock screen. I would change
window tree to make separate root window for lock screen. Anyway it needs to be
refined when Athene will have normal wallpaper manager.

[oshima, 2014/10/14 19:05:15]

Moving container (or window) triggers a lot of observer executions, and that
used to cause other issues.

I'm going to create an API to hide containers (so that you don't have to worry
about how), so we can revisit later when it's ready.

   VLOG(1) << "Moving desktop background to unlocked container";
   ash::Shell::GetInstance()->
       desktop_background_controller()->MoveDesktopToUnlockedContainer();
+#endif
 
   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";
@@ skipping 10 matching lines @@
 }
 
 void ScreenLocker::ScreenLockReady() {
   locked_ = true;
   base::TimeDelta delta = base::Time::Now() - start_time_;
   VLOG(1) << "ScreenLocker " << this << " is ready after "
           << delta.InSecondsF() << " second(s)";
   UMA_HISTOGRAM_TIMES("ScreenLocker.ScreenLockTime", delta);
 
   VLOG(1) << "Moving desktop background to locked container";
+#if !defined(USE_ATHENA)
   ash::Shell::GetInstance()->
       desktop_background_controller()->MoveDesktopToLockedContainer();
+#endif
 
   input_method::InputMethodManager* imm =
       input_method::InputMethodManager::Get();
   saved_ime_state_ = imm->GetActiveIMEState();
   imm->SetState(saved_ime_state_->Clone());
   imm->GetActiveIMEState()->EnableLockScreenLayouts();
 
   bool state = true;
   VLOG(1) << "Emitting SCREEN_LOCK_STATE_CHANGED with state=" << state;
   content::NotificationService::current()->Notify(
@@ skipping 12 matching lines @@
   for (user_manager::UserList::const_iterator it = users_.begin();
        it != users_.end();
        ++it) {
     if ((*it)->email() == username)
       return true;
   }
   return false;
 }
 
 }  // namespace chromeos