Minimal support for OOBE/login for chrome-athena

chrome/browser/chromeos/login/ui/login_display_host_impl.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/ui/login_display_host_impl.h"
 
 #include <vector>
 
 #include "ash/audio/sounds.h"
 #include "ash/desktop_background/desktop_background_controller.h"
@@ skipping 78 matching lines @@
 #include "ui/gfx/size.h"
 #include "ui/gfx/transform.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_util.h"
 #include "ui/views/focus/focus_manager.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/window_animations.h"
 #include "url/gurl.h"
 
+#if defined(USE_ATHENA)
+#include "athena/common/container_priorities.h"
+#include "athena/screen/public/screen_manager.h"
+#endif
+
 namespace {
 
 // Maximum delay for startup sound after 'loginPromptVisible' signal.
 const int kStartupSoundMaxDelayMs = 2000;
 
 // URL which corresponds to the login WebUI.
 const char kLoginURL[] = "chrome://oobe/login";
 
 // URL which corresponds to the OOBE WebUI.
 const char kOobeURL[] = "chrome://oobe/oobe";
@@ skipping 173 matching lines @@
       startup_sound_played_(false),
       startup_sound_honors_spoken_feedback_(false),
       is_observing_keyboard_(false) {
   DBusThreadManager::Get()->GetSessionManagerClient()->AddObserver(this);
   CrasAudioHandler::Get()->AddAudioObserver(this);
   if (keyboard::KeyboardController::GetInstance()) {
     keyboard::KeyboardController::GetInstance()->AddObserver(this);
     is_observing_keyboard_ = true;
   }
 
+#if !defined(USE_ATHENA)
   ash::Shell::GetInstance()->delegate()->AddVirtualKeyboardStateObserver(this);
   ash::Shell::GetScreen()->AddObserver(this);
+#endif
 
   // We need to listen to CLOSE_ALL_BROWSERS_REQUEST but not APP_TERMINATING
   // because/ APP_TERMINATING will never be fired as long as this keeps
   // ref-count. CLOSE_ALL_BROWSERS_REQUEST is safe here because there will be no
   // browser instance that will block the shutdown.
   registrar_.Add(this,
                  chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
                  content::NotificationService::AllSources());
 
   // NOTIFICATION_BROWSER_OPENED is issued after browser is created, but
   // not shown yet. Lock window has to be closed at this point so that
   // a browser window exists and the window can acquire input focus.
   registrar_.Add(this,
                  chrome::NOTIFICATION_BROWSER_OPENED,
                  content::NotificationService::AllSources());
 
   // Login screen is moved to lock screen container when user logs in.
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_USER_CHANGED,
                  content::NotificationService::AllSources());
 
   DCHECK(default_host_ == NULL);
   default_host_ = this;
 
+#if !defined(USE_ATHENA)
   // Make sure chrome won't exit while we are at login/oobe screen.
   chrome::IncrementKeepAliveCount();

[oshima, 2014/09/09 06:32:50]

If someone else may call decrease, you can keep this call.

[Dmitry Polukhin, 2014/09/10 20:30:24]

Done.

+#endif
 
   bool is_registered = StartupUtils::IsDeviceRegistered();
   bool zero_delay_enabled = WizardController::IsZeroDelayEnabled();
   bool disable_boot_animation = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableBootAnimation);
 
   waiting_for_wallpaper_load_ = !zero_delay_enabled &&
                                 (!is_registered || !disable_boot_animation);
 
+#if defined(USE_ATHENA)
+  // Athena doesn't use wallpaper manager so don't wait for wallpaper loading,

[oshima, 2014/09/09 06:32:50]

Athena will use wallpaper manager, so please update the comment and just say
this is a temporal solution.

[Dmitry Polukhin, 2014/09/10 20:30:24]

Done.

+  // crbug.com/408734.
+  waiting_for_wallpaper_load_ = false;
+#endif
+
   // For slower hardware we have boot animation disabled so
   // we'll be initializing WebUI hidden, waiting for user pods to load and then
   // show WebUI at once.
   waiting_for_user_pods_ = !zero_delay_enabled && !waiting_for_wallpaper_load_;
 
   initialize_webui_hidden_ =
       kHiddenWebUIInitializationDefault && !zero_delay_enabled;
 
   // Check if WebUI init type is overriden.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshWebUIInit)) {
