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;
   }
 
-  ash::Shell::GetInstance()->delegate()->AddVirtualKeyboardStateObserver(this);
-  ash::Shell::GetScreen()->AddObserver(this);
+  if (ash::Shell::HasInstance()) {
+    ash::Shell::GetInstance()->delegate()->
+        AddVirtualKeyboardStateObserver(this);
+    ash::Shell::GetScreen()->AddObserver(this);
+  }
 
   // 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
@@ skipping 15 matching lines @@
   chrome::IncrementKeepAliveCount();
 
   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/04 16:14:28]

I believe we want to use it, and if so, we should have TODO with a bug. bshe@?

[bshe, 2014/09/04 18:36:53]

Right. I think eventually we want to support changing wallpaper in athena. Not
sure about the timeline though. Leaving a todo sounds fine and can probably
refer to crbug.com/408734 ?

[Dmitry Polukhin, 2014/09/05 15:05:00]

Done.

+  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;
   }
 
-  ash::Shell::GetInstance()->delegate()->
-      RemoveVirtualKeyboardStateObserver(this);
-  ash::Shell::GetScreen()->RemoveObserver(this);
+  if (ash::Shell::HasInstance()) {
+    ash::Shell::GetInstance()->delegate()->
+        RemoveVirtualKeyboardStateObserver(this);
+    ash::Shell::GetScreen()->RemoveObserver(this);
+  }
 
   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()) {
-    // 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();
+    if (ash::Shell::HasInstance()) {
+      // 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();
+    }
     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)
+  // TODO(dpolukhin): find right place for login/lock screen container,
+  // perhaps inside athena::SystemUI.
+  athena::ScreenManager::ContainerParams container_params(
+      "LoginScreen", athena::CP_LOGIN_SCREEN);
+  container_params.can_activate_children = true;
+  params.parent = athena::ScreenManager::Get()->CreateContainer(
+      container_params);

[oshima, 2014/09/04 16:14:28]

this container should be deleted when exiting login screen.

[Dmitry Polukhin, 2014/09/08 09:10:45]

Done.

[Nikita (slow), 2014/09/08 09:53:17]

Are there plans to have single place (like RootWindow in Ash) that manages such
containers?

Lock screen may reuse this container and lock screen is not handled by
LoginDisplayHost so it seems that having one place that creates this container
just once would be a better approach.

+#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)
   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