src/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/lazy_instance.h"
  11 #include "base/memory/linked_ptr.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "base/values.h"
  14 #include "chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_crypto_delegate.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/browser/signin/easy_unlock_screenlock_state_handler.h"
  17 #include "chrome/browser/signin/easy_unlock_service.h"
  18 #include "chrome/common/extensions/api/easy_unlock_private.h"
  19 #include "chrome/grit/generated_resources.h"
  20 #include "components/proximity_auth/bluetooth_util.h"
  21 #include "content/public/browser/browser_thread.h"
  22 #include "extensions/browser/browser_context_keyed_api_factory.h"
  23 #include "ui/base/l10n/l10n_util.h"
  24
  25 #if defined(OS_CHROMEOS)
  26 #include "chrome/browser/chromeos/chromeos_utils.h"
  27 #include "components/user_manager/user.h"
  28 #include "components/user_manager/user_manager.h"
  29 #endif
  30
  31 namespace extensions {
  32 namespace api {
  33
  34 namespace {
  35
  36 static base::LazyInstance<BrowserContextKeyedAPIFactory<EasyUnlockPrivateAPI> >
  37     g_factory = LAZY_INSTANCE_INITIALIZER;
  38
  39 // Utility method for getting the API's crypto delegate.
  40 EasyUnlockPrivateCryptoDelegate* GetCryptoDelegate(
  41     content::BrowserContext* context) {
  42   return BrowserContextKeyedAPIFactory<EasyUnlockPrivateAPI>::Get(context)
  43              ->crypto_delegate();
  44 }
  45
  46 EasyUnlockScreenlockStateHandler::State ToScreenlockStateHandlerState(
  47     easy_unlock_private::State state) {
  48   switch (state) {
  49     case easy_unlock_private::STATE_NO_BLUETOOTH:
  50       return EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH;
  51     case easy_unlock_private::STATE_BLUETOOTH_CONNECTING:
  52       return EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING;
  53     case easy_unlock_private::STATE_NO_PHONE:
  54       return EasyUnlockScreenlockStateHandler::STATE_NO_PHONE;
  55     case easy_unlock_private::STATE_PHONE_NOT_AUTHENTICATED:
  56       return EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_AUTHENTICATED;
  57     case easy_unlock_private::STATE_PHONE_LOCKED:
  58       return EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED;
  59     case easy_unlock_private::STATE_PHONE_UNLOCKABLE:
  60       return EasyUnlockScreenlockStateHandler::STATE_PHONE_UNLOCKABLE;
  61     case easy_unlock_private::STATE_PHONE_NOT_NEARBY:
  62       return EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_NEARBY;
  63     case easy_unlock_private::STATE_PHONE_UNSUPPORTED:
  64       return EasyUnlockScreenlockStateHandler::STATE_PHONE_UNSUPPORTED;
  65     case easy_unlock_private::STATE_AUTHENTICATED:
  66       return EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED;
  67     default:
  68       return EasyUnlockScreenlockStateHandler::STATE_INACTIVE;
  69   }
  70 }
  71
  72 }  // namespace
  73
  74 // static
  75 BrowserContextKeyedAPIFactory<EasyUnlockPrivateAPI>*
  76     EasyUnlockPrivateAPI::GetFactoryInstance() {
  77   return g_factory.Pointer();
  78 }
  79
  80 EasyUnlockPrivateAPI::EasyUnlockPrivateAPI(content::BrowserContext* context)
  81     : crypto_delegate_(EasyUnlockPrivateCryptoDelegate::Create()) {
  82 }
  83
  84 EasyUnlockPrivateAPI::~EasyUnlockPrivateAPI() {}
  85
  86 EasyUnlockPrivateGetStringsFunction::EasyUnlockPrivateGetStringsFunction() {
  87 }
  88 EasyUnlockPrivateGetStringsFunction::~EasyUnlockPrivateGetStringsFunction() {
  89 }
  90
  91 bool EasyUnlockPrivateGetStringsFunction::RunSync() {
  92   scoped_ptr<base::DictionaryValue> strings(new base::DictionaryValue);
  93
  94 #if defined(OS_CHROMEOS)
  95   const base::string16 device_type = chromeos::GetChromeDeviceType();
  96 #else
  97   // TODO(isherman): Set an appropriate device name for non-ChromeOS devices.
  98   const base::string16 device_type = base::ASCIIToUTF16("Chromeschnozzle");
  99 #endif  // defined(OS_CHROMEOS)
 100
 101 #if defined(OS_CHROMEOS)
 102   const user_manager::UserManager* manager = user_manager::UserManager::Get();
 103   const user_manager::User* user = manager ? manager->GetActiveUser() : NULL;
 104   const std::string user_email_utf8 =
 105       user ? user->display_email() : std::string();
 106   const base::string16 user_email = base::UTF8ToUTF16(user_email_utf8);
 107 #else
 108   // TODO(isherman): Set an appropriate user display email for non-ChromeOS
 109   // platforms.
 110   const base::string16 user_email = base::UTF8ToUTF16("superman@example.com");
 111 #endif  // defined(OS_CHROMEOS)
 112
 113   // Common strings.
 114   strings->SetString(
 115       "learnMoreLinkTitle",
 116       l10n_util::GetStringUTF16(IDS_EASY_UNLOCK_LEARN_MORE_LINK_TITLE));
 117
 118   // Setup notification strings.
 119   strings->SetString(
 120       "setupNotificationTitle",
 121       l10n_util::GetStringFUTF16(IDS_EASY_UNLOCK_SETUP_NOTIFICATION_TITLE,
 122                                  device_type));
 123   strings->SetString(
 124       "setupNotificationMessage",
 125       l10n_util::GetStringFUTF16(IDS_EASY_UNLOCK_SETUP_NOTIFICATION_MESSAGE,
 126                                  device_type));
 127   strings->SetString(
 128       "setupNotificationButtonTitle",
 129       l10n_util::GetStringUTF16(
 130           IDS_EASY_UNLOCK_SETUP_NOTIFICATION_BUTTON_TITLE));
 131
 132   // Success notification strings.
 133   strings->SetString(
 134       "successNotificationTitle",
 135       l10n_util::GetStringUTF16(IDS_EASY_UNLOCK_SUCCESS_NOTIFICATION_TITLE));
 136   strings->SetString(
 137       "successNotificationMessage",
 138       l10n_util::GetStringFUTF16(IDS_EASY_UNLOCK_SUCCESS_NOTIFICATION_MESSAGE,
 139                                  device_type));
 140
 141   // Chromebook added to Easy Unlock notification strings.
 142   strings->SetString(
 143       "chromebookAddedNotificationTitle",
 144       l10n_util::GetStringUTF16(
 145           IDS_EASY_UNLOCK_CHROMEBOOK_ADDED_NOTIFICATION_TITLE));
 146   strings->SetString(
 147      "chromebookAddedNotificationMessage",
 148      l10n_util::GetStringFUTF16(
 149           IDS_EASY_UNLOCK_CHROMEBOOK_ADDED_NOTIFICATION_MESSAGE,
 150           device_type));
 151
 152   // Setup dialog strings.
 153   // Step 1: Intro.
 154   strings->SetString(
 155       "setupIntroHeaderTitle",
 156       l10n_util::GetStringFUTF16(
 157           IDS_EASY_UNLOCK_SETUP_INTRO_HEADER_TITLE, device_type));
 158   strings->SetString(
 159       "setupIntroHeaderText",
 160       l10n_util::GetStringFUTF16(IDS_EASY_UNLOCK_SETUP_INTRO_HEADER_TEXT,
 161                                  device_type,
 162                                  user_email));
 163   strings->SetString(
 164       "setupIntroFindPhoneButtonLabel",
 165       l10n_util::GetStringUTF16(
 166           IDS_EASY_UNLOCK_SETUP_INTRO_FIND_PHONE_BUTTON_LABEL));
 167   strings->SetString(
 168       "setupIntroFindingPhoneButtonLabel",
 169       l10n_util::GetStringUTF16(
 170           IDS_EASY_UNLOCK_SETUP_INTRO_FINDING_PHONE_BUTTON_LABEL));
 171   strings->SetString(
 172       "setupIntroRetryFindPhoneButtonLabel",
 173       l10n_util::GetStringUTF16(
 174           IDS_EASY_UNLOCK_SETUP_INTRO_RETRY_FIND_PHONE_BUTTON_LABEL));
 175   strings->SetString(
 176       "setupIntroHowIsThisSecureLinkText",
 177       l10n_util::GetStringUTF16(
 178           IDS_EASY_UNLOCK_SETUP_INTRO_HOW_IS_THIS_SECURE_LINK_TEXT));
 179   // Step 2: Found a viable phone.
 180   strings->SetString(
 181       "setupFoundPhoneHeaderTitle",
 182       l10n_util::GetStringFUTF16(
 183           IDS_EASY_UNLOCK_SETUP_FOUND_PHONE_HEADER_TITLE, device_type));
 184   strings->SetString(
 185       "setupFoundPhoneHeaderText",
 186       l10n_util::GetStringFUTF16(
 187           IDS_EASY_UNLOCK_SETUP_FOUND_PHONE_HEADER_TEXT, device_type));
 188   strings->SetString(
 189       "setupFoundPhoneUseThisPhoneButtonLabel",
 190       l10n_util::GetStringUTF16(
 191           IDS_EASY_UNLOCK_SETUP_FOUND_PHONE_USE_THIS_PHONE_BUTTON_LABEL));
 192   strings->SetString(
 193       "setupPairingPhoneFailedButtonLabel",
 194       l10n_util::GetStringUTF16(
 195           IDS_EASY_UNLOCK_SETUP_PAIRING_PHONE_FAILED_BUTTON_LABEL));
 196   // Step 3: Setup completed successfully.
 197   strings->SetString(
 198       "setupCompleteHeaderTitle",
 199       l10n_util::GetStringUTF16(
 200           IDS_EASY_UNLOCK_SETUP_COMPLETE_HEADER_TITLE));
 201   strings->SetString(
 202       "setupCompleteHeaderText",
 203       l10n_util::GetStringUTF16(
 204           IDS_EASY_UNLOCK_SETUP_COMPLETE_HEADER_TEXT));
 205   strings->SetString(
 206       "setupCompleteTryItOutButtonLabel",
 207       l10n_util::GetStringUTF16(
 208           IDS_EASY_UNLOCK_SETUP_COMPLETE_TRY_IT_OUT_BUTTON_LABEL));
 209   strings->SetString(
 210       "setupCompleteSettingsLinkText",
 211       l10n_util::GetStringUTF16(
 212           IDS_EASY_UNLOCK_SETUP_COMPLETE_SETTINGS_LINK_TEXT));
 213
 214   // Error strings.
 215   strings->SetString(
 216       "setupErrorBluetoothUnavailable",
 217       l10n_util::GetStringFUTF16(
 218           IDS_EASY_UNLOCK_SETUP_ERROR_BLUETOOTH_UNAVAILBLE, device_type));
 219   strings->SetString(
 220       "setupErrorOffline",
 221       l10n_util::GetStringFUTF16(
 222           IDS_EASY_UNLOCK_SETUP_ERROR_OFFLINE, device_type));
 223   strings->SetString(
 224       "setupErrorFindingPhone",
 225       l10n_util::GetStringUTF16(IDS_EASY_UNLOCK_SETUP_ERROR_FINDING_PHONE));
 226   strings->SetString(
 227       "setupErrorBluetoothConnectionFailed",
 228       l10n_util::GetStringFUTF16(
 229           IDS_EASY_UNLOCK_SETUP_ERROR_BLUETOOTH_CONNECTION_FAILED,
 230           device_type));
 231   strings->SetString(
 232       "setupErrorConnectionToPhoneTimeout",
 233        l10n_util::GetStringFUTF16(
 234            IDS_EASY_UNLOCK_SETUP_ERROR_CONNECT_TO_PHONE_TIMEOUT,
 235            device_type));
 236   strings->SetString(
 237       "setupErrorSyncPhoneState",
 238        l10n_util::GetStringUTF16(
 239            IDS_EASY_UNLOCK_SETUP_ERROR_SYNC_PHONE_STATE_FAILED));
 240   strings->SetString(
 241       "setupErrorConnectingToPhone",
 242       l10n_util::GetStringFUTF16(
 243           IDS_EASY_UNLOCK_SETUP_ERROR_CONNECTING_TO_PHONE, device_type));
 244
 245   // TODO(isherman): Remove this string once the app has been updated.
 246   strings->SetString("setupIntroHeaderFootnote", base::string16());
 247
 248   SetResult(strings.release());
 249   return true;
 250 }
 251
 252 EasyUnlockPrivatePerformECDHKeyAgreementFunction::
 253 EasyUnlockPrivatePerformECDHKeyAgreementFunction() {}
 254
 255 EasyUnlockPrivatePerformECDHKeyAgreementFunction::
 256 ~EasyUnlockPrivatePerformECDHKeyAgreementFunction() {}
 257
 258 bool EasyUnlockPrivatePerformECDHKeyAgreementFunction::RunAsync() {
 259   scoped_ptr<easy_unlock_private::PerformECDHKeyAgreement::Params> params =
 260       easy_unlock_private::PerformECDHKeyAgreement::Params::Create(*args_);
 261   EXTENSION_FUNCTION_VALIDATE(params);
 262
 263   GetCryptoDelegate(browser_context())->PerformECDHKeyAgreement(
 264       *params,
 265       base::Bind(&EasyUnlockPrivatePerformECDHKeyAgreementFunction::OnData,
 266                  this));
 267   return true;
 268 }
 269
 270 void EasyUnlockPrivatePerformECDHKeyAgreementFunction::OnData(
 271     const std::string& secret_key) {
 272   // TODO(tbarzic): Improve error handling.
 273   if (!secret_key.empty()) {
 274     results_ = easy_unlock_private::PerformECDHKeyAgreement::Results::Create(
 275         secret_key);
 276   }
 277   SendResponse(true);
 278 }
 279
 280 EasyUnlockPrivateGenerateEcP256KeyPairFunction::
 281 EasyUnlockPrivateGenerateEcP256KeyPairFunction() {}
 282
 283 EasyUnlockPrivateGenerateEcP256KeyPairFunction::
 284 ~EasyUnlockPrivateGenerateEcP256KeyPairFunction() {}
 285
 286 bool EasyUnlockPrivateGenerateEcP256KeyPairFunction::RunAsync() {
 287   GetCryptoDelegate(browser_context())->GenerateEcP256KeyPair(
 288       base::Bind(&EasyUnlockPrivateGenerateEcP256KeyPairFunction::OnData,
 289                  this));
 290   return true;
 291 }
 292
 293 void EasyUnlockPrivateGenerateEcP256KeyPairFunction::OnData(
 294     const std::string& private_key,
 295     const std::string& public_key) {
 296   // TODO(tbarzic): Improve error handling.
 297   if (!public_key.empty() && !private_key.empty()) {
 298     results_ = easy_unlock_private::GenerateEcP256KeyPair::Results::Create(
 299         public_key, private_key);
 300   }
 301   SendResponse(true);
 302 }
 303
 304 EasyUnlockPrivateCreateSecureMessageFunction::
 305 EasyUnlockPrivateCreateSecureMessageFunction() {}
 306
 307 EasyUnlockPrivateCreateSecureMessageFunction::
 308 ~EasyUnlockPrivateCreateSecureMessageFunction() {}
 309
 310 bool EasyUnlockPrivateCreateSecureMessageFunction::RunAsync() {
 311   scoped_ptr<easy_unlock_private::CreateSecureMessage::Params> params =
 312       easy_unlock_private::CreateSecureMessage::Params::Create(*args_);
 313   EXTENSION_FUNCTION_VALIDATE(params);
 314
 315   GetCryptoDelegate(browser_context())->CreateSecureMessage(
 316       *params,
 317       base::Bind(&EasyUnlockPrivateCreateSecureMessageFunction::OnData,
 318                  this));
 319   return true;
 320 }
 321
 322 void EasyUnlockPrivateCreateSecureMessageFunction::OnData(
 323     const std::string& message) {
 324   // TODO(tbarzic): Improve error handling.
 325   if (!message.empty()) {
 326     results_ = easy_unlock_private::CreateSecureMessage::Results::Create(
 327         message);
 328   }
 329   SendResponse(true);
 330 }
 331
 332 EasyUnlockPrivateUnwrapSecureMessageFunction::
 333 EasyUnlockPrivateUnwrapSecureMessageFunction() {}
 334
 335 EasyUnlockPrivateUnwrapSecureMessageFunction::
 336 ~EasyUnlockPrivateUnwrapSecureMessageFunction() {}
 337
 338 bool EasyUnlockPrivateUnwrapSecureMessageFunction::RunAsync() {
 339   scoped_ptr<easy_unlock_private::UnwrapSecureMessage::Params> params =
 340       easy_unlock_private::UnwrapSecureMessage::Params::Create(*args_);
 341   EXTENSION_FUNCTION_VALIDATE(params);
 342
 343   GetCryptoDelegate(browser_context())->UnwrapSecureMessage(
 344       *params,
 345       base::Bind(&EasyUnlockPrivateUnwrapSecureMessageFunction::OnData,
 346                  this));
 347   return true;
 348 }
 349
 350 void EasyUnlockPrivateUnwrapSecureMessageFunction::OnData(
 351     const std::string& data) {
 352   // TODO(tbarzic): Improve error handling.
 353   if (!data.empty())
 354     results_ = easy_unlock_private::UnwrapSecureMessage::Results::Create(data);
 355   SendResponse(true);
 356 }
 357
 358 EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::
 359     EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction() {}
 360
 361 EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::
 362     ~EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction() {}
 363
 364 bool EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::RunAsync() {
 365   scoped_ptr<easy_unlock_private::SeekBluetoothDeviceByAddress::Params> params(
 366       easy_unlock_private::SeekBluetoothDeviceByAddress::Params::Create(
 367           *args_));
 368   EXTENSION_FUNCTION_VALIDATE(params.get());
 369
 370   proximity_auth::bluetooth_util::SeekDeviceByAddress(
 371       params->device_address,
 372       base::Bind(
 373           &EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::OnSeekSuccess,
 374           this),
 375       base::Bind(
 376           &EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::OnSeekFailure,
 377           this),
 378       content::BrowserThread::GetBlockingPool());
 379   return true;
 380 }
 381
 382 void EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::OnSeekSuccess() {
 383   SendResponse(true);
 384 }
 385
 386 void EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::OnSeekFailure(
 387     const std::string& error_message) {
 388   SetError(error_message);
 389   SendResponse(false);
 390 }
 391
 392 EasyUnlockPrivateConnectToBluetoothServiceInsecurelyFunction::
 393     EasyUnlockPrivateConnectToBluetoothServiceInsecurelyFunction() {}
 394
 395 EasyUnlockPrivateConnectToBluetoothServiceInsecurelyFunction::
 396     ~EasyUnlockPrivateConnectToBluetoothServiceInsecurelyFunction() {}
 397
 398 void EasyUnlockPrivateConnectToBluetoothServiceInsecurelyFunction::
 399     ConnectToService(device::BluetoothDevice* device,
 400                      const device::BluetoothUUID& uuid) {
 401   proximity_auth::bluetooth_util::ConnectToServiceInsecurely(
 402       device,
 403       uuid,
 404       base::Bind(&EasyUnlockPrivateConnectToBluetoothServiceInsecurelyFunction::
 405                      OnConnect,
 406                  this),
 407       base::Bind(&EasyUnlockPrivateConnectToBluetoothServiceInsecurelyFunction::
 408                      OnConnectError,
 409                  this));
 410 }
 411
 412 EasyUnlockPrivateUpdateScreenlockStateFunction::
 413     EasyUnlockPrivateUpdateScreenlockStateFunction() {}
 414
 415 EasyUnlockPrivateUpdateScreenlockStateFunction::
 416     ~EasyUnlockPrivateUpdateScreenlockStateFunction() {}
 417
 418 bool EasyUnlockPrivateUpdateScreenlockStateFunction::RunSync() {
 419   scoped_ptr<easy_unlock_private::UpdateScreenlockState::Params> params(
 420       easy_unlock_private::UpdateScreenlockState::Params::Create(*args_));
 421   EXTENSION_FUNCTION_VALIDATE(params.get());
 422
 423   Profile* profile = Profile::FromBrowserContext(browser_context());
 424   if (EasyUnlockService::Get(profile)->UpdateScreenlockState(
 425           ToScreenlockStateHandlerState(params->state)))
 426     return true;
 427
 428   SetError("Not allowed");
 429   return false;
 430 }
 431
 432 EasyUnlockPrivateSetPermitAccessFunction::
 433     EasyUnlockPrivateSetPermitAccessFunction() {
 434 }
 435
 436 EasyUnlockPrivateSetPermitAccessFunction::
 437     ~EasyUnlockPrivateSetPermitAccessFunction() {
 438 }
 439
 440 bool EasyUnlockPrivateSetPermitAccessFunction::RunSync() {
 441   scoped_ptr<easy_unlock_private::SetPermitAccess::Params> params(
 442       easy_unlock_private::SetPermitAccess::Params::Create(*args_));
 443   EXTENSION_FUNCTION_VALIDATE(params.get());
 444
 445   Profile* profile = Profile::FromBrowserContext(browser_context());
 446   EasyUnlockService::Get(profile)
 447       ->SetPermitAccess(*params->permit_access.ToValue());
 448
 449   return true;
 450 }
 451
 452 EasyUnlockPrivateGetPermitAccessFunction::
 453     EasyUnlockPrivateGetPermitAccessFunction() {
 454 }
 455
 456 EasyUnlockPrivateGetPermitAccessFunction::
 457     ~EasyUnlockPrivateGetPermitAccessFunction() {
 458 }
 459
 460 bool EasyUnlockPrivateGetPermitAccessFunction::RunSync() {
 461   Profile* profile = Profile::FromBrowserContext(browser_context());
 462   const base::DictionaryValue* permit_value =
 463       EasyUnlockService::Get(profile)->GetPermitAccess();
 464   if (permit_value) {
 465     scoped_ptr<easy_unlock_private::PermitRecord> permit =
 466         easy_unlock_private::PermitRecord::FromValue(*permit_value);
 467     results_ = easy_unlock_private::GetPermitAccess::Results::Create(*permit);
 468   }
 469
 470   return true;
 471 }
 472
 473 EasyUnlockPrivateClearPermitAccessFunction::
 474     EasyUnlockPrivateClearPermitAccessFunction() {
 475 }
 476
 477 EasyUnlockPrivateClearPermitAccessFunction::
 478     ~EasyUnlockPrivateClearPermitAccessFunction() {
 479 }
 480
 481 bool EasyUnlockPrivateClearPermitAccessFunction::RunSync() {
 482   Profile* profile = Profile::FromBrowserContext(browser_context());
 483   EasyUnlockService::Get(profile)->ClearPermitAccess();
 484   return true;
 485 }
 486
 487 EasyUnlockPrivateSetRemoteDevicesFunction::
 488     EasyUnlockPrivateSetRemoteDevicesFunction() {
 489 }
 490
 491 EasyUnlockPrivateSetRemoteDevicesFunction::
 492     ~EasyUnlockPrivateSetRemoteDevicesFunction() {
 493 }
 494
 495 bool EasyUnlockPrivateSetRemoteDevicesFunction::RunSync() {
 496   scoped_ptr<easy_unlock_private::SetRemoteDevices::Params> params(
 497       easy_unlock_private::SetRemoteDevices::Params::Create(*args_));
 498   EXTENSION_FUNCTION_VALIDATE(params.get());
 499
 500   Profile* profile = Profile::FromBrowserContext(browser_context());
 501   if (params->devices.empty()) {
 502     EasyUnlockService::Get(profile)->ClearRemoteDevices();
 503   } else {
 504     base::ListValue devices;
 505     for (size_t i = 0; i < params->devices.size(); ++i) {
 506       devices.Append(params->devices[i]->ToValue().release());
 507     }
 508     EasyUnlockService::Get(profile)->SetRemoteDevices(devices);
 509   }
 510
 511   return true;
 512 }
 513
 514 EasyUnlockPrivateGetRemoteDevicesFunction::
 515     EasyUnlockPrivateGetRemoteDevicesFunction() {
 516 }
 517
 518 EasyUnlockPrivateGetRemoteDevicesFunction::
 519     ~EasyUnlockPrivateGetRemoteDevicesFunction() {
 520 }
 521
 522 bool EasyUnlockPrivateGetRemoteDevicesFunction::RunSync() {
 523   Profile* profile = Profile::FromBrowserContext(browser_context());
 524   const base::ListValue* devices =
 525       EasyUnlockService::Get(profile)->GetRemoteDevices();
 526   SetResult(devices ? devices->DeepCopy() : new base::ListValue());
 527   return true;
 528 }
 529
 530 EasyUnlockPrivateGetSignInChallengeFunction::
 531     EasyUnlockPrivateGetSignInChallengeFunction() {
 532 }
 533
 534 EasyUnlockPrivateGetSignInChallengeFunction::
 535     ~EasyUnlockPrivateGetSignInChallengeFunction() {
 536 }
 537
 538 bool EasyUnlockPrivateGetSignInChallengeFunction::RunSync() {
 539   Profile* profile = Profile::FromBrowserContext(browser_context());
 540   const std::string challenge =
 541       EasyUnlockService::Get(profile)->GetChallenge();
 542   if (!challenge.empty()) {
 543     results_ =
 544         easy_unlock_private::GetSignInChallenge::Results::Create(challenge);
 545   }
 546   return true;
 547 }
 548
 549 EasyUnlockPrivateTrySignInSecretFunction::
 550     EasyUnlockPrivateTrySignInSecretFunction() {
 551 }
 552
 553 EasyUnlockPrivateTrySignInSecretFunction::
 554     ~EasyUnlockPrivateTrySignInSecretFunction() {
 555 }
 556
 557 bool EasyUnlockPrivateTrySignInSecretFunction::RunSync() {
 558   scoped_ptr<easy_unlock_private::TrySignInSecret::Params> params(
 559       easy_unlock_private::TrySignInSecret::Params::Create(*args_));
 560   EXTENSION_FUNCTION_VALIDATE(params.get());
 561
 562   Profile* profile = Profile::FromBrowserContext(browser_context());
 563   EasyUnlockService::Get(profile)->FinalizeSignin(params->sign_in_secret);
 564   return true;
 565 }
 566
 567 EasyUnlockPrivateGetUserInfoFunction::EasyUnlockPrivateGetUserInfoFunction() {
 568 }
 569
 570 EasyUnlockPrivateGetUserInfoFunction::~EasyUnlockPrivateGetUserInfoFunction() {
 571 }
 572
 573 bool EasyUnlockPrivateGetUserInfoFunction::RunSync() {
 574   EasyUnlockService* service =
 575       EasyUnlockService::Get(Profile::FromBrowserContext(browser_context()));
 576   std::vector<linked_ptr<easy_unlock_private::UserInfo> > users;
 577   std::string user_id = service->GetUserEmail();
 578   if (!user_id.empty()) {
 579     users.push_back(
 580         linked_ptr<easy_unlock_private::UserInfo>(
 581             new easy_unlock_private::UserInfo()));
 582     users[0]->user_id = user_id;
 583     users[0]->logged_in = service->GetType() == EasyUnlockService::TYPE_REGULAR;
 584     users[0]->data_ready = users[0]->logged_in ||
 585                            service->GetRemoteDevices() != NULL;
 586   }
 587   results_ = easy_unlock_private::GetUserInfo::Results::Create(users);
 588   return true;
 589 }
 590
 591 }  // namespace api
 592 }  // namespace extensions