@@ skipping 45 matching lines @@
 }
 
 LoginDisplayHostImpl::~LoginDisplayHostImpl() {
   DBusThreadManager::Get()->GetSessionManagerClient()->RemoveObserver(this);
   CrasAudioHandler::Get()->RemoveAudioObserver(this);
   if (keyboard::KeyboardController::GetInstance() && is_observing_keyboard_) {
     keyboard::KeyboardController::GetInstance()->RemoveObserver(this);
     is_observing_keyboard_ = false;
   }
 
+#if !defined(USE_ATHENA)
   ash::Shell::GetInstance()->delegate()->
       RemoveVirtualKeyboardStateObserver(this);
   ash::Shell::GetScreen()->RemoveObserver(this);
+#endif
 
   if (login_view_ && login_window_)
     login_window_->RemoveRemovalsObserver(this);
 
   if (login::LoginScrollIntoViewEnabled())
     ResetKeyboardOverscrollOverride();
 
   views::FocusManager::set_arrow_key_traversal_enabled(false);
   ResetLoginWindowAndView();
 
+#if !defined(USE_ATHENA)
   // Let chrome process exit after login/oobe screen if needed.
   chrome::DecrementKeepAliveCount();
+#endif
 
   default_host_ = NULL;
   // TODO(tengs): This should be refactored. See crbug.com/314934.
   if (user_manager::UserManager::Get()->IsCurrentUserNew()) {
     // DriveOptInController will delete itself when finished.
     (new DriveFirstRunController(
         ProfileManager::GetActiveUserProfile()))->EnableOfflineMode();
   }
 }
 
