Login Screen for Mus

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 <utility>
 #include <vector>
 
 #include "ash/audio/sounds.h"
@@ skipping 40 matching lines @@
 #include "chrome/browser/chromeos/policy/enrollment_config.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/system/device_disabling_manager.h"
 #include "chrome/browser/chromeos/system/input_device_settings.h"
 #include "chrome/browser/chromeos/system/timezone_resolver_manager.h"
 #include "chrome/browser/chromeos/system/timezone_util.h"
 #include "chrome/browser/chromeos/ui/focus_ring_controller.h"
 #include "chrome/browser/lifetime/keep_alive_types.h"
 #include "chrome/browser/lifetime/scoped_keep_alive.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/ui/ash/ash_util.h"
 #include "chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/browser_resources.h"
 #include "chromeos/audio/chromeos_sounds.h"
 #include "chromeos/chromeos_constants.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
@@ skipping 199 matching lines @@
       is_wallpaper_loaded_(false),
       status_area_saved_visibility_(false),
       crash_count_(0),
       restore_path_(RESTORE_UNKNOWN),
       finalize_animation_type_(ANIMATION_WORKSPACE),
       startup_sound_played_(false),
       startup_sound_honors_spoken_feedback_(false),
       is_observing_keyboard_(false),
       pointer_factory_(this),
       animation_weak_ptr_factory_(this) {
+  if (chrome::IsRunningInMash()) {
+    finalize_animation_type_ = ANIMATION_NONE;
+    initialize_webui_hidden_ = 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);
+  if (!chrome::IsRunningInMash()) {
+    ash::Shell::GetInstance()->delegate()->AddVirtualKeyboardStateObserver(
+        this);
+  }
   gfx::Screen::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());
 
@@ skipping 11 matching lines @@
 
   DCHECK(default_host() == nullptr);
   default_host_ = this;
 
   keep_alive_.reset(
       new ScopedKeepAlive(KeepAliveOrigin::LOGIN_DISPLAY_HOST_IMPL,
                           KeepAliveRestartOption::DISABLED));
 
   bool is_registered = StartupUtils::IsDeviceRegistered();
   bool zero_delay_enabled = WizardController::IsZeroDelayEnabled();
+  if (chrome::IsRunningInMash())
+    zero_delay_enabled = true;
   bool disable_boot_animation =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableBootAnimation);
 
   waiting_for_wallpaper_load_ = !zero_delay_enabled &&
                                 (!is_registered || !disable_boot_animation);
 
   // 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;
+  if (!chrome::IsRunningInMash()) {
+    initialize_webui_hidden_ =
+        kHiddenWebUIInitializationDefault && !zero_delay_enabled;
+  }
 
   // Check if WebUI init type is overriden.
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+  if (!chrome::IsRunningInMash() &&
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshWebUIInit)) {
     const std::string override_type =
         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             switches::kAshWebUIInit);
     if (override_type == kWebUIInitParallel)
       initialize_webui_hidden_ = true;
     else if (override_type == kWebUIInitPostpone)
       initialize_webui_hidden_ = false;
   }
 
@@ skipping 24 matching lines @@
           << " wait_for_wp_load_: " << waiting_for_wallpaper_load_
           << " wait_for_pods_: " << waiting_for_user_pods_
           << " init_webui_hidden_: " << initialize_webui_hidden_;
 
   media::SoundsManager* manager = media::SoundsManager::Get();
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   manager->Initialize(chromeos::SOUND_STARTUP,
                       bundle.GetRawDataResource(IDR_SOUND_STARTUP_WAV));
 
   // Disable Drag'n'Drop for the login session.
-  scoped_drag_drop_disabler_.reset(new aura::client::ScopedDragDropDisabler(
-      ash::Shell::GetPrimaryRootWindow()));
+  if (!chrome::IsRunningInMash()) {
+    scoped_drag_drop_disabler_.reset(new aura::client::ScopedDragDropDisabler(
+        ash::Shell::GetPrimaryRootWindow()));
+  }
 }
 
 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);
+  if (!chrome::IsRunningInMash()) {
+    ash::Shell::GetInstance()->delegate()->RemoveVirtualKeyboardStateObserver(
+        this);
+  }
   gfx::Screen::GetScreen()->RemoveObserver(this);
 
   if (login_view_ && login_window_)
     login_window_->RemoveRemovalsObserver(this);
 
   chrome::MultiUserWindowManager* window_manager =
       chrome::MultiUserWindowManager::GetInstance();
   // MultiUserWindowManager instance might be null if no user is logged in - or
   // in a unit test.
   if (window_manager)
