Settings People Revamp: Easy Unlock: Add basic UI

chrome/browser/ui/webui/settings/chromeos/easy_unlock_settings_handler.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/ui/webui/settings/chromeos/easy_unlock_settings_handler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/easy_unlock_service.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/proximity_auth/switches.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 
 namespace chromeos {
 namespace settings {
 
 EasyUnlockSettingsHandler::EasyUnlockSettingsHandler(Profile* profile)
     : profile_(profile) {
   EasyUnlockService::Get(profile)->AddObserver(this);
+
+  profile_pref_registrar_.Init(profile->GetPrefs());
+  profile_pref_registrar_.Add(

[dpapad, 2016/03/15 17:49:40]

Based on our WebUI initialization pitfalls discussion, registering this C++
observer in the constructor is not very safe. It might end-up calling to JS
before WebUI is ready.

The proposed solution (see
https://docs.google.com/document/d/1ubLoYnTSyjCMFCpy1tPy6g1RAm5FajmbuQygjqN3a...)
is to only register C++ observers after the page has communicated that it is
ready.

[tommycli, 2016/03/15 18:58:27]

Done.

+      prefs::kEasyUnlockPairing,
+      base::Bind(&EasyUnlockSettingsHandler::SendEnabledStatus,
+                 base::Unretained(this)));
 }
 
 EasyUnlockSettingsHandler::~EasyUnlockSettingsHandler() {
   EasyUnlockService::Get(profile_)->RemoveObserver(this);
 }
 
 EasyUnlockSettingsHandler* EasyUnlockSettingsHandler::Create(
     content::WebUIDataSource* html_source,
     Profile* profile) {
-  bool allowed = EasyUnlockService::Get(profile)->IsAllowed();
+  EasyUnlockService* easy_unlock_service = EasyUnlockService::Get(profile);
+  bool allowed = easy_unlock_service->IsAllowed();
   html_source->AddBoolean("easyUnlockAllowed", allowed);
   if (!allowed)
     return nullptr;
 
+  html_source->AddBoolean("easyUnlockEnabled",
+                          easy_unlock_service->IsEnabled());
   html_source->AddString("easyUnlockLearnMoreURL",

[dpapad, 2016/03/15 17:49:40]

Can we move "easyUnlockLearnMoreURL" registration in
md_settings_localized_strings_provider.cc? I think this is more aligned with the
pattern we follow for other pages, where string constants are registered there,
and only info that depends on this class is registered here (for example
booleans).

[tommycli, 2016/03/15 18:58:27]

Done.

                          chrome::kEasyUnlockLearnMoreUrl);
   html_source->AddBoolean(
       "easyUnlockProximityDetectionAllowed",
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           proximity_auth::switches::kEnableProximityDetection));
 
   return new EasyUnlockSettingsHandler(profile);
 }
 
 void EasyUnlockSettingsHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
+      "easyUnlockGetEnabledStatus",
+      base::Bind(&EasyUnlockSettingsHandler::HandleGetEnabledStatus,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
       "easyUnlockGetTurnOffFlowStatus",
       base::Bind(&EasyUnlockSettingsHandler::HandleGetTurnOffFlowStatus,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "easyUnlockRequestTurnOff",
       base::Bind(&EasyUnlockSettingsHandler::HandleRequestTurnOff,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "easyUnlockTurnOffOverlayDismissed",
       base::Bind(&EasyUnlockSettingsHandler::HandlePageDismissed,
                  base::Unretained(this)));
 }
 
 void EasyUnlockSettingsHandler::OnTurnOffOperationStatusChanged() {
   SendTurnOffOperationStatus();
 }
 
+void EasyUnlockSettingsHandler::SendEnabledStatus() {
+  web_ui()->CallJavascriptFunction(
+      "cr.webUIListenerCallback",
+      base::StringValue("easy-unlock-enabled-status"),
+      base::FundamentalValue(EasyUnlockService::Get(profile_)->IsEnabled()));
+}
+
 void EasyUnlockSettingsHandler::SendTurnOffOperationStatus() {
   EasyUnlockService::TurnOffFlowStatus status =
       EasyUnlockService::Get(profile_)->GetTurnOffFlowStatus();
 
   // Translate status into JS UI state string. Note the translated string
   // should match UIState defined in easy_unlock_turn_off_overlay.js.
   std::string status_string;
   switch (status) {
     case EasyUnlockService::IDLE:
       status_string = "idle";
       break;
     case EasyUnlockService::PENDING:
       status_string = "pending";
       break;
     case EasyUnlockService::FAIL:
       status_string = "server-error";
       break;
     default:
       LOG(ERROR) << "Unknown Easy unlock turn-off operation status: " << status;
       status_string = "idle";
       break;
   }
 
   web_ui()->CallJavascriptFunction(
       "cr.webUIListenerCallback",
       base::StringValue("easy-unlock-turn-off-flow-status"),
       base::StringValue(status_string));
 }
 
+void EasyUnlockSettingsHandler::HandleGetEnabledStatus(
+    const base::ListValue* args) {
+  CHECK_EQ(1U, args->GetSize());
+  const base::Value* callback_id;
+  CHECK(args->Get(0, &callback_id));
+  ResolveJavascriptCallback(
+      *callback_id,
+      base::FundamentalValue(EasyUnlockService::Get(profile_)->IsEnabled()));
+}
+
 void EasyUnlockSettingsHandler::HandleGetTurnOffFlowStatus(
     const base::ListValue* args) {
   SendTurnOffOperationStatus();
 }
 
 void EasyUnlockSettingsHandler::HandleRequestTurnOff(
     const base::ListValue* args) {
   EasyUnlockService::Get(profile_)->RunTurnOffFlow();
 }
 
 void EasyUnlockSettingsHandler::HandlePageDismissed(
     const base::ListValue* args) {
   EasyUnlockService::Get(profile_)->ResetTurnOffFlow();
 }
 
 }  // namespace settings
 }  // namespace chromeos