Make supervised user ChromeOS import aware of new password schema.

chrome/browser/chromeos/login/managed/locally_managed_user_creation_screen.cc

 // Copyright (c) 2013 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/managed/locally_managed_user_creation_screen.h"
 
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/rand_util.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/camera_detector.h"
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
 #include "chrome/browser/chromeos/login/managed/managed_user_creation_controller.h"
 #include "chrome/browser/chromeos/login/managed/managed_user_creation_controller_new.h"
 #include "chrome/browser/chromeos/login/managed/managed_user_creation_controller_old.h"
 #include "chrome/browser/chromeos/login/managed/supervised_user_authentication.h"
 #include "chrome/browser/chromeos/login/screens/error_screen.h"
 #include "chrome/browser/chromeos/login/screens/screen_observer.h"
 #include "chrome/browser/chromeos/login/supervised_user_manager.h"
 #include "chrome/browser/chromeos/login/user_image.h"
 #include "chrome/browser/chromeos/login/user_image_manager.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
+#include "chrome/browser/managed_mode/managed_user_constants.h"
+#include "chrome/browser/managed_mode/managed_user_shared_settings_service.h"
+#include "chrome/browser/managed_mode/managed_user_shared_settings_service_factory.h"
 #include "chrome/browser/managed_mode/managed_user_sync_service.h"
 #include "chrome/browser/managed_mode/managed_user_sync_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chromeos/network/network_state.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/generated_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/image/image_skia.h"
 
@@ skipping 185 matching lines @@
   DCHECK(controller_.get());
   DCHECK(existing_users_.get());
   VLOG(1) << "Importing user " << user_id;
   base::DictionaryValue* user_info;
   if (!existing_users_->GetDictionary(user_id, &user_info)) {
     LOG(ERROR) << "Can not import non-existing user " << user_id;
     return;
   }
   base::string16 display_name;
   std::string master_key;
+  std::string signature_key;
+  std::string encryption_key;
   std::string avatar;
   bool exists;
   int avatar_index = ManagedUserCreationController::kDummyAvatarIndex;
   user_info->GetString(ManagedUserSyncService::kName, &display_name);
   user_info->GetString(ManagedUserSyncService::kMasterKey, &master_key);
+  user_info->GetString(ManagedUserSyncService::kPasswordSignatureKey,
+                       &signature_key);
+  user_info->GetString(ManagedUserSyncService::kPasswordEncryptionKey,
+                       &encryption_key);
   user_info->GetString(ManagedUserSyncService::kChromeOsAvatar, &avatar);
   user_info->GetBoolean(kUserExists, &exists);
 
   // We should not get here with existing user selected, so just display error.
   if (exists) {
     actor_->ShowErrorPage(
         l10n_util::GetStringUTF16(
             IDS_CREATE_LOCALLY_MANAGED_USER_GENERIC_ERROR_TITLE),
         l10n_util::GetStringUTF16(
             IDS_CREATE_LOCALLY_MANAGED_USER_GENERIC_ERROR),
         l10n_util::GetStringUTF16(
             IDS_CREATE_LOCALLY_MANAGED_USER_GENERIC_ERROR_BUTTON));
     return;
   }
 
   ManagedUserSyncService::GetAvatarIndex(avatar, &avatar_index);
 
-  controller_->StartImport(display_name,
-                           std::string(),
-                           avatar_index,
-                           user_id,
-                           master_key);
+  const base::DictionaryValue* password_data = NULL;
+  ManagedUserSharedSettingsService* shared_settings_service =
+      ManagedUserSharedSettingsServiceFactory::GetForBrowserContext(
+          controller_->GetManagerProfile());
+  const base::Value* value = shared_settings_service->GetValue(
+      user_id, managed_users::kChromeOSPasswordData);
+
+  bool password_right_here = value && value->GetAsDictionary(&password_data) &&

[Nikita (slow), 2014/04/03 09:13:08]

nit: rename password_right_here to have_password

+                             !password_data->empty();
+
+  if (password_right_here) {
+    controller_->StartImport(display_name,
+                             avatar_index,
+                             user_id,
+                             master_key,
+                             password_data,
+                             encryption_key,
+                             signature_key);
+  } else {
+    NOTREACHED() << " Oops, no password";
+  }
 }
 
 // TODO(antrim): Code duplication with previous method will be removed once
 // password sync is implemented.
 void LocallyManagedUserCreationScreen::ImportManagedUserWithPassword(
     const std::string& user_id,
     const std::string& password) {
   DCHECK(controller_.get());
   DCHECK(existing_users_.get());
   VLOG(1) << "Importing user " << user_id;
@@ skipping 230 matching lines @@
       ui_copy->SetBoolean(kUserExists, true);
       local_copy->SetString(kUserConflict, kUserConflictImported);
       ui_copy->SetString(kUserConflict, kUserConflictImported);
     } else if (supervised_user_manager->FindByDisplayName(display_name)) {
       local_copy->SetBoolean(kUserExists, true);
       ui_copy->SetBoolean(kUserExists, true);
       local_copy->SetString(kUserConflict, kUserConflictName);
       ui_copy->SetString(kUserConflict, kUserConflictName);
     }
     ui_copy->SetString(ManagedUserSyncService::kName, display_name);
-    // TODO(antrim): For now mark all users as having no password.
-    ui_copy->SetBoolean(kUserNeedPassword, true);
+
+    std::string signature_key;
+    bool has_password =

[Nikita (slow), 2014/04/03 09:13:08]

nit: Not quite clear why variable is called has_password if you check for
signature key.

+        local_copy->GetString(ManagedUserSyncService::kPasswordSignatureKey,
+                              &signature_key) &&
+        !signature_key.empty();
+
+    ui_copy->SetBoolean(kUserNeedPassword, !has_password);
     ui_copy->SetString("id", it.key());
 
     existing_users_->Set(it.key(), local_copy);
     ui_users->Append(ui_copy);
   }
   actor_->ShowExistingManagedUsers(ui_users.get());
 }
 
 void LocallyManagedUserCreationScreen::OnPhotoTaken(
     const std::string& raw_data) {
@@ skipping 36 matching lines @@
     selected_image_ = User::kExternalImageIndex;
   } else {
     NOTREACHED() << "Unexpected image type: " << image_type;
   }
 }
 
 void LocallyManagedUserCreationScreen::OnImageAccepted() {
 }
 
 }  // namespace chromeos