[cros] Rename BaseLoginDisplayHost to LoginDisplayHostImpl

chrome/browser/chromeos/login/login_display_host_impl.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/base_login_display_host.h"
+#include "chrome/browser/chromeos/login/login_display_host_impl.h"
 
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
@@ skipping 87 matching lines @@
 
 ui::Layer* GetLayer(views::Widget* widget) {
   return widget->GetNativeView()->layer();
 }
 
 }  // namespace
 
 namespace chromeos {
 
 // static
-LoginDisplayHost* BaseLoginDisplayHost::default_host_ = NULL;
+LoginDisplayHost* LoginDisplayHostImpl::default_host_ = NULL;
 
 ////////////////////////////////////////////////////////////////////////////////
-// BaseLoginDisplayHost, public
+// LoginDisplayHostImpl, public
 
-BaseLoginDisplayHost::BaseLoginDisplayHost(const gfx::Rect& background_bounds)
+LoginDisplayHostImpl::LoginDisplayHostImpl(const gfx::Rect& background_bounds)
     : background_bounds_(background_bounds),
       ALLOW_THIS_IN_INITIALIZER_LIST(pointer_factory_(this)),
       shutting_down_(false),
       oobe_progress_bar_visible_(false),
       session_starting_(false) {
   // We need to listen to CLOSE_ALL_BROWSERS_REQUEST but not APP_TERMINATIN
   // 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,
@@ skipping 12 matching lines @@
                  chrome::NOTIFICATION_LOGIN_USER_CHANGED,
                  content::NotificationService::AllSources());
 
   DCHECK(default_host_ == NULL);
   default_host_ = this;
 
   // Make sure chrome won't exit while we are at login/oobe screen.
   chrome::StartKeepAlive();
 }
 
