[CrOS MultiDevice] Create RemoteDeviceProvider, which synchronously provides RemoteDevice objects.

This class encapsulates the creation of RemoteDevice objects, which are created asynchronously by RemoteDeviceLoader.

Bug: 
Change-Id: Ib9b14fba32dd4bfd6ef384b887d5c269449ca2a8
Reviewed-on: https://chromium-review.googlesource.com/576308Reviewed-by: Tim Song <tengs@chromium.org>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Commit-Queue: Kyle Horimoto <khorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#491216}

components/cryptauth/BUILD.gn

@@ -63,6 +63,8 @@ static_library("cryptauth") {
     "remote_device.h",
     "remote_device_loader.cc",
     "remote_device_loader.h",
+    "remote_device_provider.cc",
+    "remote_device_provider.h",
     "secure_channel.cc",
     "secure_channel.h",
     "secure_context.h",
@@ -170,6 +172,7 @@ source_set("unit_tests") {
     "raw_eid_generator_impl_unittest.cc",
     "remote_beacon_seed_fetcher_unittest.cc",
     "remote_device_loader_unittest.cc",
+    "remote_device_provider_unittest.cc",
     "secure_channel_unittest.cc",
     "session_keys_unittest.cc",
     "sync_scheduler_impl_unittest.cc",

components/cryptauth/cryptauth_device_manager.cc

@@ -336,6 +336,25 @@ CryptAuthDeviceManager::~CryptAuthDeviceManager() {
   }
 }
 
+void CryptAuthDeviceManager::SetSyncSchedulerForTest(
+    std::unique_ptr<SyncScheduler> sync_scheduler) {
+  scheduler_ = std::move(sync_scheduler);
+}
+
+void CryptAuthDeviceManager::NotifySyncStarted() {
+  for (auto& observer : observers_) {
+    observer.OnSyncStarted();
+  }
+}
+
+void CryptAuthDeviceManager::NotifySyncFinished(
+    SyncResult sync_result,
+    DeviceChangeResult device_change_result) {
+  for (auto& observer : observers_) {
+    observer.OnSyncFinished(sync_result, device_change_result);
+  }
+}
+
 // static
 void CryptAuthDeviceManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDoublePref(prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds,
@@ -464,12 +483,9 @@ void CryptAuthDeviceManager::OnGetMyDevicesSuccess(
   sync_request_->OnDidComplete(true);
   cryptauth_client_.reset();
   sync_request_.reset();
-  for (auto& observer : observers_) {
-    observer.OnSyncFinished(SyncResult::SUCCESS,
-                            unlock_keys_changed
-                                ? DeviceChangeResult::CHANGED
-                                : DeviceChangeResult::UNCHANGED);
-  }
+  NotifySyncFinished(SyncResult::SUCCESS, unlock_keys_changed
+                                              ? DeviceChangeResult::CHANGED
+                                              : DeviceChangeResult::UNCHANGED);
 }
 
 void CryptAuthDeviceManager::OnGetMyDevicesFailure(const std::string& error) {
@@ -479,8 +495,7 @@ void CryptAuthDeviceManager::OnGetMyDevicesFailure(const std::string& error) {
   sync_request_->OnDidComplete(false);
   cryptauth_client_.reset();
   sync_request_.reset();
-  for (auto& observer : observers_)
-    observer.OnSyncFinished(SyncResult::FAILURE, DeviceChangeResult::UNCHANGED);
+  NotifySyncFinished(SyncResult::FAILURE, DeviceChangeResult::UNCHANGED);
 }
 
 void CryptAuthDeviceManager::OnResyncMessage() {
@@ -510,8 +525,7 @@ void CryptAuthDeviceManager::UpdateUnlockKeysFromPrefs() {
 
 void CryptAuthDeviceManager::OnSyncRequested(
     std::unique_ptr<SyncScheduler::SyncRequest> sync_request) {
-  for (auto& observer : observers_)
-    observer.OnSyncStarted();
+  NotifySyncStarted();
 
   sync_request_ = std::move(sync_request);
   cryptauth_client_ = client_factory_->CreateInstance();

components/cryptauth/cryptauth_device_manager.h

@@ -119,9 +119,15 @@ class CryptAuthDeviceManager : public SyncScheduler::Delegate,
   // use this constructor outside of tests.
   CryptAuthDeviceManager();
 
-  void SetSyncSchedulerForTest(std::unique_ptr<SyncScheduler> sync_scheduler) {
-    scheduler_ = std::move(sync_scheduler);
-  }
+  void SetSyncSchedulerForTest(std::unique_ptr<SyncScheduler> sync_scheduler);
+
+  // Invokes OnSyncStarted() on all observers.
+  void NotifySyncStarted();
+
+  // Invokes OnSyncFinished(|sync_result|, |device_change_result|) on all
+  // observers.
+  void NotifySyncFinished(SyncResult sync_result,
+                          DeviceChangeResult device_change_result);
 
  private:
   // CryptAuthGCMManager::Observer:

components/cryptauth/remote_device_provider.cc

+// Copyright 2017 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 "components/cryptauth/remote_device_provider.h"
+
+#include "base/bind.h"
+#include "components/cryptauth/remote_device_loader.h"
+#include "components/cryptauth/secure_message_delegate.h"
+
+namespace cryptauth {
+
+RemoteDeviceProvider::RemoteDeviceProvider(
+    CryptAuthDeviceManager* device_manager,
+    const std::string& user_id,
+    const std::string& user_private_key,
+    SecureMessageDelegateFactory* secure_message_delegate_factory)
+    : device_manager_(device_manager),
+      user_id_(user_id),
+      user_private_key_(user_private_key),
+      secure_message_delegate_factory_(secure_message_delegate_factory),
+      weak_ptr_factory_(this) {
+  device_manager_->AddObserver(this);
+  remote_device_loader_ = cryptauth::RemoteDeviceLoader::Factory::NewInstance(
+      device_manager->GetSyncedDevices(), user_id, user_private_key,
+      secure_message_delegate_factory->CreateSecureMessageDelegate());
+  remote_device_loader_->Load(
+      false /* should_load_beacon_seeds */,
+      base::Bind(&RemoteDeviceProvider::OnRemoteDevicesLoaded,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+RemoteDeviceProvider::~RemoteDeviceProvider() {
+  device_manager_->RemoveObserver(this);
+}
+
+void RemoteDeviceProvider::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void RemoteDeviceProvider::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void RemoteDeviceProvider::OnSyncFinished(
+    CryptAuthDeviceManager::SyncResult sync_result,
+    CryptAuthDeviceManager::DeviceChangeResult device_change_result) {
+  if (sync_result == CryptAuthDeviceManager::SyncResult::SUCCESS &&
+      device_change_result ==
+          CryptAuthDeviceManager::DeviceChangeResult::CHANGED) {
+    remote_device_loader_ = cryptauth::RemoteDeviceLoader::Factory::NewInstance(
+        device_manager_->GetSyncedDevices(), user_id_, user_private_key_,
+        secure_message_delegate_factory_->CreateSecureMessageDelegate());
+
+    remote_device_loader_->Load(
+        false /* should_load_beacon_seeds */,
+        base::Bind(&RemoteDeviceProvider::OnRemoteDevicesLoaded,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+}
+
+void RemoteDeviceProvider::OnRemoteDevicesLoaded(
+    const RemoteDeviceList& synced_remote_devices) {
+  synced_remote_devices_ = synced_remote_devices;
+  remote_device_loader_.reset();
+
+  // Notify observers of change. Note that there is no need to check if
+  // |synced_remote_devices_| has changed here because the fetch is only started
+  // if the change result passed to OnSyncFinished() is CHANGED.
+  for (auto& observer : observers_) {
+    observer.OnSyncDeviceListChanged();
+  }
+}
+
+const RemoteDeviceList RemoteDeviceProvider::GetSyncedDevices() const {
+  return synced_remote_devices_;
+}
+
+}  // namespace cryptauth
\ No newline at end of file

components/cryptauth/remote_device_provider.h

+// Copyright 2017 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 COMPONENTS_CRYPTAUTH_REMOTE_DEVICE_PROVIDER_H_
+#define COMPONENTS_CRYPTAUTH_REMOTE_DEVICE_PROVIDER_H_
+
+#include "components/cryptauth/cryptauth_device_manager.h"
+#include "components/cryptauth/remote_device.h"
+
+namespace cryptauth {
+
+class RemoteDeviceLoader;
+class SecureMessageDelegate;
+
+// TODO(khorimoto): Move SecureMessageDelegateFactory to another file.
+class SecureMessageDelegateFactory {
+ public:
+  virtual std::unique_ptr<SecureMessageDelegate>
+  CreateSecureMessageDelegate() = 0;
+  virtual ~SecureMessageDelegateFactory(){};
+};
+
+// This class generates and caches RemoteDevice objects when associated metadata
+// has been synced, and updates this cache when a new sync occurs.
+class RemoteDeviceProvider : public CryptAuthDeviceManager::Observer {
+ public:
+  class Observer {
+   public:
+    virtual void OnSyncDeviceListChanged() {}
+
+   protected:
+    virtual ~Observer() {}
+  };
+
+  RemoteDeviceProvider(
+      CryptAuthDeviceManager* device_manager,
+      const std::string& user_id,
+      const std::string& user_private_key,
+      SecureMessageDelegateFactory* secure_message_delegate_factory);
+
+  ~RemoteDeviceProvider() override;
+
+  void AddObserver(Observer* observer);
+  void RemoveObserver(Observer* observer);
+
+  // Returns a list of all RemoteDevices that have been synced.
+  const RemoteDeviceList GetSyncedDevices() const;
+
+  // CryptAuthDeviceManager::Observer:
+  void OnSyncFinished(
+      CryptAuthDeviceManager::SyncResult sync_result,
+      CryptAuthDeviceManager::DeviceChangeResult device_change_result) override;
+
+ private:
+  void OnRemoteDevicesLoaded(const RemoteDeviceList& synced_remote_devices);
+
+  // To get ExternalDeviceInfo needed to retrieve RemoteDevices.
+  CryptAuthDeviceManager* device_manager_;
+
+  // The account ID of the current user.
+  const std::string user_id_;
+
+  // The private key used to generate RemoteDevices.
+  const std::string user_private_key_;
+
+  SecureMessageDelegateFactory* secure_message_delegate_factory_;
+  std::unique_ptr<RemoteDeviceLoader> remote_device_loader_;
+  RemoteDeviceList synced_remote_devices_;
+  base::ObserverList<Observer> observers_;
+  base::WeakPtrFactory<RemoteDeviceProvider> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoteDeviceProvider);
+};
+
+}  // namespace cryptauth
+
+#endif  // COMPONENTS_CRYPTAUTH_REMOTE_DEVICE_PROVIDER_H_