[Easy Unlock] Update handling of the trial easy unlock/signin run

chrome/browser/signin/easy_unlock_service.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.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/prefs/pref_registry_simple.h"
@@ skipping 169 matching lines @@
       new base::DictionaryValue(),
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterBooleanPref(
       prefs::kEasyUnlockAllowed,
       true,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // static
 void EasyUnlockService::RegisterPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterDictionaryPref(prefs::kEasyUnlockFirstRunComplete);
   registry->RegisterDictionaryPref(prefs::kEasyUnlockHardlockState);
 }
 
 // static
-void EasyUnlockService::RemoveHardlockStateForUser(const std::string& user_id) {
+void EasyUnlockService::ResetLocalStateForUser(const std::string& user_id) {
   DCHECK(!user_id.empty());
 
   PrefService* local_state = GetLocalState();
   if (!local_state)
     return;
 
-  DictionaryPrefUpdate update(local_state, prefs::kEasyUnlockHardlockState);
-  update->RemoveWithoutPathExpansion(user_id, NULL);
+  DictionaryPrefUpdate hardlock_update(local_state,
+                                       prefs::kEasyUnlockHardlockState);
+  hardlock_update->RemoveWithoutPathExpansion(user_id, NULL);
+
+  DictionaryPrefUpdate first_run_update(local_state,
+                                        prefs::kEasyUnlockFirstRunComplete);
+  first_run_update->RemoveWithoutPathExpansion(user_id, NULL);
 }
 
 bool EasyUnlockService::IsAllowed() {
   if (shut_down_)
     return false;
 
   if (!IsAllowedInternal())
     return false;
 
 #if defined(OS_CHROMEOS)
@@ skipping 40 matching lines @@
     return;
   if (GetScreenlockStateHandler())
     screenlock_state_handler_->MaybeShowHardlockUI();
 }
 
 EasyUnlockScreenlockStateHandler*
     EasyUnlockService::GetScreenlockStateHandler() {
   if (!IsAllowed())
     return NULL;
   if (!screenlock_state_handler_) {
+    std::string user_id = GetUserEmail();
+    if (GetType() == TYPE_REGULAR)
+      MaybeMigrateShowTutorialPref(user_id);
     screenlock_state_handler_.reset(new EasyUnlockScreenlockStateHandler(
-        GetUserEmail(),
+        user_id,
         GetHardlockState(),
-        GetType() == TYPE_REGULAR ? profile_->GetPrefs() : NULL,
+        GetLocalState(),
         ScreenlockBridge::Get()));
   }
   return screenlock_state_handler_.get();
 }
 
 bool EasyUnlockService::UpdateScreenlockState(
     EasyUnlockScreenlockStateHandler::State state) {
   EasyUnlockScreenlockStateHandler* handler = GetScreenlockStateHandler();
   if (!handler)
     return false;
@@ skipping 237 matching lines @@
   if (!local_state)
     return;
 
   DictionaryPrefUpdate update(local_state, prefs::kEasyUnlockHardlockState);
   update->SetIntegerWithoutPathExpansion(user_id, static_cast<int>(state));
 
   if (GetUserEmail() == user_id)
     SetScreenlockHardlockedState(state);
 }
 
+void EasyUnlockService::MaybeMigrateShowTutorialPref(
+    const std::string& user_id) {
+  DCHECK_EQ(TYPE_REGULAR, GetType());
+
+  PrefService* local_state = GetLocalState();
+  // The default value for kEasyUnlockShowTutorial pref is true.
+  if (user_id.empty() || !local_state ||
+      profile_->GetPrefs()->GetBoolean(prefs::kEasyUnlockShowTutorial))
+    return;
+  profile_->GetPrefs()->SetBoolean(prefs::kEasyUnlockShowTutorial, true);

[xiyuan, 2014/10/08 19:57:25]

nit: How about ClearPref() here?

[tbarzic, 2014/10/09 02:43:24]

Done.

+
+  DictionaryPrefUpdate update(local_state, prefs::kEasyUnlockFirstRunComplete);
+  update->SetBooleanWithoutPathExpansion(user_id, true);
+}
+
 #if defined(OS_CHROMEOS)
 void EasyUnlockService::OnCryptohomeKeysFetchedForChecking(
     const std::string& user_id,
     const std::set<std::string> paired_devices,
     bool success,
     const chromeos::EasyUnlockDeviceKeyDataList& key_data_list) {
   DCHECK(!user_id.empty() && !paired_devices.empty());
 
   if (!success) {
     SetHardlockStateForUser(user_id,
                             EasyUnlockScreenlockStateHandler::NO_PAIRING);
     return;
   }
 
   std::set<std::string> devices_in_cryptohome;
   for (const auto& device_key_data : key_data_list)
     devices_in_cryptohome.insert(device_key_data.public_key);
 
   if (paired_devices != devices_in_cryptohome) {
     SetHardlockStateForUser(user_id,
                             EasyUnlockScreenlockStateHandler::PAIRING_CHANGED);
   }
 }
 #endif