remoting: Use ephemeral UUID for clients.

Instead of attempting to maintain a persistent identifer for our mobile
clients, create a unquie UUID to be used for the session.

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

remoting/client/chromoting_session.cc

@@ -35,6 +35,7 @@
 #include "remoting/protocol/performance_tracker.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/video_renderer.h"
+#include "remoting/signaling/ftl_client_uuid_device_id_provider.h"
 #include "remoting/signaling/ftl_signal_strategy.h"
 #include "remoting/signaling/server_log_entry.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
@@ -86,7 +87,6 @@ struct SessionContext {
       audio_player_weak_factory;
   std::unique_ptr<protocol::CursorShapeStub> cursor_shape_stub;
   std::unique_ptr<protocol::VideoRenderer> video_renderer;
-  std::unique_ptr<FtlDeviceIdProvider> device_id_provider;
 
   ConnectToHostInfo info;
 };
@@ -496,7 +496,7 @@ void ChromotingSession::Core::ConnectOnNetworkThread() {
   if (!session_context_->info.host_ftl_id.empty()) {
     signaling_ = std::make_unique<FtlSignalStrategy>(
         runtime_->CreateOAuthTokenGetter(),
-        std::move(session_context_->device_id_provider));
+        std::make_unique<FtlClientUuidDeviceIdProvider>());
     logger_->SetSignalStrategyType(ChromotingEvent::SignalStrategyType::FTL);
   } else {
     signaling_ = std::make_unique<XmppSignalStrategy>(
@@ -636,7 +636,6 @@ ChromotingSession::ChromotingSession(
     std::unique_ptr<protocol::CursorShapeStub> cursor_shape_stub,
     std::unique_ptr<protocol::VideoRenderer> video_renderer,
     std::unique_ptr<protocol::AudioStub> audio_player,
-    std::unique_ptr<FtlDeviceIdProvider> device_id_provider,
     const ConnectToHostInfo& info)
     : runtime_(ChromotingClientRuntime::GetInstance()) {
   DCHECK(delegate);
@@ -654,7 +653,6 @@ ChromotingSession::ChromotingSession(
           session_context->audio_player.get());
   session_context->cursor_shape_stub = std::move(cursor_shape_stub);
   session_context->video_renderer = std::move(video_renderer);
-  session_context->device_id_provider = std::move(device_id_provider);
   session_context->info = info;
 
   auto logger = std::make_unique<ClientTelemetryLogger>(

remoting/client/chromoting_session.h

@@ -93,7 +93,6 @@ class ChromotingSession : public ClientInputInjector {
                     std::unique_ptr<protocol::CursorShapeStub> cursor_stub,
                     std::unique_ptr<protocol::VideoRenderer> video_renderer,
                     std::unique_ptr<protocol::AudioStub> audio_player,
-                    std::unique_ptr<FtlDeviceIdProvider> device_id_provider,
                     const ConnectToHostInfo& info);
 
   ~ChromotingSession() override;

remoting/client/jni/jni_client.cc

@@ -50,8 +50,7 @@ void JniClient::ConnectToHost(const ConnectToHostInfo& info) {
   session_.reset(new ChromotingSession(
       weak_ptr_, display_handler_->CreateCursorShapeStub(),
       display_handler_->CreateVideoRenderer(),
-      std::make_unique<AudioPlayerAndroid>(), /* device_id_provider */ nullptr,
-      info));
+      std::make_unique<AudioPlayerAndroid>(), info));
 }
 
 void JniClient::DisconnectFromHost() {

remoting/ios/facade/BUILD.gn

@@ -10,8 +10,6 @@ source_set("facade") {
   sources = [
     "directory_client.cc",
     "directory_client.h",
-    "ftl_device_id_provider_ios.h",
-    "ftl_device_id_provider_ios.mm",
     "host_list_service.h",
     "host_list_service.mm",
     "ios_client_runtime_delegate.h",

remoting/ios/facade/ftl_device_id_provider_ios.mm

-// 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.
-
-#if !defined(__has_feature) || !__has_feature(objc_arc)
-#error "This file requires ARC support."
-#endif
-
-#include "remoting/ios/facade/ftl_device_id_provider_ios.h"
-
-#import <UIKit/UIKit.h>
-
-#include "base/strings/sys_string_conversions.h"
-
-namespace remoting {
-
-FtlDeviceIdProviderIos::FtlDeviceIdProviderIos() {
-  std::string vendor_id = base::SysNSStringToUTF8(
-      UIDevice.currentDevice.identifierForVendor.UUIDString);
-  device_id_.set_type(ftl::DeviceIdType_Type_IOS_VENDOR_ID);
-  device_id_.set_id(vendor_id);
-}
-
-FtlDeviceIdProviderIos::~FtlDeviceIdProviderIos() = default;
-
-ftl::DeviceId FtlDeviceIdProviderIos::GetDeviceId() {
-  return device_id_;
-}
-
-}  // namespace remoting

remoting/ios/session/remoting_client.mm

@@ -26,7 +26,6 @@
 #include "remoting/client/connect_to_host_info.h"
 #include "remoting/client/gesture_interpreter.h"
 #include "remoting/client/input/keyboard_interpreter.h"
-#include "remoting/ios/facade/ftl_device_id_provider_ios.h"
 #import "remoting/ios/facade/remoting_authentication.h"
 #import "remoting/ios/facade/remoting_service.h"
 #include "remoting/ios/session/remoting_client_session_delegate.h"
@@ -141,13 +140,9 @@ static void ResolveFeedbackDataCallback(
   _displayHandler = [[GlDisplayHandler alloc] init];
   _displayHandler.delegate = self;
 
-  auto device_id_provider =
-      std::make_unique<remoting::FtlDeviceIdProviderIos>();
-
   _session = std::make_unique<remoting::ChromotingSession>(
       _sessonDelegate->GetWeakPtr(), [_displayHandler createCursorShapeStub],
-      [_displayHandler createVideoRenderer], std::move(audioStream),
-      std::move(device_id_provider), info);
+      [_displayHandler createVideoRenderer], std::move(audioStream), info);
   _gestureInterpreter.SetContext(_displayHandler.rendererProxy, _session.get());
   _keyboardInterpreter.SetContext(_session.get());
 }

remoting/proto/ftl/v1/ftl_messages.proto

@@ -46,10 +46,9 @@ message IdType {
 message DeviceIdType {
   enum Type {
     UNKNOWN = 0;
-    ANDROID_IID_TOKEN = 1;
-    IOS_VENDOR_ID = 2;
     WEB_UUID = 3;
     CHROMOTING_HOST_ID = 6;
+    CLIENT_UUID = 7;
   }
 }
 

remoting/signaling/BUILD.gn

@@ -6,6 +6,8 @@ static_library("signaling") {
   sources = [
     "delegating_signal_strategy.cc",
     "delegating_signal_strategy.h",
+    "ftl_client_uuid_device_id_provider.cc",
+    "ftl_client_uuid_device_id_provider.h",
     "ftl_device_id_provider.h",
     "ftl_grpc_context.cc",
     "ftl_grpc_context.h",
@@ -72,6 +74,8 @@ static_library("signaling") {
 
   if (is_nacl) {
     sources -= [
+      "ftl_client_uuid_device_id_provider.cc",
+      "ftl_client_uuid_device_id_provider.h",
       "ftl_grpc_context.cc",
       "ftl_grpc_context.h",
       "ftl_host_device_id_provider.cc",

remoting/signaling/ftl_client_uuid_device_id_provider.cc

+// 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_client_uuid_device_id_provider.h"
+
+#include "base/guid.h"
+
+namespace remoting {
+
+FtlClientUuidDeviceIdProvider::FtlClientUuidDeviceIdProvider()
+    : client_uuid_(base::GenerateGUID()) {}
+
+FtlClientUuidDeviceIdProvider::~FtlClientUuidDeviceIdProvider() = default;
+
+ftl::DeviceId FtlClientUuidDeviceIdProvider::GetDeviceId() {
+  ftl::DeviceId device_id;
+  device_id.set_type(ftl::DeviceIdType_Type_CLIENT_UUID);
+  device_id.set_id(client_uuid_);
+  return device_id;
+}
+
+}  // namespace remoting

remoting/ios/facade/ftl_device_id_provider_ios.h → remoting/signaling/ftl_client_uuid_device_id_provider.h

@@ -2,29 +2,28 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef REMOTING_IOS_FACADE_FTL_DEVICE_ID_PROVIDER_IOS_H_
-#define REMOTING_IOS_FACADE_FTL_DEVICE_ID_PROVIDER_IOS_H_
+#ifndef REMOTING_SIGNALING_FTL_CLIENT_UUID_DEVICE_ID_PROVIDER_H_
+#define REMOTING_SIGNALING_FTL_CLIENT_UUID_DEVICE_ID_PROVIDER_H_
 
 #include <string>
 
-#include "base/macros.h"
 #include "remoting/signaling/ftl_device_id_provider.h"
 
 namespace remoting {
 
-class FtlDeviceIdProviderIos final : public FtlDeviceIdProvider {
+// A device ID provider using ephemeral client UUIDs. A random UUID will be
+// generated on construction.
+class FtlClientUuidDeviceIdProvider : public FtlDeviceIdProvider {
  public:
-  FtlDeviceIdProviderIos();
-  ~FtlDeviceIdProviderIos() override;
+  FtlClientUuidDeviceIdProvider();
+  ~FtlClientUuidDeviceIdProvider() override;
 
   ftl::DeviceId GetDeviceId() override;
 
  private:
-  ftl::DeviceId device_id_;
-
-  DISALLOW_COPY_AND_ASSIGN(FtlDeviceIdProviderIos);
+  std::string client_uuid_;
 };
 
 }  // namespace remoting
 
-#endif  // REMOTING_IOS_FACADE_FTL_DEVICE_ID_PROVIDER_IOS_H_
+#endif  // REMOTING_SIGNALING_FTL_CLIENT_UUID_DEVICE_ID_PROVIDER_H_