cros: Show dircryto migration banner

chrome/browser/chromeos/login/screens/user_selection_screen.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/screens/user_selection_screen.h"
 
 #include <stddef.h>
 
 #include <utility>
 
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_factory.h"
 #include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_storage.h"
 #include "chrome/browser/chromeos/login/reauth_stats.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/chromeos/login/ui/views/user_board_view.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/multi_profile_user_controller.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/signin/easy_unlock_service.h"
 #include "chrome/browser/ui/webui/chromeos/login/l10n_util.h"
 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
+#include "chrome/grit/generated_resources.h"
+#include "chromeos/cryptohome/cryptohome_parameters.h"
+#include "chromeos/dbus/cryptohome_client.h"
+#include "chromeos/dbus/dbus_method_call_status.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
 #include "components/prefs/pref_service.h"
 #include "components/proximity_auth/screenlock_bridge.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/known_user.h"
 #include "components/user_manager/user_manager.h"
 #include "components/user_manager/user_type.h"
+#include "ui/base/l10n/l10n_util.h"
 #include "ui/base/user_activity/user_activity_detector.h"
 
 namespace chromeos {
 
 namespace {
 
 // User dictionary keys.
 const char kKeyUsername[] = "username";
 const char kKeyGaiaID[] = "gaiaId";
 const char kKeyDisplayName[] = "displayName";
@@ skipping 94 matching lines @@
   quick_unlock::QuickUnlockStorage* quick_unlock_storage =
       quick_unlock::QuickUnlockFactory::GetForUser(user);
   if (!quick_unlock_storage)
     return false;
 
   return quick_unlock_storage->IsFingerprintAuthenticationAvailable();
 }
 
 }  // namespace
 
+// Helper class to call cryptohome to check whether a user needs dircrypto
+// migration. The check results are cached to limit calls to cryptohome.
+class UserSelectionScreen::DircryptoMigrationChecker {
+ public:
+  explicit DircryptoMigrationChecker(UserSelectionScreen* owner)
+      : owner_(owner), weak_ptr_factory_(this) {}
+  ~DircryptoMigrationChecker() = default;
+
+  // Start to check whether the given user needs dircrypto migration.
+  void Check(const AccountId& account_id) {
+    focused_user_ = account_id;
+
+    auto it = needs_dircrypto_migration_cache_.find(account_id);
+    if (it != needs_dircrypto_migration_cache_.end()) {
+      UpdateUI(account_id, it->second);
+      return;
+    }
+
+    DBusThreadManager::Get()
+        ->GetCryptohomeClient()
+        ->WaitForServiceToBeAvailable(
+            base::Bind(&DircryptoMigrationChecker::RunCryptohomeCheck,
+                       weak_ptr_factory_.GetWeakPtr(), account_id));
+  }
+
+ private:
+  // WaitForServiceToBeAvailable callback to invoke NeedsDircryptoMigration when
+  // cryptohome service is available.
+  void RunCryptohomeCheck(const AccountId& account_id, bool service_is_ready) {
+    if (!service_is_ready) {
+      LOG(ERROR) << "Cryptohome is not available.";
+      return;
+    }
+
+    const cryptohome::Identification cryptohome_id(account_id);
+    DBusThreadManager::Get()->GetCryptohomeClient()->NeedsDircryptoMigration(
+        cryptohome_id,
+        base::Bind(&DircryptoMigrationChecker::
+                       OnCryptohomeNeedsDircryptoMigrationCallback,
+                   weak_ptr_factory_.GetWeakPtr(), account_id));
+  }
+
+  // Callback invoked when NeedsDircryptoMigration call is finished.
+  void OnCryptohomeNeedsDircryptoMigrationCallback(
+      const AccountId& account_id,
+      DBusMethodCallStatus call_status,
+      bool needs_migration) {
+    if (call_status != DBUS_METHOD_CALL_SUCCESS) {
+      LOG(ERROR) << "Failed to call cryptohome NeedsDircryptoMigration.";
+      return;
+    }
+
+    needs_dircrypto_migration_cache_[account_id] = needs_migration;
+    UpdateUI(account_id, needs_migration);
+  }
+
+  // Update UI for the given user when the check result is available.
+  void UpdateUI(const AccountId& account_id, bool needs_migration) {
+    // Bail if the user is not the currently focused.
+    if (account_id != focused_user_)
+      return;
+
+    owner_->ShowBannerMessage(
+        needs_migration ? l10n_util::GetStringUTF16(
+                              IDS_LOGIN_NEEDS_DIRCRYPTO_MIGRATION_BANNER)
+                        : base::string16());
+  }
+
+  UserSelectionScreen* const owner_;
+  AccountId focused_user_ = EmptyAccountId();
+
+  // Cached result of NeedsDircryptoMigration cryptohome check. Key is the
+  // account id of users. True value means the user needs dircrypto migration
+  // and false means dircrypto migration is done.
+  std::map<AccountId, bool> needs_dircrypto_migration_cache_;
+
+  base::WeakPtrFactory<DircryptoMigrationChecker> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(DircryptoMigrationChecker);
+};
+
 UserSelectionScreen::UserSelectionScreen(const std::string& display_type)
     : BaseScreen(nullptr, OobeScreen::SCREEN_USER_SELECTION),
       display_type_(display_type),
       weak_factory_(this) {}
 
 UserSelectionScreen::~UserSelectionScreen() {
   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(nullptr);
   ui::UserActivityDetector* activity_detector = ui::UserActivityDetector::Get();
   if (activity_detector && activity_detector->HasObserver(this))
     activity_detector->RemoveObserver(this);
@@ skipping 295 matching lines @@
 
   if (!token_handle_util_.get()) {
     token_handle_util_.reset(new TokenHandleUtil());
   }
 
   if (token_handle_util_->HasToken(account_id)) {
     token_handle_util_->CheckToken(
         account_id, base::Bind(&UserSelectionScreen::OnUserStatusChecked,
                                weak_factory_.GetWeakPtr()));
   }
+
+  // Run dircrypto migration check only on the login screen.
+  if (display_type_ == OobeUI::kLoginDisplay) {
+    if (!dircrypto_migration_checker_) {
+      dircrypto_migration_checker_ =
+          base::MakeUnique<DircryptoMigrationChecker>(this);
+    }
+    dircrypto_migration_checker_->Check(account_id);
+  }
 }
 
 void UserSelectionScreen::OnUserStatusChecked(
     const AccountId& account_id,
     TokenHandleUtil::TokenHandleStatus status) {
   if (status == TokenHandleUtil::INVALID) {
     RecordReauthReason(account_id, ReauthReason::INVALID_TOKEN_HANDLE);
     token_handle_util_->MarkHandleInvalid(account_id);
     SetAuthType(account_id, ONLINE_SIGN_IN, base::string16());
   }
@@ skipping 122 matching lines @@
   // The user profile should exist if and only if this is the lock screen.
   DCHECK_EQ(!!profile, GetScreenType() == LOCK_SCREEN);
 
   if (!profile)
     profile = profile_helper->GetSigninProfile();
 
   return EasyUnlockService::Get(profile);
 }
 
 }  // namespace chromeos