-BaseLoginDisplayHost::~BaseLoginDisplayHost() {
+LoginDisplayHostImpl::~LoginDisplayHostImpl() {
   // Let chrome process exit after login/oobe screen if needed.
   chrome::EndKeepAlive();
 
   default_host_ = NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// BaseLoginDisplayHost, LoginDisplayHost implementation:
+// LoginDisplayHostImpl, LoginDisplayHost implementation:
 
-void BaseLoginDisplayHost::BeforeSessionStart() {
+void LoginDisplayHostImpl::BeforeSessionStart() {
   session_starting_ = true;
 }
 
-void BaseLoginDisplayHost::OnSessionStart() {
+void LoginDisplayHostImpl::OnSessionStart() {
   DVLOG(1) << "Session starting";
   ash::Shell::GetInstance()->
       desktop_background_controller()->MoveDesktopToUnlockedContainer();
   if (wizard_controller_.get())
     wizard_controller_->OnSessionStart();
   // Display host is deleted once animation is completed
   // since sign in screen widget has to stay alive.
   StartAnimation();
   ShutdownDisplayHost(false);
 }
 
-void BaseLoginDisplayHost::OnCompleteLogin() {
+void LoginDisplayHostImpl::OnCompleteLogin() {
   // Cancelling the |auto_enrollment_client_| now allows it to determine whether
   // its protocol finished before login was complete.
   if (auto_enrollment_client_.get())
     auto_enrollment_client_.release()->CancelAndDeleteSoon();
 }
 
-void BaseLoginDisplayHost::StartWizard(
+void LoginDisplayHostImpl::StartWizard(
     const std::string& first_screen_name,
     DictionaryValue* screen_parameters) {
   DVLOG(1) << "Starting wizard, first_screen_name: " << first_screen_name;
   // Create and show the wizard.
   // Note, dtor of the old WizardController should be called before ctor of the
   // new one, because "default_controller()" is updated there. So pure "reset()"
   // is done before new controller creation.
   wizard_controller_.reset();
   wizard_controller_.reset(CreateWizardController());
 
   oobe_progress_bar_visible_ = !WizardController::IsDeviceRegistered();
   SetOobeProgressBarVisible(oobe_progress_bar_visible_);
   wizard_controller_->Init(first_screen_name, screen_parameters);
 }
 
-void BaseLoginDisplayHost::StartSignInScreen() {
+void LoginDisplayHostImpl::StartSignInScreen() {
   DVLOG(1) << "Starting sign in screen";
   const chromeos::UserList& users = chromeos::UserManager::Get()->GetUsers();
 
   // Fix for users who updated device and thus never passed register screen.
   // If we already have users, we assume that it is not a second part of
   // OOBE. See http://crosbug.com/6289
   if (!WizardController::IsDeviceRegistered() && !users.empty()) {
     VLOG(1) << "Mark device registered because there are remembered users: "
             << users.size();
     WizardController::MarkDeviceRegistered();
@@ skipping 16 matching lines @@
   ServicesCustomizationDocument::GetInstance()->StartFetching();
 
   // Initiate mobile config load.
   MobileConfig::GetInstance();
 
   // Initiate device policy fetching.
   g_browser_process->browser_policy_connector()->ScheduleServiceInitialization(
       kPolicyServiceInitializationDelayMilliseconds);
 }
 
-WizardController* BaseLoginDisplayHost::GetWizardController() {
+WizardController* LoginDisplayHostImpl::GetWizardController() {
   return wizard_controller_.get();
 }
 
-void BaseLoginDisplayHost::ResumeSignInScreen() {
+void LoginDisplayHostImpl::ResumeSignInScreen() {
   // We only get here after a previous call the StartSignInScreen. That sign-in
   // was successful but was interrupted by an auto-enrollment execution; once
   // auto-enrollment is complete we resume the normal login flow from here.
   DVLOG(1) << "Resuming sign in screen";
   CHECK(sign_in_controller_.get());
   SetOobeProgressBarVisible(oobe_progress_bar_visible_);
   SetStatusAreaVisible(true);
   SetShutdownButtonEnabled(true);
   sign_in_controller_->ResumeLogin();
 }
 
-void BaseLoginDisplayHost::CheckForAutoEnrollment() {
+void LoginDisplayHostImpl::CheckForAutoEnrollment() {
   // This method is called when the controller determines that the
   // auto-enrollment check can start. This happens either after the EULA is
   // accepted, or right after a reboot if the EULA has already been accepted.
 
   if (policy::AutoEnrollmentClient::IsDisabled()) {
     VLOG(1) << "CheckForAutoEnrollment: auto-enrollment disabled";
     return;
   }
 
   // Start by checking if the device has already been owned.
   pointer_factory_.InvalidateWeakPtrs();
   DeviceSettingsService::Get()->GetOwnershipStatusAsync(
-      base::Bind(&BaseLoginDisplayHost::OnOwnershipStatusCheckDone,
+      base::Bind(&LoginDisplayHostImpl::OnOwnershipStatusCheckDone,
                  pointer_factory_.GetWeakPtr()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// BaseLoginDisplayHost, content:NotificationObserver implementation:
+// LoginDisplayHostImpl, content:NotificationObserver implementation:
 
-void BaseLoginDisplayHost::Observe(
+void LoginDisplayHostImpl::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST) {
     ShutdownDisplayHost(true);
   } else if (type == chrome::NOTIFICATION_BROWSER_OPENED && session_starting_) {
     // Browsers created before session start (windows opened by extensions, for
     // 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 &&
              chromeos::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();
     registrar_.Remove(this,
                       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
                       content::NotificationService::AllSources());
   }
 }
 
-void BaseLoginDisplayHost::ShutdownDisplayHost(bool post_quit_task) {
+void LoginDisplayHostImpl::ShutdownDisplayHost(bool post_quit_task) {
   if (shutting_down_)
     return;
 
   shutting_down_ = true;
   registrar_.RemoveAll();
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   if (post_quit_task)
     MessageLoop::current()->Quit();
 }
 
-void BaseLoginDisplayHost::StartAnimation() {
+void LoginDisplayHostImpl::StartAnimation() {
   if (ash::Shell::GetContainer(
           ash::Shell::GetPrimaryRootWindow(),
           ash::internal::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 (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableLoginAnimations))
     ash::Shell::GetInstance()->DoInitialWorkspaceAnimation();
 }
 
-void BaseLoginDisplayHost::OnOwnershipStatusCheckDone(
+void LoginDisplayHostImpl::OnOwnershipStatusCheckDone(
     DeviceSettingsService::OwnershipStatus status,
     bool current_user_is_owner) {
   if (status != DeviceSettingsService::OWNERSHIP_NONE) {
     // The device is already owned. No need for auto-enrollment checks.
     VLOG(1) << "CheckForAutoEnrollment: device already owned";
     return;
   }
 
   // Kick off the auto-enrollment client.
   if (auto_enrollment_client_.get()) {
     // They client might have been started after the EULA screen, but we made
     // it to the login screen before it finished. In that case let the current
     // client proceed.
     //
     // CheckForAutoEnrollment() is also called when we reach the sign-in screen,
     // because that's what happens after an auto-update.
     VLOG(1) << "CheckForAutoEnrollment: client already started";
 
     // If the client already started and already finished too, pass the decision
     // to the |sign_in_controller_| now.
     if (auto_enrollment_client_->should_auto_enroll())
       ForceAutoEnrollment();
   } else {
     VLOG(1) << "CheckForAutoEnrollment: starting auto-enrollment client";
     auto_enrollment_client_.reset(policy::AutoEnrollmentClient::Create(
-        base::Bind(&BaseLoginDisplayHost::OnAutoEnrollmentClientDone,
+        base::Bind(&LoginDisplayHostImpl::OnAutoEnrollmentClientDone,
                    base::Unretained(this))));
     auto_enrollment_client_->Start();
   }
 }
 
-void BaseLoginDisplayHost::OnAutoEnrollmentClientDone() {
+void LoginDisplayHostImpl::OnAutoEnrollmentClientDone() {
   bool auto_enroll = auto_enrollment_client_->should_auto_enroll();
   VLOG(1) << "OnAutoEnrollmentClientDone, decision is " << auto_enroll;
 
   if (auto_enroll)
     ForceAutoEnrollment();
 }
 
-void BaseLoginDisplayHost::ForceAutoEnrollment() {
+void LoginDisplayHostImpl::ForceAutoEnrollment() {
   if (sign_in_controller_.get())
     sign_in_controller_->DoAutoEnrollment();
 }
 
 // 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,
                      const gfx::Size& size) {
   if (browser_shutdown::IsTryingToQuit())
     return;
@@ skipping 125 matching lines @@
   VLOG(1) << "Initial time zone: " << timezone_name;
   // Apply locale customizations only once to preserve whatever locale
   // user has changed to during OOBE.
   if (!timezone_name.empty()) {
     chromeos::system::TimezoneSettings::GetInstance()->SetTimezoneFromID(
         UTF8ToUTF16(timezone_name));
   }
 }
 
 }  // namespace chromeos