@@ skipping 353 matching lines @@
     // example) are ignored.
     OnBrowserCreated();
     registrar_.Remove(this,
                       chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
                       content::NotificationService::AllSources());
     registrar_.Remove(this,
                       chrome::NOTIFICATION_BROWSER_OPENED,
                       content::NotificationService::AllSources());
   } else if (type == chrome::NOTIFICATION_LOGIN_USER_CHANGED &&
              user_manager::UserManager::Get()->IsCurrentUserNew()) {
+#if !defined(USE_ATHENA)
     // For new user, move desktop to locker container so that windows created
     // during the user image picker step are below it.
     ash::Shell::GetInstance()->
         desktop_background_controller()->MoveDesktopToLockedContainer();
+#endif
     registrar_.Remove(this,
                       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
                       content::NotificationService::AllSources());
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LoginDisplayHostImpl, WebContentsObserver implementation:
 
 void LoginDisplayHostImpl::RenderProcessGone(base::TerminationStatus status) {
@@ skipping 237 matching lines @@
     focus_ring_controller_->SetVisible(true);
 
     keyboard_driven_oobe_key_handler_.reset(new KeyboardDrivenOobeKeyHandler);
   }
 
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params.bounds = background_bounds();
   params.show_state = ui::SHOW_STATE_FULLSCREEN;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
+#if defined(USE_ATHENA)
+  athena::ScreenManager::ContainerParams container_params(
+      "LoginScreen", athena::CP_LOGIN_SCREEN);
+  container_params.can_activate_children = true;

[oshima, 2014/09/09 06:32:51]

container_params.grab_inputs = true?

[Dmitry Polukhin, 2014/09/10 20:30:24]

It is not required now because other Athena windows don't exists at this point
but later we may need it for lock screen.

[oshima, 2014/09/10 20:42:27]

Acknowledged.

+  login_screen_container_.reset(
+      athena::ScreenManager::Get()->CreateContainer(container_params));
+  params.parent = login_screen_container_.get();
+#else
   params.parent =
       ash::Shell::GetContainer(ash::Shell::GetPrimaryRootWindow(),
                                ash::kShellWindowId_LockScreenContainer);
-
+#endif
   login_window_ = new views::Widget;
   params.delegate = new LoginWidgetDelegate(login_window_);
   login_window_->Init(params);
 
   login_view_ = new WebUILoginView();
   login_view_->Init();
   if (login_view_->webui_visible())
     OnLoginPromptVisible();
 
   wm::SetWindowVisibilityAnimationDuration(
@@ skipping 81 matching lines @@
 // external
 
 // Declared in login_wizard.h so that others don't need to depend on our .h.
 // TODO(nkostylev): Split this into a smaller functions.
 void ShowLoginWizard(const std::string& first_screen_name) {
   if (browser_shutdown::IsTryingToQuit())
     return;
 
   VLOG(1) << "Showing OOBE screen: " << first_screen_name;
 
+#if !defined(USE_ATHENA)

[oshima, 2014/09/09 06:32:50]

crbug.com/407579

[Dmitry Polukhin, 2014/09/10 20:30:24]

Done.

   chromeos::input_method::InputMethodManager* manager =
       chromeos::input_method::InputMethodManager::Get();
 
   // Set up keyboards. For example, when |locale| is "en-US", enable US qwerty
   // and US dvorak keyboard layouts.
   if (g_browser_process && g_browser_process->local_state()) {
     manager->GetActiveIMEState()->SetInputMethodLoginDefault();
 
     PrefService* prefs = g_browser_process->local_state();
     // Apply owner preferences for tap-to-click and mouse buttons swap for
     // login screen.
     system::InputDeviceSettings::Get()->SetPrimaryButtonRight(
         prefs->GetBoolean(prefs::kOwnerPrimaryMouseButtonRight));
     system::InputDeviceSettings::Get()->SetTapToClick(
         prefs->GetBoolean(prefs::kOwnerTapToClickEnabled));
   }
   system::InputDeviceSettings::Get()->SetNaturalScroll(
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kNaturalScrollDefault));
+#endif
 
   gfx::Rect screen_bounds(chromeos::CalculateScreenBounds(gfx::Size()));
 
   g_browser_process->platform_part()->SessionManager()->SetSessionState(
       StartupUtils::IsOobeCompleted()
           ? session_manager::SESSION_STATE_LOGIN_PRIMARY
           : session_manager::SESSION_STATE_OOBE);
 
   LoginDisplayHost* display_host = new LoginDisplayHostImpl(screen_bounds);
 
@@ skipping 50 matching lines @@
   // EmitLoginPromptReady.
   PrefService* prefs = g_browser_process->local_state();
   const std::string& current_locale =
       prefs->GetString(prefs::kApplicationLocale);
   VLOG(1) << "Current locale: " << current_locale;
   const std::string& locale = startup_manifest->initial_locale_default();
 
   const std::string& layout = startup_manifest->keyboard_layout();
   VLOG(1) << "Initial locale: " << locale << "keyboard layout " << layout;
 
+#if !defined(USE_ATHENA)
   // Determine keyboard layout from OEM customization (if provided) or
   // initial locale and save it in preferences.
   manager->GetActiveIMEState()->SetInputMethodLoginDefaultFromVPD(locale,
                                                                   layout);
+#endif
 
   if (!current_locale.empty() || locale.empty()) {
     ShowLoginWizardFinish(first_screen_name, startup_manifest, display_host);
     return;
   }
 
   // Save initial locale from VPD/customization manifest as current
   // Chrome locale. Otherwise it will be lost if Chrome restarts.
   // Don't need to schedule pref save because setting initial local
   // will enforce preference saving.
   prefs->SetString(prefs::kApplicationLocale, locale);
   StartupUtils::SetInitialLocale(locale);
 
   scoped_ptr<ShowLoginWizardSwitchLanguageCallbackData> data(
       new ShowLoginWizardSwitchLanguageCallbackData(
           first_screen_name, startup_manifest, display_host));
 
   scoped_ptr<locale_util::SwitchLanguageCallback> callback(
       new locale_util::SwitchLanguageCallback(
           base::Bind(&OnLanguageSwitchedCallback, base::Passed(data.Pass()))));
 
   // Load locale keyboards here. Hardware layout would be automatically enabled.
   locale_util::SwitchLanguage(
       locale, true, true /* login_layouts_only */, callback.Pass());
 }
 
 }  // namespace chromeos