[CrOS MultiDevice] Add test double for DeviceCapabilityManager.

Add FakeDeviceCapabilityManager, DeviceCapabilityManagerImpl,
and a factory for DeviceCapabilityManager.

Make DeviceCapabilityManager a pure virtual base class.

Bug: 752273
Change-Id: Ibf29b3a2cf893c2144315134e751884460ea3cd7
Reviewed-on: https://chromium-review.googlesource.com/671196
Commit-Queue: Regan Hsu <hsuregan@google.com>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#503650}

components/cryptauth/BUILD.gn

@@ -39,8 +39,9 @@ static_library("cryptauth") {
     "cryptauth_service.h",
     "data_with_timestamp.cc",
     "data_with_timestamp.h",
-    "device_capability_manager.cc",
     "device_capability_manager.h",
+    "device_capability_manager_impl.cc",
+    "device_capability_manager_impl.h",
     "device_to_device_authenticator.cc",
     "device_to_device_authenticator.h",
     "device_to_device_initiator_helper.cc",
@@ -119,6 +120,8 @@ static_library("test_support") {
     "fake_cryptauth_gcm_manager.h",
     "fake_cryptauth_service.cc",
     "fake_cryptauth_service.h",
+    "fake_device_capability_manager.cc",
+    "fake_device_capability_manager.h",
     "fake_remote_device_provider.cc",
     "fake_remote_device_provider.h",
     "fake_secure_channel.cc",
@@ -165,7 +168,7 @@ source_set("unit_tests") {
     "cryptauth_enroller_impl_unittest.cc",
     "cryptauth_enrollment_manager_unittest.cc",
     "cryptauth_gcm_manager_impl_unittest.cc",
-    "device_capability_manager_unittest.cc",
+    "device_capability_manager_impl_unittest.cc",
     "device_to_device_authenticator_unittest.cc",
     "device_to_device_operations_unittest.cc",
     "device_to_device_secure_context_unittest.cc",

components/cryptauth/device_capability_manager.h

@@ -5,12 +5,7 @@
 #ifndef COMPONENTS_CRYPTAUTH_DEVICE_CAPABILITY_MANAGER_H_
 #define COMPONENTS_CRYPTAUTH_DEVICE_CAPABILITY_MANAGER_H_
 
-#include "base/bind.h"
-#include "base/callback_forward.h"
-#include "base/containers/queue.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/weak_ptr.h"
-#include "components/cryptauth/cryptauth_client.h"
+#include "base/callback.h"
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
 
 namespace cryptauth {
@@ -18,124 +13,33 @@ namespace cryptauth {
 // DeviceCapabilityManager sends requests to the back-end which enable/disable
 // device capabilities and finds devices which contain those capabilities. Here,
 // the term "capability" refers to the ability of a device to use a given
-// feature (e.g. EasyUnlock or Magic Tether).
+// feature (e.g. EasyUnlock or Instant Tethering).
 class DeviceCapabilityManager {
  public:
   // CAPABILITY_UNLOCK_KEY refers to EasyUnlock.
   enum class Capability { CAPABILITY_UNLOCK_KEY };
 
-  DeviceCapabilityManager(CryptAuthClientFactory* cryptauth_client_factory);
+  virtual ~DeviceCapabilityManager(){};
 
-  ~DeviceCapabilityManager();
-
-  // Enables or disables |capability| for the device corresponding to
-  // |public_key|. In error cases, |error_callback| is invoked with an error
-  // string.
-  void SetCapabilityEnabled(
+  virtual void SetCapabilityEnabled(
       const std::string& public_key,
       Capability capability,
       bool enabled,
       const base::Closure& success_callback,
-      const base::Callback<void(const std::string&)>& error_callback);
+      const base::Callback<void(const std::string&)>& error_callback) = 0;
 
-  // Fetches metadata about the device which are eligible for |capability|. In
-  // error cases, |error_callback| is invoked with an error string.
-  void FindEligibleDevicesForCapability(
+  virtual void FindEligibleDevicesForCapability(
       Capability capability,
       const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
                                 const std::vector<IneligibleDevice>&)>&
           success_callback,
-      const base::Callback<void(const std::string&)>& error_callback);
+      const base::Callback<void(const std::string&)>& error_callback) = 0;
 
-  // Determines whether a device with |public_key| is promotable for
-  // |capability|. In error cases, |error_callback| is invoked with an error
-  // string.
-  void IsCapabilityPromotable(
+  virtual void IsCapabilityPromotable(
       const std::string& public_key,
       Capability capability,
       const base::Callback<void(bool)>& success_callback,
-      const base::Callback<void(const std::string&)>& error_callback);
-
- private:
-  enum class RequestType {
-    SET_CAPABILITY_ENABLED,
-    FIND_ELIGIBLE_DEVICES_FOR_CAPABILITY,
-    IS_CAPABILITY_PROMOTABLE
-  };
-
-  struct Request {
-    // Used for SET_CAPABILITY_ENABLED Requests.
-    Request(RequestType request_type,
-            Capability capability,
-            std::string public_key,
-            bool enabled,
-            const base::Closure& set_capability_callback,
-            const base::Callback<void(const std::string&)>& error_callback);
-
-    // Used for FIND_ELIGIBLE_DEVICES_FOR_CAPABILITY Requests.
-    Request(RequestType request_type,
-            Capability capability,
-            const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
-                                      const std::vector<IneligibleDevice>&)>&
-                find_eligible_devices_callback,
-            const base::Callback<void(const std::string&)>& error_callback);
-
-    // Used for IS_CAPABILITY_PROMOTABLE Requests.
-    Request(RequestType request_type,
-            Capability capability,
-            std::string public_key,
-            const base::Callback<void(bool)> is_device_promotable_callback,
-            const base::Callback<void(const std::string&)>& error_callback);
-
-    ~Request();
-
-    // Defined for every request.
-    RequestType request_type;
-    base::Callback<void(const std::string&)> error_callback;
-    Capability capability;
-
-    // Defined for SET_CAPABILITY_ENABLED and IS_CAPABILITY_PROMOTABLE;
-    // otherwise, unused.
-    std::string public_key;
-
-    // Defined if |request_type_| is SET_CAPABILITY_ENABLED; otherwise, unused.
-    base::Closure set_capability_callback;
-    bool enabled;
-
-    // Defined if |request_type_| is FIND_ELIGIBLE_DEVICES_FOR_CAPABILITY;
-    // otherwise, unused.
-    base::Callback<void(const std::vector<ExternalDeviceInfo>&,
-                        const std::vector<IneligibleDevice>&)>
-        find_eligible_devices_callback;
-
-    // Defined if |request_type_| is IS_CAPABILITY_PROMOTABLE; otherwise,
-    // unused.
-    base::Callback<void(bool)> is_device_promotable_callback;
-  };
-
-  void CreateNewCryptAuthClient();
-
-  void ProcessSetCapabilityEnabledRequest();
-  void ProcessFindEligibleDevicesForCapability();
-  void ProcessIsCapabilityPromotableRequest();
-
-  void SetUnlockKeyCapability();
-  void FindEligibleUnlockDevices();
-  void IsDeviceUnlockPromotable();
-
-  void OnToggleEasyUnlockResponse(const ToggleEasyUnlockResponse& response);
-  void OnFindEligibleUnlockDevicesResponse(
-      const FindEligibleUnlockDevicesResponse& response);
-  void OnIsDeviceUnlockPromotableResponse(
-      const FindEligibleForPromotionResponse& response);
-  void OnErrorResponse(const std::string& response);
-  void ProcessRequestQueue();
-
-  std::unique_ptr<CryptAuthClient> current_cryptauth_client_;
-  std::unique_ptr<Request> current_request_;
-  base::queue<std::unique_ptr<Request>> pending_requests_;
-  CryptAuthClientFactory* crypt_auth_client_factory_;
-  base::WeakPtrFactory<DeviceCapabilityManager> weak_ptr_factory_;
+      const base::Callback<void(const std::string&)>& error_callback) = 0;
 };
 }  // namespace cryptauth
 

components/cryptauth/device_capability_manager.cc → components/cryptauth/device_capability_manager_impl.cc

@@ -2,21 +2,47 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "components/cryptauth/device_capability_manager.h"
+#include "components/cryptauth/device_capability_manager_impl.h"
 
 #include "base/logging.h"
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
 
 namespace cryptauth {
 
-DeviceCapabilityManager::DeviceCapabilityManager(
+// static
+DeviceCapabilityManagerImpl::Factory*
+    DeviceCapabilityManagerImpl::Factory::factory_instance_ = nullptr;
+
+// static
+std::unique_ptr<DeviceCapabilityManager>
+DeviceCapabilityManagerImpl::Factory::NewInstance(
+    CryptAuthClientFactory* cryptauth_client_factory) {
+  if (!factory_instance_) {
+    factory_instance_ = new Factory();
+  }
+  return factory_instance_->BuildInstance(cryptauth_client_factory);
+}
+
+void DeviceCapabilityManagerImpl::Factory::SetInstanceForTesting(
+    Factory* factory) {
+  factory_instance_ = factory;
+}
+
+std::unique_ptr<DeviceCapabilityManager>
+DeviceCapabilityManagerImpl::Factory::BuildInstance(
+    CryptAuthClientFactory* cryptauth_client_factory) {
+  return base::WrapUnique(
+      new DeviceCapabilityManagerImpl(cryptauth_client_factory));
+}
+
+DeviceCapabilityManagerImpl::DeviceCapabilityManagerImpl(
     CryptAuthClientFactory* cryptauth_client_factory)
     : crypt_auth_client_factory_(cryptauth_client_factory),
       weak_ptr_factory_(this) {}
 
-DeviceCapabilityManager::~DeviceCapabilityManager() {}
+DeviceCapabilityManagerImpl::~DeviceCapabilityManagerImpl() {}
 
-void DeviceCapabilityManager::SetCapabilityEnabled(
+void DeviceCapabilityManagerImpl::SetCapabilityEnabled(
     const std::string& public_key,
     Capability capability,
     bool enabled,
@@ -28,7 +54,7 @@ void DeviceCapabilityManager::SetCapabilityEnabled(
   ProcessRequestQueue();
 }
 
-void DeviceCapabilityManager::FindEligibleDevicesForCapability(
+void DeviceCapabilityManagerImpl::FindEligibleDevicesForCapability(
     Capability capability,
     const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
                               const std::vector<IneligibleDevice>&)>&
@@ -40,7 +66,7 @@ void DeviceCapabilityManager::FindEligibleDevicesForCapability(
   ProcessRequestQueue();
 }
 
-void DeviceCapabilityManager::IsCapabilityPromotable(
+void DeviceCapabilityManagerImpl::IsCapabilityPromotable(
     const std::string& public_key,
     Capability capability,
     const base::Callback<void(bool)>& success_callback,
@@ -51,7 +77,7 @@ void DeviceCapabilityManager::IsCapabilityPromotable(
   ProcessRequestQueue();
 }
 
-DeviceCapabilityManager::Request::Request(
+DeviceCapabilityManagerImpl::Request::Request(
     RequestType request_type,
     Capability capability,
     std::string public_key,
@@ -65,7 +91,7 @@ DeviceCapabilityManager::Request::Request(
       set_capability_callback(set_capability_callback),
       enabled(enabled) {}
 
-DeviceCapabilityManager::Request::Request(
+DeviceCapabilityManagerImpl::Request::Request(
     RequestType request_type,
     Capability capability,
     const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
@@ -77,7 +103,7 @@ DeviceCapabilityManager::Request::Request(
       capability(capability),
       find_eligible_devices_callback(find_eligible_devices_callback) {}
 
-DeviceCapabilityManager::Request::Request(
+DeviceCapabilityManagerImpl::Request::Request(
     RequestType request_type,
     Capability capability,
     std::string public_key,
@@ -89,29 +115,29 @@ DeviceCapabilityManager::Request::Request(
       public_key(public_key),
       is_device_promotable_callback(is_device_promotable_callback) {}
 
-DeviceCapabilityManager::Request::~Request() {}
+DeviceCapabilityManagerImpl::Request::~Request() {}
 
-void DeviceCapabilityManager::CreateNewCryptAuthClient() {
+void DeviceCapabilityManagerImpl::CreateNewCryptAuthClient() {
   DCHECK(!current_cryptauth_client_);
   current_cryptauth_client_ = crypt_auth_client_factory_->CreateInstance();
 }
 
-void DeviceCapabilityManager::ProcessSetCapabilityEnabledRequest() {
+void DeviceCapabilityManagerImpl::ProcessSetCapabilityEnabledRequest() {
   DCHECK(current_request_->capability == Capability::CAPABILITY_UNLOCK_KEY);
   SetUnlockKeyCapability();
 }
 
-void DeviceCapabilityManager::ProcessFindEligibleDevicesForCapability() {
+void DeviceCapabilityManagerImpl::ProcessFindEligibleDevicesForCapability() {
   DCHECK(current_request_->capability == Capability::CAPABILITY_UNLOCK_KEY);
   FindEligibleUnlockDevices();
 }
 
-void DeviceCapabilityManager::ProcessIsCapabilityPromotableRequest() {
+void DeviceCapabilityManagerImpl::ProcessIsCapabilityPromotableRequest() {
   DCHECK(current_request_->capability == Capability::CAPABILITY_UNLOCK_KEY);
   IsDeviceUnlockPromotable();
 }
 
-void DeviceCapabilityManager::SetUnlockKeyCapability() {
+void DeviceCapabilityManagerImpl::SetUnlockKeyCapability() {
   CreateNewCryptAuthClient();
 
   ToggleEasyUnlockRequest request;
@@ -121,24 +147,25 @@ void DeviceCapabilityManager::SetUnlockKeyCapability() {
 
   current_cryptauth_client_->ToggleEasyUnlock(
       request,
-      base::Bind(&DeviceCapabilityManager::OnToggleEasyUnlockResponse,
+      base::Bind(&DeviceCapabilityManagerImpl::OnToggleEasyUnlockResponse,
                  weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&DeviceCapabilityManager::OnErrorResponse,
+      base::Bind(&DeviceCapabilityManagerImpl::OnErrorResponse,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void DeviceCapabilityManager::FindEligibleUnlockDevices() {
+void DeviceCapabilityManagerImpl::FindEligibleUnlockDevices() {
   CreateNewCryptAuthClient();
 
   current_cryptauth_client_->FindEligibleUnlockDevices(
       FindEligibleUnlockDevicesRequest(),
-      base::Bind(&DeviceCapabilityManager::OnFindEligibleUnlockDevicesResponse,
+      base::Bind(
+          &DeviceCapabilityManagerImpl::OnFindEligibleUnlockDevicesResponse,
           weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&DeviceCapabilityManager::OnErrorResponse,
+      base::Bind(&DeviceCapabilityManagerImpl::OnErrorResponse,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void DeviceCapabilityManager::IsDeviceUnlockPromotable() {
+void DeviceCapabilityManagerImpl::IsDeviceUnlockPromotable() {
   CreateNewCryptAuthClient();
 
   FindEligibleForPromotionRequest request;
@@ -146,13 +173,14 @@ void DeviceCapabilityManager::IsDeviceUnlockPromotable() {
 
   current_cryptauth_client_->FindEligibleForPromotion(
       request,
-      base::Bind(&DeviceCapabilityManager::OnIsDeviceUnlockPromotableResponse,
+      base::Bind(
+          &DeviceCapabilityManagerImpl::OnIsDeviceUnlockPromotableResponse,
           weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&DeviceCapabilityManager::OnErrorResponse,
+      base::Bind(&DeviceCapabilityManagerImpl::OnErrorResponse,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void DeviceCapabilityManager::OnToggleEasyUnlockResponse(
+void DeviceCapabilityManagerImpl::OnToggleEasyUnlockResponse(
     const ToggleEasyUnlockResponse& response) {
   current_cryptauth_client_.reset();
   current_request_->set_capability_callback.Run();
@@ -160,7 +188,7 @@ void DeviceCapabilityManager::OnToggleEasyUnlockResponse(
   ProcessRequestQueue();
 }
 
-void DeviceCapabilityManager::OnFindEligibleUnlockDevicesResponse(
+void DeviceCapabilityManagerImpl::OnFindEligibleUnlockDevicesResponse(
     const FindEligibleUnlockDevicesResponse& response) {
   current_cryptauth_client_.reset();
   current_request_->find_eligible_devices_callback.Run(
@@ -172,7 +200,7 @@ void DeviceCapabilityManager::OnFindEligibleUnlockDevicesResponse(
   ProcessRequestQueue();
 }
 
-void DeviceCapabilityManager::OnIsDeviceUnlockPromotableResponse(
+void DeviceCapabilityManagerImpl::OnIsDeviceUnlockPromotableResponse(
     const FindEligibleForPromotionResponse& response) {
   current_cryptauth_client_.reset();
   current_request_->is_device_promotable_callback.Run(
@@ -181,14 +209,14 @@ void DeviceCapabilityManager::OnIsDeviceUnlockPromotableResponse(
   ProcessRequestQueue();
 }
 
-void DeviceCapabilityManager::OnErrorResponse(const std::string& response) {
+void DeviceCapabilityManagerImpl::OnErrorResponse(const std::string& response) {
   current_cryptauth_client_.reset();
   current_request_->error_callback.Run(response);
   current_request_.reset();
   ProcessRequestQueue();
 }
 
-void DeviceCapabilityManager::ProcessRequestQueue() {
+void DeviceCapabilityManagerImpl::ProcessRequestQueue() {
   if (current_request_ || pending_requests_.empty())
     return;
 

components/cryptauth/device_capability_manager_impl.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_DEVICE_CAPABILITY_MANAGER_IMPL_H_
+#define COMPONENTS_CRYPTAUTH_DEVICE_CAPABILITY_MANAGER_IMPL_H_
+
+#include "base/bind.h"
+#include "base/callback_forward.h"
+#include "base/containers/queue.h"
+#include "base/memory/ptr_util.h"
+#include "base/memory/weak_ptr.h"
+#include "components/cryptauth/cryptauth_client.h"
+#include "components/cryptauth/device_capability_manager.h"
+#include "components/cryptauth/proto/cryptauth_api.pb.h"
+
+namespace cryptauth {
+
+using Capability = DeviceCapabilityManager::Capability;
+
+// Concrete DeviceCapabilityManager implementation.
+class DeviceCapabilityManagerImpl : public DeviceCapabilityManager {
+ public:
+  class Factory {
+   public:
+    static std::unique_ptr<DeviceCapabilityManager> NewInstance(
+        CryptAuthClientFactory* cryptauth_client_factory);
+
+    static void SetInstanceForTesting(Factory* factory);
+
+   protected:
+    virtual std::unique_ptr<DeviceCapabilityManager> BuildInstance(
+        CryptAuthClientFactory* cryptauth_client_factory);
+
+   private:
+    static Factory* factory_instance_;
+  };
+
+  DeviceCapabilityManagerImpl(CryptAuthClientFactory* cryptauth_client_factory);
+
+  ~DeviceCapabilityManagerImpl() override;
+
+  // Enables or disables |capability| for the device corresponding to
+  // |public_key|. In error cases, |error_callback| is invoked with an error
+  // string.
+  void SetCapabilityEnabled(
+      const std::string& public_key,
+      Capability capability,
+      bool enabled,
+      const base::Closure& success_callback,
+      const base::Callback<void(const std::string&)>& error_callback) override;
+
+  // Fetches metadata about the device which are eligible for |capability|. In
+  // error cases, |error_callback| is invoked with an error string.
+  void FindEligibleDevicesForCapability(
+      Capability capability,
+      const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
+                                const std::vector<IneligibleDevice>&)>&
+          success_callback,
+      const base::Callback<void(const std::string&)>& error_callback) override;
+
+  // Determines whether a device with |public_key| is promotable for
+  // |capability|. In error cases, |error_callback| is invoked with an error
+  // string.
+  void IsCapabilityPromotable(
+      const std::string& public_key,
+      Capability capability,
+      const base::Callback<void(bool)>& success_callback,
+      const base::Callback<void(const std::string&)>& error_callback) override;
+
+ private:
+  enum class RequestType {
+    SET_CAPABILITY_ENABLED,
+    FIND_ELIGIBLE_DEVICES_FOR_CAPABILITY,
+    IS_CAPABILITY_PROMOTABLE
+  };
+
+  struct Request {
+    // Used for SET_CAPABILITY_ENABLED Requests.
+    Request(RequestType request_type,
+            Capability capability,
+            std::string public_key,
+            bool enabled,
+            const base::Closure& set_capability_callback,
+            const base::Callback<void(const std::string&)>& error_callback);
+
+    // Used for FIND_ELIGIBLE_DEVICES_FOR_CAPABILITY Requests.
+    Request(RequestType request_type,
+            Capability capability,
+            const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
+                                      const std::vector<IneligibleDevice>&)>&
+                find_eligible_devices_callback,
+            const base::Callback<void(const std::string&)>& error_callback);
+
+    // Used for IS_CAPABILITY_PROMOTABLE Requests.
+    Request(RequestType request_type,
+            Capability capability,
+            std::string public_key,
+            const base::Callback<void(bool)> is_device_promotable_callback,
+            const base::Callback<void(const std::string&)>& error_callback);
+
+    ~Request();
+
+    // Defined for every request.
+    RequestType request_type;
+    base::Callback<void(const std::string&)> error_callback;
+    Capability capability;
+
+    // Defined for SET_CAPABILITY_ENABLED and IS_CAPABILITY_PROMOTABLE;
+    // otherwise, unused.
+    std::string public_key;
+
+    // Defined if |request_type_| is SET_CAPABILITY_ENABLED; otherwise, unused.
+    base::Closure set_capability_callback;
+    bool enabled;
+
+    // Defined if |request_type_| is FIND_ELIGIBLE_DEVICES_FOR_CAPABILITY;
+    // otherwise, unused.
+    base::Callback<void(const std::vector<ExternalDeviceInfo>&,
+                        const std::vector<IneligibleDevice>&)>
+        find_eligible_devices_callback;
+
+    // Defined if |request_type_| is IS_CAPABILITY_PROMOTABLE; otherwise,
+    // unused.
+    base::Callback<void(bool)> is_device_promotable_callback;
+  };
+
+  void CreateNewCryptAuthClient();
+
+  void ProcessSetCapabilityEnabledRequest();
+  void ProcessFindEligibleDevicesForCapability();
+  void ProcessIsCapabilityPromotableRequest();
+
+  void SetUnlockKeyCapability();
+  void FindEligibleUnlockDevices();
+  void IsDeviceUnlockPromotable();
+
+  void OnToggleEasyUnlockResponse(const ToggleEasyUnlockResponse& response);
+  void OnFindEligibleUnlockDevicesResponse(
+      const FindEligibleUnlockDevicesResponse& response);
+  void OnIsDeviceUnlockPromotableResponse(
+      const FindEligibleForPromotionResponse& response);
+  void OnErrorResponse(const std::string& response);
+  void ProcessRequestQueue();
+
+  std::unique_ptr<CryptAuthClient> current_cryptauth_client_;
+  std::unique_ptr<Request> current_request_;
+  base::queue<std::unique_ptr<Request>> pending_requests_;
+  CryptAuthClientFactory* crypt_auth_client_factory_;
+  base::WeakPtrFactory<DeviceCapabilityManagerImpl> weak_ptr_factory_;
+};
+}  // namespace cryptauth
+
+#endif  // COMPONENTS_CRYPTAUTH_DEVICE_CAPABILITY_MANAGER_IMPL_H_

components/cryptauth/fake_device_capability_manager.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/fake_device_capability_manager.h"
+
+namespace cryptauth {
+
+FakeDeviceCapabilityManager::FakeDeviceCapabilityManager() {}
+
+FakeDeviceCapabilityManager::~FakeDeviceCapabilityManager() {}
+
+void FakeDeviceCapabilityManager::SetCapabilityEnabled(
+    const std::string& public_key,
+    Capability capability,
+    bool enabled,
+    const base::Closure& success_callback,
+    const base::Callback<void(const std::string&)>& error_callback) {
+  if (set_capability_enabled_error_code_.empty()) {
+    success_callback.Run();
+    return;
+  }
+  error_callback.Run(std::move(set_capability_enabled_error_code_));
+}
+
+void FakeDeviceCapabilityManager::FindEligibleDevicesForCapability(
+    Capability capability,
+    const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
+                              const std::vector<IneligibleDevice>&)>&
+        success_callback,
+    const base::Callback<void(const std::string&)>& error_callback) {
+  if (find_eligible_devices_for_capability_error_code_.empty()) {
+    success_callback.Run(external_device_infos_, ineligible_devices_);
+    return;
+  }
+  error_callback.Run(find_eligible_devices_for_capability_error_code_);
+}
+
+void FakeDeviceCapabilityManager::IsCapabilityPromotable(
+    const std::string& public_key,
+    Capability capability,
+    const base::Callback<void(bool)>& success_callback,
+    const base::Callback<void(const std::string&)>& error_callback) {
+  if (is_capability_promotable_error_code_.empty()) {
+    success_callback.Run(true /* capability is promotable */);
+    return;
+  }
+  error_callback.Run(is_capability_promotable_error_code_);
+}
+
+}  // namespace cryptauth
\ No newline at end of file

components/cryptauth/fake_device_capability_manager.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_FAKE_DEVICE_CAPABILITY_MANAGER_H_
+#define COMPONENTS_CRYPTAUTH_FAKE_DEVICE_CAPABILITY_MANAGER_H_
+
+#include "base/callback.h"
+#include "components/cryptauth/device_capability_manager.h"
+#include "components/cryptauth/proto/cryptauth_api.pb.h"
+
+namespace cryptauth {
+
+using Capability = DeviceCapabilityManager::Capability;
+
+// Test double for Device Capability Manager.
+class FakeDeviceCapabilityManager : public cryptauth::DeviceCapabilityManager {
+ public:
+  FakeDeviceCapabilityManager();
+
+  ~FakeDeviceCapabilityManager() override;
+
+  void set_find_eligible_devices_for_capability_error_code(
+      std::string error_code) {
+    find_eligible_devices_for_capability_error_code_ = error_code;
+  }
+
+  void set_capability_enabled_error_code(std::string error_code) {
+    set_capability_enabled_error_code_ = error_code;
+    LOG(ERROR) << set_capability_enabled_error_code_;
+  }
+
+  void set_is_capability_promotable_error_code(std::string error_code) {
+    is_capability_promotable_error_code_ = error_code;
+  }
+
+  void set_external_device_info(
+      std::vector<ExternalDeviceInfo> external_device_infos) {
+    external_device_infos_ = external_device_infos;
+  }
+
+  void set_ineligible_devices(
+      std::vector<IneligibleDevice> ineligible_devices) {
+    ineligible_devices_ = ineligible_devices;
+  }
+
+  // cryptauth::DeviceCapabilityManager:
+  void SetCapabilityEnabled(
+      const std::string& public_key,
+      Capability capability,
+      bool enabled,
+      const base::Closure& success_callback,
+      const base::Callback<void(const std::string&)>& error_callback) override;
+
+  void FindEligibleDevicesForCapability(
+      Capability capability,
+      const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
+                                const std::vector<IneligibleDevice>&)>&
+          success_callback,
+      const base::Callback<void(const std::string&)>& error_callback) override;
+
+  void IsCapabilityPromotable(
+      const std::string& public_key,
+      Capability capability,
+      const base::Callback<void(bool)>& success_callback,
+      const base::Callback<void(const std::string&)>& error_callback) override;
+
+  std::string set_capability_enabled_error_code_;
+  std::string find_eligible_devices_for_capability_error_code_;
+  std::string is_capability_promotable_error_code_;
+  std::vector<ExternalDeviceInfo> external_device_infos_;
+  std::vector<IneligibleDevice> ineligible_devices_;
+};
+}  // namespace cryptauth
+
+#endif  // COMPONENTS_CRYPTAUTH_FAKE_DEVICE_CAPABILITY_MANAGER_H_