@@ skipping 140 matching lines @@
 AppLaunchController* LoginDisplayHostImpl::GetAppLaunchController() {
   return app_launch_controller_.get();
 }
 
 void LoginDisplayHostImpl::StartUserAdding(
     const base::Closure& completion_callback) {
   DisableKeyboardOverscroll();
 
   restore_path_ = RESTORE_ADD_USER_INTO_SESSION;
   completion_callback_ = completion_callback;
-  finalize_animation_type_ = ANIMATION_ADD_USER;
+  if (!chrome::IsRunningInMash())
+    finalize_animation_type_ = ANIMATION_ADD_USER;
   // Observe the user switch animation and defer the deletion of itself only
   // after the animation is finished.
   chrome::MultiUserWindowManager* window_manager =
       chrome::MultiUserWindowManager::GetInstance();
   // MultiUserWindowManager instance might be null in a unit test.
   if (window_manager)
     window_manager->AddObserver(this);
 
   VLOG(1) << "Login WebUI >> user adding";
   if (!login_window_)
     LoadURL(GURL(kUserAddingURL));
   // We should emit this signal only at login screen (after reboot or sign out).
   login_view_->set_should_emit_login_prompt_visible(false);
 
-  // Lock container can be transparent after lock screen animation.
-  aura::Window* lock_container = ash::Shell::GetContainer(
-      ash::Shell::GetPrimaryRootWindow(),
-      ash::kShellWindowId_LockScreenContainersContainer);
-  lock_container->layer()->SetOpacity(1.0);
+  if (!chrome::IsRunningInMash()) {
+    // Lock container can be transparent after lock screen animation.
+    aura::Window* lock_container = ash::Shell::GetContainer(
+        ash::Shell::GetPrimaryRootWindow(),
+        ash::kShellWindowId_LockScreenContainersContainer);
+    lock_container->layer()->SetOpacity(1.0);
 
-  ash::Shell::GetInstance()->
-      desktop_background_controller()->MoveDesktopToLockedContainer();
+    ash::Shell::GetInstance()
+        ->desktop_background_controller()
+        ->MoveDesktopToLockedContainer();
+  }
 
   existing_user_controller_.reset();  // Only one controller in a time.
   existing_user_controller_.reset(new chromeos::ExistingUserController(this));
 
   if (!signin_screen_controller_.get()) {
     signin_screen_controller_.reset(new SignInScreenController(
         GetOobeUI(), webui_login_display_->delegate()));
   }
 
   SetOobeProgressBarVisible(oobe_progress_bar_visible_ = false);
@@ skipping 17 matching lines @@
 
 void LoginDisplayHostImpl::StartSignInScreen(
     const LoginScreenContext& context) {
   DisableKeyboardOverscroll();
 
   startup_sound_honors_spoken_feedback_ = true;
   TryToPlayStartupSound();
 
   restore_path_ = RESTORE_SIGN_IN;
   is_showing_login_ = true;
-  finalize_animation_type_ = ANIMATION_WORKSPACE;
+  if (!chrome::IsRunningInMash())
+    finalize_animation_type_ = ANIMATION_WORKSPACE;
 
   PrewarmAuthentication();
 
   if (waiting_for_wallpaper_load_ && !initialize_webui_hidden_) {
     VLOG(1) << "Login WebUI >> sign in postponed";
     return;
   }
   VLOG(1) << "Login WebUI >> sign in";
 
   if (!login_window_) {
@@ skipping 104 matching lines @@
 
   bool device_disabled = false;
   CrosSettings::Get()->GetBoolean(kDeviceDisabled, &device_disabled);
   if (device_disabled && system::DeviceDisablingManager::
                              HonorDeviceDisablingDuringNormalOperation()) {
     // If the device is disabled, bail out. A device disabled screen will be
     // shown by the DeviceDisablingManager.
     return;
   }
 
-  finalize_animation_type_ = ANIMATION_FADE_OUT;
+  if (!chrome::IsRunningInMash())
+    finalize_animation_type_ = ANIMATION_FADE_OUT;
   if (!login_window_)
     LoadURL(GURL(kAppLaunchSplashURL));
 
   login_view_->set_should_emit_login_prompt_visible(false);
 
   app_launch_controller_.reset(new AppLaunchController(
       app_id, diagnostic_mode, this, GetOobeUI()));
 
   app_launch_controller_->StartAppLaunch(auto_launch);
 }
@@ skipping 49 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 (!chrome::IsRunningInMash()) {
+      // 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());
   } else if (chrome::NOTIFICATION_WALLPAPER_ANIMATION_FINISHED == type) {
     VLOG(1) << "Login WebUI >> wp animation done";
     is_wallpaper_loaded_ = true;
-    ash::Shell::GetInstance()->user_wallpaper_delegate()
-        ->OnWallpaperBootAnimationFinished();
+    if (!chrome::IsRunningInMash()) {
+      ash::Shell::GetInstance()
+          ->user_wallpaper_delegate()
+          ->OnWallpaperBootAnimationFinished();
+    }
     if (waiting_for_wallpaper_load_) {
       // StartWizard / StartSignInScreen could be called multiple times through
       // the lifetime of host.
       // Make sure that subsequent calls are not postponed.
       waiting_for_wallpaper_load_ = false;
       if (initialize_webui_hidden_)
         ShowWebUI();
       else
         StartPostponedWebUI();
     }
@@ skipping 126 matching lines @@
   shutting_down_ = true;
   registrar_.RemoveAll();
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   if (post_quit_task)
     base::MessageLoop::current()->QuitWhenIdle();
 
   if (!completion_callback_.is_null())
     base::MessageLoop::current()->PostTask(FROM_HERE, completion_callback_);
 
   if (ash::Shell::HasInstance() &&
-      finalize_animation_type_ == ANIMATION_ADD_USER) {
+      finalize_animation_type_ == ANIMATION_ADD_USER &&
+      !chrome::IsRunningInMash()) {
     ash::Shell::GetInstance()
         ->desktop_background_controller()
         ->MoveDesktopToUnlockedContainer();
   }
 }
 
 void LoginDisplayHostImpl::ScheduleWorkspaceAnimation() {
+  if (chrome::IsRunningInMash())
+    return;
   if (ash::Shell::GetContainer(ash::Shell::GetPrimaryRootWindow(),
                                ash::kShellWindowId_DesktopBackgroundContainer)
           ->children()
           .empty()) {
     // If there is no background window, don't perform any animation on the
     // default and background layer because there is nothing behind it.
     return;
   }
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 85 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;
-  params.parent =
-      ash::Shell::GetContainer(ash::Shell::GetPrimaryRootWindow(),
-                               ash::kShellWindowId_LockScreenContainer);
+  if (!chrome::IsRunningInMash()) {
+    params.parent =
+        ash::Shell::GetContainer(ash::Shell::GetPrimaryRootWindow(),
+                                 ash::kShellWindowId_LockScreenContainer);
+  }
   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();
 
-  login_window_->SetVisibilityAnimationDuration(
-      base::TimeDelta::FromMilliseconds(kLoginFadeoutTransitionDurationMs));
-  login_window_->SetVisibilityAnimationTransition(views::Widget::ANIMATE_HIDE);
+  if (!chrome::IsRunningInMash()) {
+    login_window_->SetVisibilityAnimationDuration(
+        base::TimeDelta::FromMilliseconds(kLoginFadeoutTransitionDurationMs));
+    login_window_->SetVisibilityAnimationTransition(
+        views::Widget::ANIMATE_HIDE);
+  }
 
   login_window_->AddRemovalsObserver(this);
   login_window_->SetContentsView(login_view_);
 
   // If WebUI is initialized in hidden state, show it only if we're no
   // longer waiting for wallpaper animation/user images loading. Otherwise,
   // always show it.
   if (!initialize_webui_hidden_ ||
       (!waiting_for_wallpaper_load_ && !waiting_for_user_pods_)) {
     VLOG(1) << "Login WebUI >> show login wnd on create";
@@ skipping 200 matching lines @@
 
   locale_util::SwitchLanguageCallback callback(
       base::Bind(&OnLanguageSwitchedCallback, base::Passed(std::move(data))));
 
   // Load locale keyboards here. Hardware layout would be automatically enabled.
   locale_util::SwitchLanguage(locale, true, true /* login_layouts_only */,
                               callback, ProfileManager::GetActiveUserProfile());
 }
 
 }  // namespace chromeos