[Easy signin] Add method to get user info to easyUnlockPrivate

chrome/browser/signin/easy_unlock_service_signin_chromeos.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/signin/easy_unlock_service_signin_chromeos.h"
 
 #include "base/bind.h"
-#include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_key_manager.h"
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
-#include "chromeos/chromeos_switches.h"
 #include "chromeos/login/auth/user_context.h"
 
 namespace {
 
 // The maximum allowed backoff interval when waiting for cryptohome to start.
 size_t kMaxCryptohomeBackoffIntervalMs = 10000u;
 
 // If the data load fails, the initial interval after which the load will be
 // retried. Further intervals will exponentially increas by factor 2.
 size_t kInitialCryptohomeBackoffIntervalMs = 200u;
@@ skipping 58 matching lines @@
 
 EasyUnlockServiceSignin::UserData::UserData()
     : state(EasyUnlockServiceSignin::USER_DATA_STATE_INITIAL) {
 }
 
 EasyUnlockServiceSignin::UserData::~UserData() {}
 
 EasyUnlockServiceSignin::EasyUnlockServiceSignin(Profile* profile)
     : EasyUnlockService(profile),
       allow_cryptohome_backoff_(true),
+      service_active_(false),
       weak_ptr_factory_(this) {
 }
 
 EasyUnlockServiceSignin::~EasyUnlockServiceSignin() {
-  STLDeleteContainerPairSecondPointers(user_data_.begin(), user_data_.end());
 }
 
 EasyUnlockService::Type EasyUnlockServiceSignin::GetType() const {
   return EasyUnlockService::TYPE_SIGNIN;
 }
 
 std::string EasyUnlockServiceSignin::GetUserEmail() const {
   return user_id_;
 }
 
@@ skipping 46 matching lines @@
 std::string EasyUnlockServiceSignin::GetChallenge() const {
   const UserData* data = FindLoadedDataForCurrentUser();
   // TODO(xiyuan): Use correct remote device instead of hard coded first one.
   size_t device_index = 0;
   if (!data || data->devices.size() <= device_index)
     return std::string();
   return data->devices[device_index].challenge;
 }
 
 void EasyUnlockServiceSignin::InitializeInternal() {
+  if (chromeos::LoginState::Get()->IsUserLoggedIn())
+    return;
+
+  service_active_ = true;
+
+  chromeos::LoginState::Get()->AddObserver(this);
+  ScreenlockBridge* screenlock_bridge = ScreenlockBridge::Get();
+  screenlock_bridge->AddObserver(this);
+  if (!screenlock_bridge->focused_user_id().empty())
+    OnFocusedUserChanged(screenlock_bridge->focused_user_id());
+}
+
+void EasyUnlockServiceSignin::ShutdownInternal() {
+  if (!service_active_)
+    return;
+  service_active_ = false;
+
+  weak_ptr_factory_.InvalidateWeakPtrs();
+  ScreenlockBridge::Get()->RemoveObserver(this);
+  chromeos::LoginState::Get()->RemoveObserver(this);
+  STLDeleteContainerPairSecondPointers(user_data_.begin(), user_data_.end());
+  user_data_.clear();
 }
 
 bool EasyUnlockServiceSignin::IsAllowedInternal() {
-  return !user_id_.empty() &&
-         FindLoadedDataForCurrentUser() &&
-         CommandLine::ForCurrentProcess()->HasSwitch(
-             chromeos::switches::kEnableEasySignin);
+  return service_active_ &&
+         !user_id_.empty() &&
+         !chromeos::LoginState::Get()->IsUserLoggedIn();
+}
+
+void EasyUnlockServiceSignin::OnScreenDidLock() {
+}
+
+void EasyUnlockServiceSignin::OnScreenDidUnlock() {
+}
+
+void EasyUnlockServiceSignin::OnFocusedUserChanged(const std::string& user_id) {
+  if (user_id_ == user_id)
+    return;
+
+  // Setting or clearing the user_id may changed |IsAllowed| value, so in these
+  // cases update the app state. Otherwise, it's enough to notify the app the
+  // user data has been updated.
+  bool should_update_app_state = user_id_.empty() != user_id.empty();
+  user_id_ = user_id;
+
+  ResetScreenlockStateHandler();
+
+  if (should_update_app_state) {
+    UpdateAppState();
+  } else {
+    NotifyUserUpdated();
+  }
+
+  LoadCurrentUserDataIfNeeded();
+}
+
+void EasyUnlockServiceSignin::LoggedInStateChanged() {
+  if (!chromeos::LoginState::Get()->IsUserLoggedIn())
+    return;
+  UnloadApp();
+  Shutdown();
 }
 
 void EasyUnlockServiceSignin::LoadCurrentUserDataIfNeeded() {
-  if (user_id_.empty() ||
-      !CommandLine::ForCurrentProcess()->HasSwitch(
-             chromeos::switches::kEnableEasySignin))
+  if (user_id_.empty() || !service_active_)
     return;
 
   std::map<std::string, UserData*>::iterator it = user_data_.find(user_id_);
   if (it == user_data_.end())
     user_data_.insert(std::make_pair(user_id_, new UserData()));
 
   UserData* data = user_data_[user_id_];
 
   if (data->state != USER_DATA_STATE_INITIAL)
     return;
@@ skipping 13 matching lines @@
     const chromeos::EasyUnlockDeviceKeyDataList& devices) {
   allow_cryptohome_backoff_ = false;
 
   UserData* data = user_data_[user_id_];
   data->state = USER_DATA_STATE_LOADED;
   if (success) {
     data->devices = devices;
     chromeos::EasyUnlockKeyManager::DeviceDataListToRemoteDeviceList(
         user_id, devices, &data->remote_devices_value);
   }
+
+  // If the fetched data belongs to the currently focused user, notify the app
+  // that it has to refresh it's user data.
+  if (user_id == user_id_)
+    NotifyUserUpdated();
 }
 
 const EasyUnlockServiceSignin::UserData*
     EasyUnlockServiceSignin::FindLoadedDataForCurrentUser() const {
   if (user_id_.empty())
     return NULL;
+
   std::map<std::string, UserData*>::const_iterator it =
       user_data_.find(user_id_);
   if (it == user_data_.end())
     return NULL;
   if (it->second->state != USER_DATA_STATE_LOADED)
     return NULL;
   return it->second;
 }