[remoting][FTL] Implement FtlRegistrationManager

Implements a FtlRegistrationManager class for signing in the user for
FTL services.

Change-Id: Id9323f7c9837a32e8b4bca3258f9f35f73db40d0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1526811
Commit-Queue: Yuwei Huang <yuweih@chromium.org>
Reviewed-by: Joe Downing <joedow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#643629}

remoting/signaling/BUILD.gn

@@ -8,12 +8,16 @@ static_library("signaling") {
   sources = [
     "delegating_signal_strategy.cc",
     "delegating_signal_strategy.h",
+    "ftl_device_id_provider.cc",
+    "ftl_device_id_provider.h",
     "ftl_grpc_context.cc",
     "ftl_grpc_context.h",
     "ftl_message_reception_channel.cc",
     "ftl_message_reception_channel.h",
     "ftl_messaging_client.cc",
     "ftl_messaging_client.h",
+    "ftl_registration_manager.cc",
+    "ftl_registration_manager.h",
     "iq_sender.cc",
     "iq_sender.h",
     "jid_util.cc",
@@ -68,6 +72,8 @@ static_library("signaling") {
       "ftl_message_reception_channel.h",
       "ftl_messaging_client.cc",
       "ftl_messaging_client.h",
+      "ftl_registration_manager.cc",
+      "ftl_registration_manager.h",
       "log_to_server.cc",
       "server_log_entry.cc",
       "xmpp_signal_strategy.cc",

remoting/signaling/ftl_device_id_provider.cc

@@ -0,0 +1,54 @@
+// Copyright 2019 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 "remoting/signaling/ftl_device_id_provider.h"
+
+#include <utility>
+
+#include "base/guid.h"
+#include "base/logging.h"
+#include "build/build_config.h"
+
+namespace remoting {
+
+namespace {
+
+#if defined(OS_ANDROID)
+constexpr char kDeviceIdPrefix[] = "crd-android-";
+#elif defined(OS_IOS)
+constexpr char kDeviceIdPrefix[] = "crd-ios-";
+#elif defined(OS_WIN)
+constexpr char kDeviceIdPrefix[] = "crd-win-host-";
+#elif defined(OS_MACOSX)
+constexpr char kDeviceIdPrefix[] = "crd-mac-host-";
+#elif defined(OS_CHROMEOS)
+constexpr char kDeviceIdPrefix[] = "crd-cros-host-";
+#elif defined(OS_LINUX)
+constexpr char kDeviceIdPrefix[] = "crd-linux-host-";
+#else
+constexpr char kDeviceIdPrefix[] = "crd-unknown-";
+#endif
+
+}  // namespace
+
+FtlDeviceIdProvider::FtlDeviceIdProvider(TokenStorage* token_storage)
+    : token_storage_(token_storage) {
+  DCHECK(token_storage_);
+}
+
+FtlDeviceIdProvider::~FtlDeviceIdProvider() = default;
+
+std::string FtlDeviceIdProvider::GetDeviceId() {
+  std::string device_id = token_storage_->FetchDeviceId();
+  if (device_id.empty()) {
+    device_id = kDeviceIdPrefix + base::GenerateGUID();
+    VLOG(0) << "Generated new device_id: " << device_id;
+    token_storage_->StoreDeviceId(device_id);
+  } else {
+    VLOG(0) << "Using stored device_id: " << device_id;
+  }
+  return device_id;
+}
+
+}  // namespace remoting

remoting/signaling/ftl_device_id_provider.h

@@ -0,0 +1,43 @@
+// Copyright 2019 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.
+
+#ifndef REMOTING_SIGNALING_FTL_DEVICE_ID_PROVIDER_H_
+#define REMOTING_SIGNALING_FTL_DEVICE_ID_PROVIDER_H_
+
+#include <memory>
+#include <string>
+
+#include "base/macros.h"
+
+namespace remoting {
+
+// Class that provides device ID to be used to sign in for FTL.
+// TODO(yuweih): Add unittest
+class FtlDeviceIdProvider final {
+ public:
+  class TokenStorage {
+   public:
+    TokenStorage() = default;
+    virtual ~TokenStorage() = default;
+
+    virtual std::string FetchDeviceId() = 0;
+    virtual bool StoreDeviceId(const std::string& device_id) = 0;
+  };
+
+  explicit FtlDeviceIdProvider(TokenStorage* token_storage);
+  ~FtlDeviceIdProvider();
+
+  // Gets a device ID to use for signing into FTL. This could either be a
+  // previously stored value or a newly generated value (which has been already
+  // stored into |token_storage_|).
+  std::string GetDeviceId();
+
+ private:
+  TokenStorage* token_storage_;
+  DISALLOW_COPY_AND_ASSIGN(FtlDeviceIdProvider);
+};
+
+}  // namespace remoting
+
+#endif  // REMOTING_SIGNALING_FTL_DEVICE_ID_PROVIDER_H_

remoting/signaling/ftl_registration_manager.cc

@@ -0,0 +1,111 @@
+// Copyright 2019 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 "remoting/signaling/ftl_registration_manager.h"
+
+#include <utility>
+
+#include "base/bind_helpers.h"
+#include "base/callback.h"
+#include "base/logging.h"
+#include "base/time/time.h"
+#include "remoting/signaling/ftl_device_id_provider.h"
+#include "remoting/signaling/ftl_grpc_context.h"
+
+namespace remoting {
+
+namespace {
+
+constexpr remoting::ftl::FtlCapability::Feature kFtlCapabilities[] = {
+    remoting::ftl::FtlCapability_Feature_RECEIVE_CALLS_FROM_GAIA,
+    remoting::ftl::FtlCapability_Feature_GAIA_REACHABLE};
+constexpr size_t kFtlCapabilityCount =
+    sizeof(kFtlCapabilities) / sizeof(ftl::FtlCapability::Feature);
+
+constexpr base::TimeDelta kRefreshBufferTime = base::TimeDelta::FromHours(1);
+
+}  // namespace
+
+FtlRegistrationManager::FtlRegistrationManager(
+    FtlGrpcContext* context,
+    std::unique_ptr<FtlDeviceIdProvider> device_id_provider)
+    : context_(context),
+      device_id_provider_(std::move(device_id_provider)),
+      weak_factory_(this) {
+  DCHECK(context_);
+  DCHECK(device_id_provider_);
+  registration_stub_ = Registration::NewStub(context_->channel());
+}
+
+FtlRegistrationManager::~FtlRegistrationManager() = default;
+
+void FtlRegistrationManager::SignInGaia(DoneCallback on_done) {
+  ftl::SignInGaiaRequest request;
+  request.set_app(FtlGrpcContext::GetChromotingAppIdentifier());
+  request.set_mode(ftl::SignInGaiaMode_Value_DEFAULT_CREATE_ACCOUNT);
+
+  request.mutable_register_data()->mutable_device_id()->set_id(
+      device_id_provider_->GetDeviceId());
+
+  // TODO(yuweih): Consider using different device ID type.
+  request.mutable_register_data()->mutable_device_id()->set_type(
+      ftl::DeviceIdType_Type_WEB_UUID);
+
+  for (size_t i = 0; i < kFtlCapabilityCount; i++) {
+    request.mutable_register_data()->add_caps(kFtlCapabilities[i]);
+  }
+
+  context_->ExecuteRpc(
+      base::BindOnce(&Registration::Stub::AsyncSignInGaia,
+                     base::Unretained(registration_stub_.get())),
+      request,
+      base::BindOnce(&FtlRegistrationManager::OnSignInGaiaResponse,
+                     weak_factory_.GetWeakPtr(), std::move(on_done)));
+}
+
+bool FtlRegistrationManager::IsSignedIn() const {
+  return !registration_id_.empty();
+}
+
+void FtlRegistrationManager::OnSignInGaiaResponse(
+    DoneCallback on_done,
+    const grpc::Status& status,
+    const ftl::SignInGaiaResponse& response) {
+  registration_id_.clear();
+
+  if (!status.ok()) {
+    LOG(ERROR) << "Failed to sign in."
+               << " Error code: " << status.error_code()
+               << ", message: " << status.error_message();
+    std::move(on_done).Run(status);
+    return;
+  }
+
+  registration_id_ = response.registration_id();
+  if (registration_id_.empty()) {
+    std::move(on_done).Run(
+        grpc::Status(grpc::StatusCode::UNKNOWN, "registration_id is empty."));
+    return;
+  }
+
+  // TODO(yuweih): Consider caching auth token.
+  context_->SetAuthToken(response.auth_token().payload());
+  VLOG(0) << "Auth token set on FtlClient";
+  base::TimeDelta refresh_delay =
+      base::TimeDelta::FromMicroseconds(response.auth_token().expires_in());
+  if (refresh_delay > kRefreshBufferTime) {
+    refresh_delay -= kRefreshBufferTime;
+  } else {
+    LOG(WARNING) << "Refresh time is too short. Buffer time is not applied.";
+  }
+  sign_in_refresh_timer_.Start(
+      FROM_HERE, refresh_delay,
+      base::BindOnce(&FtlRegistrationManager::SignInGaia,
+                     base::Unretained(this),
+                     base::DoNothing::Once<const grpc::Status&>()));
+  VLOG(0) << "Scheduled auth token refresh in: " << refresh_delay;
+  std::move(on_done).Run(status);
+}
+
+}  // namespace remoting

remoting/signaling/ftl_registration_manager.h

@@ -0,0 +1,62 @@
+// Copyright 2019 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.
+
+#ifndef REMOTING_SIGNALING_FTL_REGISTRATION_MANAGER_H_
+#define REMOTING_SIGNALING_FTL_REGISTRATION_MANAGER_H_
+
+#include <memory>
+#include <string>
+
+#include "base/callback_forward.h"
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/timer/timer.h"
+#include "remoting/signaling/ftl_services.grpc.pb.h"
+
+namespace remoting {
+
+class FtlDeviceIdProvider;
+class FtlGrpcContext;
+
+// Class for registering the user with FTL service.
+// TODO(yuweih): Add unittest
+class FtlRegistrationManager final {
+ public:
+  using DoneCallback = base::OnceCallback<void(const grpc::Status& status)>;
+
+  FtlRegistrationManager(
+      FtlGrpcContext* context,
+      std::unique_ptr<FtlDeviceIdProvider> device_id_provider);
+  ~FtlRegistrationManager();
+
+  // Performs a SignInGaia call for this device. |on_done| is called once it has
+  // successfully signed in or failed to sign in.
+  void SignInGaia(DoneCallback on_done);
+
+  bool IsSignedIn() const;
+
+  // Returns empty string if user hasn't been signed in.
+  const std::string& registration_id() const { return registration_id_; }
+
+ private:
+  using Registration =
+      google::internal::communications::instantmessaging::v1::Registration;
+
+  void OnSignInGaiaResponse(DoneCallback on_done,
+                            const grpc::Status& status,
+                            const ftl::SignInGaiaResponse& response);
+
+  FtlGrpcContext* context_;
+  std::unique_ptr<FtlDeviceIdProvider> device_id_provider_;
+  std::unique_ptr<Registration::Stub> registration_stub_;
+  base::OneShotTimer sign_in_refresh_timer_;
+  std::string registration_id_;
+
+  base::WeakPtrFactory<FtlRegistrationManager> weak_factory_;
+  DISALLOW_COPY_AND_ASSIGN(FtlRegistrationManager);
+};
+
+}  // namespace remoting
+
+#endif  // REMOTING_SIGNALING_FTL_REGISTRATION_MANAGER_H_