Hook up new API for easy unlock to update lock screen

chrome/browser/signin/easy_unlock_screenlock_state_handler.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_screenlock_state_handler.h"
+
+#include "base/bind.h"
+#include "base/prefs/pref_service.h"
+#include "base/strings/string16.h"
+#include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/chromeos/chromeos_utils.h"
+#include "chrome/common/pref_names.h"
+#include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
+
+namespace {
+
+size_t kIconSize = 27u;
+size_t kOpaqueIconOpacity = 50u;
+size_t kSpinnerResourceWidth = 1215u;
+size_t kSpinnerIntervalMs = 50u;
+
+std::string GetIconURLForState(EasyUnlockScreenlockStateHandler::State state) {
+  switch (state) {
+    case EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH:
+    case EasyUnlockScreenlockStateHandler::STATE_NO_PHONE:
+    case EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_AUTHENTICATED:
+    case EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED:
+    case EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_NEARBY:
+    case EasyUnlockScreenlockStateHandler::STATE_PHONE_UNLOCKABLE:
+      return "chrome://theme/IDR_EASY_UNLOCK_LOCKED";
+    case EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING:
+      return "chrome://theme/IDR_EASY_UNLOCK_SPINNER";
+    case EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED:
+      return "chrome://theme/IDR_EASY_UNLOCK_UNLOCKED";

[xiyuan, 2014/08/12 18:09:47]

Do you have a seperate CL for those image resources?

[tbarzic, 2014/08/12 19:14:36]

yep, I'll upload the cl today...

+    default:
+      return "";
+  }
+}
+
+bool UseOpaqueIcon(EasyUnlockScreenlockStateHandler::State state) {
+  return state == EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH ||
+         state == EasyUnlockScreenlockStateHandler::STATE_NO_PHONE ||
+         state == EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_NEARBY ||
+         state == EasyUnlockScreenlockStateHandler::STATE_PHONE_UNLOCKABLE;
+}
+
+bool HasAnimation(EasyUnlockScreenlockStateHandler::State state) {
+  return state == EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING;
+}
+
+size_t GetTooltipResourceId(EasyUnlockScreenlockStateHandler::State state) {
+  switch (state) {
+    case EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH:
+      return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_NO_BLUETOOTH;
+    case EasyUnlockScreenlockStateHandler::STATE_NO_PHONE:
+      return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_NO_PHONE;
+    case EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_AUTHENTICATED:
+      return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_PHONE_NOT_AUTHENTICATED;
+    case EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED:
+      return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_PHONE_LOCKED;
+    case EasyUnlockScreenlockStateHandler::STATE_PHONE_UNLOCKABLE:
+      return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_PHONE_UNLOCKABLE;
+    case EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_NEARBY:
+      return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_PHONE_NOT_NEARBY;
+    case EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED:
+      // TODO(tbarzic): When hard lock is enabled change this to
+      // IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_HARDLOCK_INSTRUCTIONS.
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+}  // namespace
+
+
+EasyUnlockScreenlockStateHandler::EasyUnlockScreenlockStateHandler(
+    const std::string& user_email,
+    PrefService* pref_service,
+    ScreenlockBridge* screenlock_bridge)
+    : state_(STATE_INACTIVE),
+      user_email_(user_email),
+      pref_service_(pref_service),
+      screenlock_bridge_(screenlock_bridge) {
+  DCHECK(screenlock_bridge_);
+  screenlock_bridge_->AddObserver(this);
+}
+
+EasyUnlockScreenlockStateHandler::~EasyUnlockScreenlockStateHandler() {
+  screenlock_bridge_->RemoveObserver(this);
+}
+
+void EasyUnlockScreenlockStateHandler::ChangeState(State new_state) {
+  if (state_ == new_state)
+    return;
+
+  state_ = screenlock_bridge_->lock_handler() ? new_state : STATE_INACTIVE;

[dzhioev (left Google), 2014/08/12 19:36:08]

screenlock_bridge_->IsLocked()?

[dzhioev (left Google), 2014/08/12 19:36:08]

Why do you ignore state change when screen is unlocked?Doesn't it mean that when
user locks screen we need to wait for another call of ChangeState to enable easy
unlock? You could probably cache the state and then apply it in
OnScreenDidUnlock.

[tbarzic, 2014/08/12 21:40:57]

Done.

[tbarzic, 2014/08/12 21:40:57]

Yes. And the app would call ChangeState when screen unlocks. But reapplying
cached state also sounds reasonable.

+
+  // If lock screen is still shown, make sure the previously set lockscreen
+  // state gets cleared.
+  if (!screenlock_bridge_->lock_handler())

[dzhioev (left Google), 2014/08/12 19:36:08]

ditto

[tbarzic, 2014/08/12 21:40:57]

Done.

+    return;
+
+  UpdateScreenlockAuthType();
+
+  ScreenlockBridge::UserPodCustomIconOptions icon_options;
+
+  std::string icon_url = GetIconURLForState(state_);
+  if (icon_url.empty()) {
+    screenlock_bridge_->lock_handler()->HideUserPodCustomIcon(user_email_);
+    return;
+  }
+  icon_options.SetIconAsResourceURL(icon_url);
+
+  UpdateTooltipOptions(&icon_options);
+
+  if (UseOpaqueIcon(state_))
+    icon_options.SetOpacity(kOpaqueIconOpacity);
+
+  icon_options.SetSize(kIconSize, kIconSize);
+
+  if (HasAnimation(state_))
+    icon_options.SetAnimation(kSpinnerResourceWidth, kSpinnerIntervalMs);
+
+  screenlock_bridge_->lock_handler()->ShowUserPodCustomIcon(user_email_,
+                                                            icon_options);
+}
+
+void EasyUnlockScreenlockStateHandler::OnScreenDidLock() {}
+
+void EasyUnlockScreenlockStateHandler::OnScreenDidUnlock() {
+  ChangeState(STATE_INACTIVE);
+}
+
+void EasyUnlockScreenlockStateHandler::UpdateTooltipOptions(
+    ScreenlockBridge::UserPodCustomIconOptions* icon_options) {
+  bool show_tutorial = ShouldShowTutorial();
+
+  size_t resource_id = 0;
+  base::string16 device_name;
+  if (show_tutorial) {
+    resource_id = IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_TUTORIAL;
+  } else {
+    resource_id = GetTooltipResourceId(state_);
+    if (state_ == STATE_AUTHENTICATED || state_ == STATE_PHONE_UNLOCKABLE)
+      device_name = GetDeviceName();
+  }
+
+  if (!resource_id)
+    return;
+
+  base::string16 tooltip;
+  if (device_name.empty()) {
+    tooltip = l10n_util::GetStringUTF16(resource_id);
+  } else {
+    tooltip = l10n_util::GetStringFUTF16(resource_id, device_name);
+  }
+
+  if (tooltip.empty())
+    return;
+
+  if (show_tutorial)
+    MarkTutorialShown();
+
+  icon_options->SetTooltip(tooltip, show_tutorial /* autoshow tooltip */);
+}
+
+bool EasyUnlockScreenlockStateHandler::ShouldShowTutorial() {
+  if (state_ != STATE_AUTHENTICATED)
+    return false;
+  return pref_service_ &&
+         pref_service_->GetBoolean(prefs::kEasyUnlockShowTutorial);
+}
+
+void EasyUnlockScreenlockStateHandler::MarkTutorialShown() {
+  if (!pref_service_)
+    return;
+  pref_service_->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
+}
+
+base::string16 EasyUnlockScreenlockStateHandler::GetDeviceName() {
+#if defined(OS_CHROMEOS)
+  return chromeos::GetChromeDeviceType();
+#else
+  // TODO(tbarzic): Figure out the name for non Chrome OS case.
+  return base::ASCIIToUTF16("Chrome");
+#endif
+}
+
+void EasyUnlockScreenlockStateHandler::UpdateScreenlockAuthType() {
+  if (state_ == STATE_AUTHENTICATED) {
+    screenlock_bridge_->lock_handler()->SetAuthType(
+        user_email_,
+        ScreenlockBridge::LockHandler::USER_CLICK,
+        l10n_util::GetStringUTF16(
+            IDS_EASY_UNLOCK_SCREENLOCK_USER_POD_AUTH_VALUE));
+  } else if (screenlock_bridge_->lock_handler()->GetAuthType(user_email_) !=
+                 ScreenlockBridge::LockHandler::OFFLINE_PASSWORD) {
+    screenlock_bridge_->lock_handler()->SetAuthType(
+        user_email_,
+        ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
+        base::string16());
+  }
+}