cros: Implement cryptohome backend for pin.

chrome/browser/chromeos/extensions/quick_unlock_private/quick_unlock_private_api.cc

 // Copyright 2016 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/extensions/quick_unlock_private/quick_unlock_private_api.h"
 
 #include "base/memory/ptr_util.h"
+#include "chrome/browser/chromeos/login/quick_unlock/pin_backend.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/profiles/profile_helper.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/login/auth/extended_authenticator.h"
 #include "chromeos/login/auth/user_context.h"
 #include "components/prefs/pref_service.h"
 #include "extensions/browser/event_router.h"
 
 namespace extensions {
@@ skipping 20 matching lines @@
     "At most one quick unlock mode can be active.";
 // PINs greater in length than |kMinLengthForWeakPin| will be checked for
 // weakness.
 const int kMinLengthForNonWeakPin = 2;
 // A list of the most commmonly used PINs, whose digits are not all the same,
 // increasing or decreasing. This list is taken from
 // www.datagenetics.com/blog/september32012/.
 const char* kMostCommonPins[] = {"1212", "1004", "2000", "6969",
                                  "1122", "1313", "2001", "1010"};
 
+using ActiveModeCallback = base::Callback<void(const QuickUnlockModeList&)>;
+
 // Returns the active set of quick unlock modes.
-QuickUnlockModeList ComputeActiveModes(Profile* profile) {
-  QuickUnlockModeList modes;
-
-  chromeos::quick_unlock::QuickUnlockStorage* quick_unlock_storage =
-      chromeos::quick_unlock::QuickUnlockFactory::GetForProfile(profile);
-  if (quick_unlock_storage && quick_unlock_storage->pin_storage()->IsPinSet())
-    modes.push_back(quick_unlock_private::QUICK_UNLOCK_MODE_PIN);
-
-  return modes;
+void ComputeActiveModes(Profile* profile, const ActiveModeCallback& result) {
+  user_manager::User* user =
+      chromeos::ProfileHelper::Get()->GetUserByProfile(profile);
+  chromeos::quick_unlock::PinBackend::IsSet(
+      user->GetAccountId(),
+      base::Bind(
+          [](const ActiveModeCallback& result, bool is_set) {
+            QuickUnlockModeList modes;
+            if (is_set)
+              modes.push_back(quick_unlock_private::QUICK_UNLOCK_MODE_PIN);
+            result.Run(modes);
+          },
+          result));
 }
 
 // Returns true if |a| and |b| contain the same elements. The elements do not
 // need to be in the same order.
 bool AreModesEqual(const QuickUnlockModeList& a, const QuickUnlockModeList& b) {
   if (a.size() != b.size())
     return false;
 
   // This is a slow comparison algorithm, but the number of entries in |a| and
   // |b| will always be very low (0-3 items) so it doesn't matter.
@@ skipping 122 matching lines @@
 
 QuickUnlockPrivateGetActiveModesFunction::
     QuickUnlockPrivateGetActiveModesFunction()
     : chrome_details_(this) {}
 
 QuickUnlockPrivateGetActiveModesFunction::
     ~QuickUnlockPrivateGetActiveModesFunction() {}
 
 ExtensionFunction::ResponseAction
 QuickUnlockPrivateGetActiveModesFunction::Run() {
-  const QuickUnlockModeList modes =
-      ComputeActiveModes(chrome_details_.GetProfile());
-  return RespondNow(ArgumentList(GetActiveModes::Results::Create(modes)));
+  ComputeActiveModes(
+      chrome_details_.GetProfile(),
+      base::Bind(&QuickUnlockPrivateGetActiveModesFunction::OnGetActiveModes,
+                 this));
+
+  return RespondLater();
+}
+
+void QuickUnlockPrivateGetActiveModesFunction::OnGetActiveModes(
+    const std::vector<api::quick_unlock_private::QuickUnlockMode>& modes) {
+  Respond(ArgumentList(GetActiveModes::Results::Create(modes)));
 }
 
 // quickUnlockPrivate.checkCredential
 
 QuickUnlockPrivateCheckCredentialFunction::
     QuickUnlockPrivateCheckCredentialFunction() {}
 
 QuickUnlockPrivateCheckCredentialFunction::
     ~QuickUnlockPrivateCheckCredentialFunction() {}
 
@@ skipping 142 matching lines @@
 }
 
 void QuickUnlockPrivateSetModesFunction::OnAuthFailure(
     const chromeos::AuthFailure& error) {
   Respond(ArgumentList(SetModes::Results::Create(false)));
   Release();  // Balanced in Run().
 }
 
 void QuickUnlockPrivateSetModesFunction::OnAuthSuccess(
     const chromeos::UserContext& user_context) {
-  const QuickUnlockModeList initial_modes =
-      ComputeActiveModes(chrome_details_.GetProfile());
-  ApplyModeChange();
-  const QuickUnlockModeList updated_modes =
-      ComputeActiveModes(chrome_details_.GetProfile());
+  ComputeActiveModes(
+      chrome_details_.GetProfile(),
+      base::Bind(
+          &QuickUnlockPrivateSetModesFunction::OnGetActiveModesAfterAuthSuccess,
+          base::Unretained(this), user_context));
+}
 
+void QuickUnlockPrivateSetModesFunction::OnGetActiveModesAfterAuthSuccess(
+    const chromeos::UserContext& user_context,
+    const std::vector<api::quick_unlock_private::QuickUnlockMode>&
+        initial_modes) {
+  std::vector<QuickUnlockMode> updated_modes = ApplyModeChange(user_context);
   if (!AreModesEqual(initial_modes, updated_modes))
     FireEvent(updated_modes);
 
   Respond(ArgumentList(SetModes::Results::Create(true)));
   Release();  // Balanced in Run().
 }
 
-void QuickUnlockPrivateSetModesFunction::ApplyModeChange() {
+std::vector<QuickUnlockMode>
+QuickUnlockPrivateSetModesFunction::ApplyModeChange(
+    const chromeos::UserContext& user_context) {
   // This function is setup so it is easy to add another quick unlock mode while
   // following all of the invariants, which are:
   //
   // 1: If an unlock type is not specified, it should be deactivated.
   // 2: If a credential for an unlock type is empty, it should not be touched.
   // 3: Otherwise, the credential should be set to the new value.
 
+  std::vector<QuickUnlockMode> newly_active_modes;
+
   bool update_pin = true;
   std::string pin_credential;
 
   // Compute needed changes.
   for (size_t i = 0; i < params_->modes.size(); ++i) {
     const QuickUnlockMode mode = params_->modes[i];
     const std::string& credential = params_->credentials[i];
 
     if (mode == quick_unlock_private::QUICK_UNLOCK_MODE_PIN) {
       update_pin = !credential.empty();
       pin_credential = credential;
+      newly_active_modes.push_back(QuickUnlockMode::QUICK_UNLOCK_MODE_PIN);
     }
   }
 
   // Apply changes.
   if (update_pin) {
-    Profile* profile = chrome_details_.GetProfile();
-    chromeos::quick_unlock::QuickUnlockStorage* quick_unlock_storage =
-        chromeos::quick_unlock::QuickUnlockFactory::GetForProfile(profile);
+    if (pin_credential.empty()) {
+      chromeos::quick_unlock::PinBackend::Remove(user_context);
+    } else {
+      chromeos::quick_unlock::PinBackend::Set(user_context, pin_credential);
 
-    if (pin_credential.empty()) {
-      quick_unlock_storage->pin_storage()->RemovePin();
-    } else {
-      quick_unlock_storage->pin_storage()->SetPin(pin_credential);
+      Profile* profile = chrome_details_.GetProfile();
+      chromeos::quick_unlock::QuickUnlockStorage* quick_unlock_storage =
+          chromeos::quick_unlock::QuickUnlockFactory::GetForProfile(profile);
       quick_unlock_storage->MarkStrongAuth();
     }
   }
+
+  return newly_active_modes;

[achuithb, 2017/05/13 01:01:57]

So that can only be empty or have the QUICK_UNLOCK_MODE_PIN?

[jdufault, 2017/06/06 18:17:05]

Yep.

 }
 
 // Triggers a quickUnlockPrivate.onActiveModesChanged change event.
 void QuickUnlockPrivateSetModesFunction::FireEvent(
     const QuickUnlockModeList& modes) {
   // Allow unit tests to override how events are raised/handled.
   if (!modes_changed_handler_.is_null()) {
     modes_changed_handler_.Run(modes);
     return;
   }
 
   std::unique_ptr<base::ListValue> args = OnActiveModesChanged::Create(modes);
   std::unique_ptr<Event> event(
       new Event(events::QUICK_UNLOCK_PRIVATE_ON_ACTIVE_MODES_CHANGED,
                 OnActiveModesChanged::kEventName, std::move(args)));
   EventRouter::Get(browser_context())->BroadcastEvent(std::move(event));
 }
 
 }  // namespace extensions