[Nearby] Add local device data updater

The local device data updater builds and queues UpdateDevice RPC
requests. It uses the Nearby Share HTTP client to make the calls when
ready. It also enforces the specified timeout.

Bug: b/157685298
Change-Id: I27372ccfdb27307c5a048b4293a4eac005f61a40
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2280581Reviewed-by: James Vecore <vecore@google.com>
Commit-Queue: Josh Nohle <nohle@chromium.org>
Cr-Commit-Position: refs/heads/master@{#789725}

chrome/browser/BUILD.gn

@@ -3735,6 +3735,7 @@ static_library("browser") {
       "//chrome/browser/nearby_sharing/certificates",
       "//chrome/browser/nearby_sharing/client",
       "//chrome/browser/nearby_sharing/instantmessaging/proto",
+      "//chrome/browser/nearby_sharing/local_device_data",
       "//chrome/browser/nearby_sharing/logging",
       "//chrome/browser/nearby_sharing/logging:util",
       "//chrome/browser/nearby_sharing/proto",

chrome/browser/nearby_sharing/local_device_data/BUILD.gn

+# Copyright 2020 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.
+
+source_set("local_device_data") {
+  sources = [
+    "nearby_share_device_data_updater.cc",
+    "nearby_share_device_data_updater.h",
+    "nearby_share_device_data_updater_impl.cc",
+    "nearby_share_device_data_updater_impl.h",
+  ]
+
+  deps = [
+    "//base",
+    "//chrome/browser/nearby_sharing/client",
+    "//chrome/browser/nearby_sharing/proto",
+  ]
+}
+
+source_set("test_support") {
+  testonly = true
+
+  sources = [
+    "fake_nearby_share_device_data_updater.cc",
+    "fake_nearby_share_device_data_updater.h",
+  ]
+
+  deps = [
+    ":local_device_data",
+    "//base",
+    "//chrome/browser/nearby_sharing/proto",
+  ]
+}
+
+source_set("unit_tests") {
+  testonly = true
+
+  sources = [ "nearby_share_device_data_updater_impl_unittest.cc" ]
+
+  deps = [
+    ":local_device_data",
+    "//base",
+    "//base/test:test_support",
+    "//chrome/browser/nearby_sharing/client",
+    "//chrome/browser/nearby_sharing/client:test_support",
+    "//chrome/browser/nearby_sharing/proto",
+    "//testing/gtest",
+  ]
+}

chrome/browser/nearby_sharing/local_device_data/fake_nearby_share_device_data_updater.cc

+// Copyright 2020 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/nearby_sharing/local_device_data/fake_nearby_share_device_data_updater.h"
+
+FakeNearbyShareDeviceDataUpdater::FakeNearbyShareDeviceDataUpdater(
+    const std::string& device_id)
+    : NearbyShareDeviceDataUpdater(device_id) {}
+
+FakeNearbyShareDeviceDataUpdater::~FakeNearbyShareDeviceDataUpdater() = default;
+
+void FakeNearbyShareDeviceDataUpdater::RunNextRequest(
+    bool success,
+    const base::Optional<nearbyshare::proto::UpdateDeviceResponse>& response) {
+  FinishAttempt(success, response);
+}
+
+void FakeNearbyShareDeviceDataUpdater::HandleNextRequest() {}
+
+std::unique_ptr<NearbyShareDeviceDataUpdater>
+FakeNearbyShareDeviceDataUpdaterFactory::CreateInstance(
+    const std::string& device_id,
+    base::TimeDelta timeout,
+    NearbyShareClientFactory* client_factory) {
+  latest_timeout_ = timeout;
+  latest_client_factory_ = client_factory;
+
+  auto instance = std::make_unique<FakeNearbyShareDeviceDataUpdater>(device_id);
+  instances_.push_back(instance.get());
+
+  return instance;
+}

chrome/browser/nearby_sharing/local_device_data/fake_nearby_share_device_data_updater.h

+// Copyright 2020 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 CHROME_BROWSER_NEARBY_SHARING_LOCAL_DEVICE_DATA_FAKE_NEARBY_SHARE_DEVICE_DATA_UPDATER_H_
+#define CHROME_BROWSER_NEARBY_SHARING_LOCAL_DEVICE_DATA_FAKE_NEARBY_SHARE_DEVICE_DATA_UPDATER_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/containers/queue.h"
+#include "base/optional.h"
+#include "base/time/time.h"
+#include "chrome/browser/nearby_sharing/local_device_data/nearby_share_device_data_updater.h"
+#include "chrome/browser/nearby_sharing/local_device_data/nearby_share_device_data_updater_impl.h"
+#include "chrome/browser/nearby_sharing/proto/device_rpc.pb.h"
+
+// An fake implementation of NearbyShareDeviceDataUpdater for use in unit tests.
+class FakeNearbyShareDeviceDataUpdater : public NearbyShareDeviceDataUpdater {
+ public:
+  explicit FakeNearbyShareDeviceDataUpdater(const std::string& device_id);
+  ~FakeNearbyShareDeviceDataUpdater() override;
+
+  // Advances the request queue and invokes request callback with the input
+  // parameters |success| and |response|.
+  void RunNextRequest(
+      bool success,
+      const base::Optional<nearbyshare::proto::UpdateDeviceResponse>& response);
+
+  const std::string& device_id() const { return device_id_; }
+
+  const base::queue<Request>& pending_requests() const {
+    return pending_requests_;
+  }
+
+ private:
+  // NearbyShareDeviceDataUpdater:
+  void HandleNextRequest() override;
+};
+
+// A fake NearbyShareDeviceDataUpdaterImpl factory for use in unit tests.
+class FakeNearbyShareDeviceDataUpdaterFactory
+    : public NearbyShareDeviceDataUpdaterImpl::Factory {
+ public:
+  FakeNearbyShareDeviceDataUpdaterFactory();
+  ~FakeNearbyShareDeviceDataUpdaterFactory() override;
+
+  // Returns all FakeNearbyShareDeviceDataUpdater instances created by
+  // CreateInstance().
+  std::vector<FakeNearbyShareDeviceDataUpdater*>& instances() {
+    return instances_;
+  }
+
+  base::TimeDelta latest_timeout() const { return latest_timeout_; }
+
+  NearbyShareClientFactory* latest_client_factory() const {
+    return latest_client_factory_;
+  }
+
+ private:
+  // NearbyShareDeviceDataUpdaterImpl::Factory:
+  std::unique_ptr<NearbyShareDeviceDataUpdater> CreateInstance(
+      const std::string& device_id,
+      base::TimeDelta timeout,
+      NearbyShareClientFactory* client_factory) override;
+
+  std::vector<FakeNearbyShareDeviceDataUpdater*> instances_;
+  base::TimeDelta latest_timeout_;
+  NearbyShareClientFactory* latest_client_factory_ = nullptr;
+};
+
+#endif  // CHROME_BROWSER_NEARBY_SHARING_LOCAL_DEVICE_DATA_FAKE_NEARBY_SHARE_DEVICE_DATA_UPDATER_H_

chrome/browser/nearby_sharing/local_device_data/nearby_share_device_data_updater.cc

+// Copyright 2020 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 <utility>
+
+#include "base/check.h"
+#include "chrome/browser/nearby_sharing/local_device_data/nearby_share_device_data_updater.h"
+
+NearbyShareDeviceDataUpdater::Request::Request(
+    base::Optional<std::string> device_name,
+    base::Optional<std::vector<nearbyshare::proto::Contact>> contacts,
+    base::Optional<std::vector<nearbyshare::proto::PublicCertificate>>
+        certificates,
+    ResultCallback callback)
+    : device_name(std::move(device_name)),
+      contacts(std::move(contacts)),
+      certificates(std::move(certificates)),
+      callback(std::move(callback)) {}
+
+NearbyShareDeviceDataUpdater::Request::Request(
+    NearbyShareDeviceDataUpdater::Request&& request) = default;
+
+NearbyShareDeviceDataUpdater::Request&
+NearbyShareDeviceDataUpdater::Request::operator=(
+    NearbyShareDeviceDataUpdater::Request&& request) = default;
+
+NearbyShareDeviceDataUpdater::Request::~Request() = default;
+
+NearbyShareDeviceDataUpdater::NearbyShareDeviceDataUpdater(
+    const std::string& device_id)
+    : device_id_(device_id) {}
+
+NearbyShareDeviceDataUpdater::~NearbyShareDeviceDataUpdater() = default;
+
+void NearbyShareDeviceDataUpdater::UpdateDeviceData(
+    base::Optional<std::string> device_name,
+    base::Optional<std::vector<nearbyshare::proto::Contact>> contacts,
+    base::Optional<std::vector<nearbyshare::proto::PublicCertificate>>
+        certificates,
+    ResultCallback callback) {
+  pending_requests_.emplace(std::move(device_name), std::move(contacts),
+                            std::move(certificates), std::move(callback));
+  ProcessRequestQueue();
+}
+
+void NearbyShareDeviceDataUpdater::ProcessRequestQueue() {
+  if (is_request_in_progress_ || pending_requests_.empty())
+    return;
+
+  is_request_in_progress_ = true;
+  HandleNextRequest();
+}
+
+void NearbyShareDeviceDataUpdater::FinishAttempt(
+    bool success,
+    const base::Optional<nearbyshare::proto::UpdateDeviceResponse>& response) {
+  DCHECK(is_request_in_progress_);
+  DCHECK(!pending_requests_.empty());
+
+  Request current_request = std::move(pending_requests_.front());
+  pending_requests_.pop();
+
+  std::move(current_request.callback).Run(success, response);
+
+  is_request_in_progress_ = false;
+  ProcessRequestQueue();
+}

chrome/browser/nearby_sharing/local_device_data/nearby_share_device_data_updater.h

+// Copyright 2020 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 CHROME_BROWSER_NEARBY_SHARING_LOCAL_DEVICE_DATA_NEARBY_SHARE_DEVICE_DATA_UPDATER_H_
+#define CHROME_BROWSER_NEARBY_SHARING_LOCAL_DEVICE_DATA_NEARBY_SHARE_DEVICE_DATA_UPDATER_H_
+
+#include <string>
+
+#include "base/callback.h"
+#include "base/containers/queue.h"
+#include "base/optional.h"
+#include "chrome/browser/nearby_sharing/proto/device_rpc.pb.h"
+#include "chrome/browser/nearby_sharing/proto/rpc_resources.pb.h"
+
+// Manages a queue of data needed to make UpdateDevice RPC requests to the
+// Nearby Server. Implementations should make the actual HTTP calls by
+// overriding HandleNextRequest(), which is invoked when the next request is
+// ready to be run. Implementations should call FinishAttempt() with the result
+// of the attempt and possibly the response.
+// TODO(crbug.com/1105547): Instead of queuing requests, hold a single pending
+// request and update the fields as other UpdateDeviceData() call are made.
+// Then, queue up all of callbacks from the merged requests in the Request
+// struct; invoke the callback in the order they were added. This will reduce
+// the number of UpdateDevice RPC calls.
+class NearbyShareDeviceDataUpdater {
+ public:
+  using ResultCallback = base::OnceCallback<void(
+      bool,
+      const base::Optional<nearbyshare::proto::UpdateDeviceResponse>&)>;
+
+  struct Request {
+    Request(base::Optional<std::string> device_name,
+            base::Optional<std::vector<nearbyshare::proto::Contact>> contacts,
+            base::Optional<std::vector<nearbyshare::proto::PublicCertificate>>
+                certificates,
+            ResultCallback callback);
+    Request(Request&& request);
+    Request& operator=(Request&& request);
+    Request(const Request&) = delete;
+    Request& operator=(const Request&) = delete;
+    ~Request();
+
+    base::Optional<std::string> device_name;
+    base::Optional<std::vector<nearbyshare::proto::Contact>> contacts;
+    base::Optional<std::vector<nearbyshare::proto::PublicCertificate>>
+        certificates;
+    ResultCallback callback;
+  };
+
+  // |device_id|: The ID used by the Nearby server to differentiate multiple
+  //              devices from the same account.
+  explicit NearbyShareDeviceDataUpdater(const std::string& device_id);
+
+  virtual ~NearbyShareDeviceDataUpdater();
+
+  // Queue up an UpdateDevice RPC request to update the following fields on the
+  // Nearby server if the parameter is not base::nullopt:
+  //
+  // |device_name|: The device display name, for example, "Joe's Pixel".
+  //
+  // |contacts|: The list of contacts that the Nearby server will send
+  //             all-contacts-visibility certificates to. Contacts marked
+  //             is_selected will be sent selected-contacts-visibility
+  //             certificates.
+  //
+  // |certificates|: The local device's certificates that the Nearby server will
+  //                 distribute to the appropriate |contacts|.
+  //
+  // If only the UpdateDevice RPC response data is desired, set all
+  // aforementioned parameters to base::nullopt.
+  void UpdateDeviceData(
+      base::Optional<std::string> device_name,
+      base::Optional<std::vector<nearbyshare::proto::Contact>> contacts,
+      base::Optional<std::vector<nearbyshare::proto::PublicCertificate>>
+          certificates,
+      ResultCallback callback);
+
+ protected:
+  void ProcessRequestQueue();
+  virtual void HandleNextRequest() = 0;
+  void FinishAttempt(
+      bool success,
+      const base::Optional<nearbyshare::proto::UpdateDeviceResponse>& response);
+
+  std::string device_id_;
+  bool is_request_in_progress_ = false;
+  base::queue<Request> pending_requests_;
+};
+
+#endif  // CHROME_BROWSER_NEARBY_SHARING_LOCAL_DEVICE_DATA_NEARBY_SHARE_DEVICE_DATA_UPDATER_H_

chrome/browser/nearby_sharing/local_device_data/nearby_share_device_data_updater_impl.cc

+// Copyright 2020 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/nearby_sharing/local_device_data/nearby_share_device_data_updater_impl.h"
+
+#include "base/memory/ptr_util.h"
+#include "chrome/browser/nearby_sharing/client/nearby_share_client.h"
+#include "chrome/browser/nearby_sharing/proto/rpc_resources.pb.h"
+
+namespace {
+
+// These values are persisted to logs. Entries should not be renumbered and
+// numeric values should never be reused.
+enum class UpdaterResultCode {
+  kSuccess = 0,
+  kTimeout = 1,
+  kHttpErrorOffline = 2,
+  kHttpErrorEndpointNotFound = 3,
+  kHttpErrorAuthenticationError = 4,
+  kHttpErrorBadRequest = 5,
+  kHttpErrorResponseMalformed = 6,
+  kHttpErrorInternalServerError = 7,
+  kHttpErrorUnknown = 8,
+  kMaxValue = kHttpErrorUnknown
+};
+
+const char kDeviceIdPrefix[] = "users/me/devices/";
+const char kDeviceNameFieldMaskPath[] = "device.display_name";
+const char kContactsFieldMaskPath[] = "device.contacts";
+const char kCertificatesFieldMaskPath[] = "device.public_certificates";
+
+UpdaterResultCode RequestErrorToUpdaterResultCode(
+    NearbyShareRequestError error) {
+  switch (error) {
+    case NearbyShareRequestError::kOffline:
+      return UpdaterResultCode::kHttpErrorOffline;
+    case NearbyShareRequestError::kEndpointNotFound:
+      return UpdaterResultCode::kHttpErrorEndpointNotFound;
+    case NearbyShareRequestError::kAuthenticationError:
+      return UpdaterResultCode::kHttpErrorAuthenticationError;
+    case NearbyShareRequestError::kBadRequest:
+      return UpdaterResultCode::kHttpErrorBadRequest;
+    case NearbyShareRequestError::kResponseMalformed:
+      return UpdaterResultCode::kHttpErrorResponseMalformed;
+    case NearbyShareRequestError::kInternalServerError:
+      return UpdaterResultCode::kHttpErrorInternalServerError;
+    case NearbyShareRequestError::kUnknown:
+      return UpdaterResultCode::kHttpErrorUnknown;
+  }
+}
+
+void RecordResultMetrics(UpdaterResultCode code) {
+  // TODO(crbug.com/1105579): Record a histogram value for each result.
+}
+
+}  // namespace
+
+// static
+NearbyShareDeviceDataUpdaterImpl::Factory*
+    NearbyShareDeviceDataUpdaterImpl::Factory::test_factory_ = nullptr;
+
+// static
+std::unique_ptr<NearbyShareDeviceDataUpdater>
+NearbyShareDeviceDataUpdaterImpl::Factory::Create(
+    const std::string& device_id,
+    base::TimeDelta timeout,
+    NearbyShareClientFactory* client_factory) {
+  if (test_factory_)
+    return test_factory_->CreateInstance(device_id, timeout, client_factory);
+
+  return base::WrapUnique(
+      new NearbyShareDeviceDataUpdaterImpl(device_id, timeout, client_factory));
+}
+
+// static
+void NearbyShareDeviceDataUpdaterImpl::Factory::SetFactoryForTesting(
+    Factory* test_factory) {
+  test_factory_ = test_factory;
+}
+
+NearbyShareDeviceDataUpdaterImpl::Factory::~Factory() = default;
+
+NearbyShareDeviceDataUpdaterImpl::NearbyShareDeviceDataUpdaterImpl(
+    const std::string& device_id,
+    base::TimeDelta timeout,
+    NearbyShareClientFactory* client_factory)
+    : NearbyShareDeviceDataUpdater(device_id),
+      timeout_(timeout),
+      client_factory_(client_factory) {}
+
+NearbyShareDeviceDataUpdaterImpl::~NearbyShareDeviceDataUpdaterImpl() = default;
+
+void NearbyShareDeviceDataUpdaterImpl::HandleNextRequest() {
+  timer_.Start(FROM_HERE, timeout_,
+               base::BindOnce(&NearbyShareDeviceDataUpdaterImpl::OnTimeout,
+                              base::Unretained(this)));
+
+  nearbyshare::proto::UpdateDeviceRequest request;
+  request.mutable_device()->set_name(kDeviceIdPrefix + device_id_);
+  if (pending_requests_.front().device_name) {
+    request.mutable_device()->set_display_name(
+        *pending_requests_.front().device_name);
+    request.mutable_update_mask()->add_paths(kDeviceNameFieldMaskPath);
+  }
+  if (pending_requests_.front().contacts) {
+    *request.mutable_device()->mutable_contacts() = {
+        pending_requests_.front().contacts->begin(),
+        pending_requests_.front().contacts->end()};
+    request.mutable_update_mask()->add_paths(kContactsFieldMaskPath);
+  }
+  if (pending_requests_.front().certificates) {
+    *request.mutable_device()->mutable_public_certificates() = {
+        pending_requests_.front().certificates->begin(),
+        pending_requests_.front().certificates->end()};
+    request.mutable_update_mask()->add_paths(kCertificatesFieldMaskPath);
+  }
+
+  client_ = client_factory_->CreateInstance();
+  client_->UpdateDevice(
+      request,
+      base::BindOnce(&NearbyShareDeviceDataUpdaterImpl::OnRpcSuccess,
+                     base::Unretained(this)),
+      base::BindOnce(&NearbyShareDeviceDataUpdaterImpl::OnRpcFailure,
+                     base::Unretained(this)));
+}
+
+void NearbyShareDeviceDataUpdaterImpl::OnRpcSuccess(
+    const nearbyshare::proto::UpdateDeviceResponse& response) {
+  timer_.Stop();
+  nearbyshare::proto::UpdateDeviceResponse response_copy(response);
+  client_.reset();
+  RecordResultMetrics(UpdaterResultCode::kSuccess);
+  FinishAttempt(/*success=*/true, response_copy);
+}
+
+void NearbyShareDeviceDataUpdaterImpl::OnRpcFailure(
+    NearbyShareRequestError error) {
+  timer_.Stop();
+  client_.reset();
+  RecordResultMetrics(RequestErrorToUpdaterResultCode(error));
+  FinishAttempt(/*success=*/false, /*response=*/base::nullopt);
+}
+
+void NearbyShareDeviceDataUpdaterImpl::OnTimeout() {
+  client_.reset();
+  RecordResultMetrics(UpdaterResultCode::kTimeout);
+  FinishAttempt(/*success=*/false, /*response=*/base::nullopt);
+}

chrome/browser/nearby_sharing/local_device_data/nearby_share_device_data_updater_impl.h

+// Copyright 2020 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 CHROME_BROWSER_NEARBY_SHARING_LOCAL_DEVICE_DATA_NEARBY_SHARE_DEVICE_DATA_UPDATER_IMPL_H_
+#define CHROME_BROWSER_NEARBY_SHARING_LOCAL_DEVICE_DATA_NEARBY_SHARE_DEVICE_DATA_UPDATER_IMPL_H_
+
+#include <memory>
+
+#include "base/time/time.h"
+#include "base/timer/timer.h"
+#include "chrome/browser/nearby_sharing/client/nearby_share_request_error.h"
+#include "chrome/browser/nearby_sharing/local_device_data/nearby_share_device_data_updater.h"
+#include "chrome/browser/nearby_sharing/proto/device_rpc.pb.h"
+
+class NearbyShareClient;
+class NearbyShareClientFactory;
+
+// An implementation of NearbyShareDeviceDataUpdater that uses the
+// NearbyShareClient to make UpdateDevice RPC calls to the Nearby server. An
+// UpdateDeviceData() attempt will fail if a response is not received within the
+// specified timeout value.
+class NearbyShareDeviceDataUpdaterImpl : public NearbyShareDeviceDataUpdater {
+ public:
+  class Factory {
+   public:
+    static std::unique_ptr<NearbyShareDeviceDataUpdater> Create(
+        const std::string& device_id,
+        base::TimeDelta timeout,
+        NearbyShareClientFactory* client_factory);
+    static void SetFactoryForTesting(Factory* test_factory);
+
+   protected:
+    virtual ~Factory();
+    virtual std::unique_ptr<NearbyShareDeviceDataUpdater> CreateInstance(
+        const std::string& device_id,
+        base::TimeDelta timeout,
+        NearbyShareClientFactory* client_factory) = 0;
+
+   private:
+    static Factory* test_factory_;
+  };
+
+  ~NearbyShareDeviceDataUpdaterImpl() override;
+
+ private:
+  NearbyShareDeviceDataUpdaterImpl(const std::string& device_id,
+                                   base::TimeDelta timeout,
+                                   NearbyShareClientFactory* client_factory);
+
+  void HandleNextRequest() override;
+  void OnTimeout();
+  void OnRpcSuccess(const nearbyshare::proto::UpdateDeviceResponse& response);
+  void OnRpcFailure(NearbyShareRequestError error);
+
+  base::TimeDelta timeout_;
+  NearbyShareClientFactory* client_factory_ = nullptr;
+  std::unique_ptr<NearbyShareClient> client_;
+  base::OneShotTimer timer_;
+};
+
+#endif  // CHROME_BROWSER_NEARBY_SHARING_LOCAL_DEVICE_DATA_NEARBY_SHARE_DEVICE_DATA_UPDATER_IMPL_H_

chrome/browser/nearby_sharing/local_device_data/nearby_share_device_data_updater_impl_unittest.cc

+// Copyright 2020 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 <memory>
+#include <string>
+#include <vector>
+
+#include "base/no_destructor.h"
+#include "base/optional.h"
+#include "base/stl_util.h"
+#include "base/test/task_environment.h"
+#include "base/time/clock.h"
+#include "base/time/time.h"
+#include "chrome/browser/nearby_sharing/client/fake_nearby_share_client.h"
+#include "chrome/browser/nearby_sharing/client/nearby_share_request_error.h"
+#include "chrome/browser/nearby_sharing/local_device_data/nearby_share_device_data_updater_impl.h"
+#include "chrome/browser/nearby_sharing/proto/device_rpc.pb.h"
+#include "chrome/browser/nearby_sharing/proto/rpc_resources.pb.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+const char kDeviceIdPrefix[] = "users/me/devices/";
+const char kTestDeviceId[] = "test_device_id";
+const char kTestDeviceName[] = "test_device_name";
+const char kTestContactEmail1[] = "test1@gmail.com";
+const char kTestContactEmail2[] = "test2@gmail.com";
+const char kTestCertificateId1[] = "cert_id_1";
+const char kTestCertificateId2[] = "cert_id_2";
+const char kTestPersonName[] = "person_name";
+constexpr base::TimeDelta kTestTimeout = base::TimeDelta::FromMinutes(123);
+
+const std::vector<nearbyshare::proto::Contact>& TestContactList() {
+  static const base::NoDestructor<std::vector<nearbyshare::proto::Contact>>
+      list([] {
+        nearbyshare::proto::Contact contact1;
+        contact1.mutable_identifier()->set_account_name(kTestContactEmail1);
+        nearbyshare::proto::Contact contact2;
+        contact2.mutable_identifier()->set_account_name(kTestContactEmail2);
+        return std::vector<nearbyshare::proto::Contact>{contact1, contact2};
+      }());
+  return *list;
+}
+
+const std::vector<nearbyshare::proto::PublicCertificate>&
+TestCertificateList() {
+  static const base::NoDestructor<
+      std::vector<nearbyshare::proto::PublicCertificate>>
+      list([] {
+        nearbyshare::proto::PublicCertificate cert1;
+        cert1.set_secret_id(kTestCertificateId1);
+        nearbyshare::proto::PublicCertificate cert2;
+        cert2.set_secret_id(kTestCertificateId2);
+        return std::vector<nearbyshare::proto::PublicCertificate>{cert1, cert2};
+      }());
+  return *list;
+}
+
+const nearbyshare::proto::UpdateDeviceResponse& TestResponse() {
+  static const base::NoDestructor<nearbyshare::proto::UpdateDeviceResponse>
+      response([] {
+        nearbyshare::proto::UpdateDeviceResponse response;
+        response.set_person_name(kTestPersonName);
+        return response;
+      }());
+  return *response;
+}
+
+void VerifyRequest(
+    const base::Optional<std::string>& expected_device_name,
+    const base::Optional<std::vector<nearbyshare::proto::Contact>>&
+        expected_contacts,
+    const base::Optional<std::vector<nearbyshare::proto::PublicCertificate>>&
+        expected_certificates,
+    const nearbyshare::proto::UpdateDeviceRequest& request) {
+  std::vector<std::string> field_mask{request.update_mask().paths().begin(),
+                                      request.update_mask().paths().end()};
+
+  EXPECT_EQ(static_cast<size_t>(expected_device_name.has_value()) +
+                static_cast<size_t>(expected_contacts.has_value()) +
+                static_cast<size_t>(expected_certificates.has_value()),
+            field_mask.size());
+  EXPECT_EQ(expected_device_name.has_value(),
+            base::Contains(field_mask, "device.display_name"));
+  EXPECT_EQ(expected_contacts.has_value(),
+            base::Contains(field_mask, "device.contacts"));
+  EXPECT_EQ(expected_certificates.has_value(),
+            base::Contains(field_mask, "device.public_certificates"));
+
+  EXPECT_EQ(std::string(kDeviceIdPrefix) + kTestDeviceId,
+            request.device().name());
+
+  EXPECT_EQ(expected_device_name.value_or(std::string()),
+            request.device().display_name());
+
+  if (expected_contacts) {
+    ASSERT_EQ(static_cast<int>(expected_contacts->size()),
+              request.device().contacts().size());
+    for (size_t i = 0; i < expected_contacts->size(); ++i) {
+      EXPECT_EQ((*expected_contacts)[i].SerializeAsString(),
+                request.device().contacts()[i].SerializeAsString());
+    }
+  } else {
+    EXPECT_TRUE(request.device().contacts().empty());
+  }
+
+  if (expected_certificates) {
+    ASSERT_EQ(static_cast<int>(expected_certificates->size()),
+              request.device().public_certificates().size());
+    for (size_t i = 0; i < expected_certificates->size(); ++i) {
+      EXPECT_EQ((*expected_certificates)[i].SerializeAsString(),
+                request.device().public_certificates()[i].SerializeAsString());
+    }
+  } else {
+    EXPECT_TRUE(request.device().public_certificates().empty());
+  }
+}
+
+void VerifyResponse(
+    const base::Optional<nearbyshare::proto::UpdateDeviceResponse>&
+        expected_response,
+    const base::Optional<nearbyshare::proto::UpdateDeviceResponse>& response) {
+  if (expected_response) {
+    ASSERT_TRUE(response);
+    EXPECT_EQ(expected_response->SerializeAsString(),
+              response->SerializeAsString());
+  } else {
+    EXPECT_FALSE(response);
+  }
+}
+
+}  // namespace
+
+class NearbyShareDeviceDataUpdaterImplTest : public ::testing::Test {
+ protected:
+  enum class UpdateDeviceRequestResult { kSuccess, kHttpFailure, kTimeout };
+
+  NearbyShareDeviceDataUpdaterImplTest() = default;
+  ~NearbyShareDeviceDataUpdaterImplTest() override = default;
+
+  void SetUp() override {
+    updater_ = NearbyShareDeviceDataUpdaterImpl::Factory::Create(
+        kTestDeviceId, kTestTimeout, &fake_client_factory_);
+  }
+
+  void CallUpdateDeviceData(
+      const base::Optional<std::string>& device_name,
+      const base::Optional<std::vector<nearbyshare::proto::Contact>>& contacts,
+      const base::Optional<std::vector<nearbyshare::proto::PublicCertificate>>&
+          certificates) {
+    updater_->UpdateDeviceData(
+        device_name, contacts, certificates,
+        base::BindOnce(&NearbyShareDeviceDataUpdaterImplTest::OnResult,
+                       base::Unretained(this)));
+  }
+
+  void ProcessNextUpdateDeviceDataRequest(
+      const base::Optional<std::string>& expected_device_name,
+      const base::Optional<std::vector<nearbyshare::proto::Contact>>&
+          expected_contacts,
+      const base::Optional<std::vector<nearbyshare::proto::PublicCertificate>>&
+          expected_certificates,
+      UpdateDeviceRequestResult result) {
+    // Verify the next request.
+    ASSERT_FALSE(fake_client_factory_.instances().empty());
+    FakeNearbyShareClient* client = fake_client_factory_.instances().back();
+    ASSERT_EQ(1u, client->update_device_requests().size());
+    VerifyRequest(expected_device_name, expected_contacts,
+                  expected_certificates,
+                  client->update_device_requests()[0].request);
+
+    // Send and verify the response.
+    size_t num_results = results_.size();
+    size_t num_responses = responses_.size();
+    switch (result) {
+      case UpdateDeviceRequestResult::kSuccess:
+        std::move(client->update_device_requests()[0].callback)
+            .Run(TestResponse());
+        return;
+      case UpdateDeviceRequestResult::kHttpFailure:
+        std::move(client->update_device_requests()[0].error_callback)
+            .Run(NearbyShareRequestError::kBadRequest);
+        return;
+      case UpdateDeviceRequestResult::kTimeout:
+        FastForward(kTestTimeout);
+        return;
+    }
+    EXPECT_EQ(num_results + 1, results_.size());
+    EXPECT_EQ(num_responses + 1, responses_.size());
+
+    bool success = result == UpdateDeviceRequestResult::kSuccess;
+    EXPECT_EQ(success, results_.back());
+    VerifyResponse(
+        success ? base::make_optional(TestResponse()) : base::nullopt,
+        responses_.back());
+  }
+
+ private:
+  // Fast-forwards mock time by |delta| and fires relevant timers.
+  void FastForward(base::TimeDelta delta) {
+    task_environment_.FastForwardBy(delta);
+  }
+
+  // The callback passed into UpdateDeviceData().
+  void OnResult(bool success,
+                const base::Optional<nearbyshare::proto::UpdateDeviceResponse>&
+                    response) {
+    results_.push_back(success);
+    responses_.push_back(response);
+  }
+
+  base::test::SingleThreadTaskEnvironment task_environment_{
+      base::test::TaskEnvironment::TimeSource::MOCK_TIME};
+  std::vector<bool> results_;
+  std::vector<base::Optional<nearbyshare::proto::UpdateDeviceResponse>>
+      responses_;
+  FakeNearbyShareClientFactory fake_client_factory_;
+  std::unique_ptr<NearbyShareDeviceDataUpdater> updater_;
+};
+
+TEST_F(NearbyShareDeviceDataUpdaterImplTest, Success_NoParameters) {
+  CallUpdateDeviceData(/*device_name=*/base::nullopt,
+                       /*contacts=*/base::nullopt,
+                       /*certificates=*/base::nullopt);
+  ProcessNextUpdateDeviceDataRequest(
+      /*expected_device_name=*/base::nullopt,
+      /*expected_contacts=*/base::nullopt,
+      /*expected_certificates=*/base::nullopt,
+      UpdateDeviceRequestResult::kSuccess);
+}
+
+TEST_F(NearbyShareDeviceDataUpdaterImplTest, Success_AllParameters) {
+  CallUpdateDeviceData(kTestDeviceName, TestContactList(),
+                       TestCertificateList());
+  ProcessNextUpdateDeviceDataRequest(kTestDeviceName, TestContactList(),
+                                     TestCertificateList(),
+                                     UpdateDeviceRequestResult::kSuccess);
+}
+
+TEST_F(NearbyShareDeviceDataUpdaterImplTest, Success_OneParameter) {
+  CallUpdateDeviceData(kTestDeviceName,
+                       /*contacts=*/base::nullopt,
+                       /*certificates=*/base::nullopt);
+  ProcessNextUpdateDeviceDataRequest(kTestDeviceName,
+                                     /*expected_contacts=*/base::nullopt,
+                                     /*expected_certificates=*/base::nullopt,
+                                     UpdateDeviceRequestResult::kSuccess);
+}
+
+TEST_F(NearbyShareDeviceDataUpdaterImplTest, Failure_Timeout) {
+  CallUpdateDeviceData(kTestDeviceName, TestContactList(),
+                       TestCertificateList());
+  ProcessNextUpdateDeviceDataRequest(kTestDeviceName, TestContactList(),
+                                     TestCertificateList(),
+                                     UpdateDeviceRequestResult::kTimeout);
+}
+
+TEST_F(NearbyShareDeviceDataUpdaterImplTest, Failure_HttpError) {
+  CallUpdateDeviceData(kTestDeviceName, TestContactList(),
+                       TestCertificateList());
+  ProcessNextUpdateDeviceDataRequest(kTestDeviceName, TestContactList(),
+                                     TestCertificateList(),
+                                     UpdateDeviceRequestResult::kHttpFailure);
+}
+
+TEST_F(NearbyShareDeviceDataUpdaterImplTest, QueuedRequests) {
+  // Queue requests while waiting to process.
+  CallUpdateDeviceData(/*device_name=*/base::nullopt,
+                       /*contacts=*/base::nullopt,
+                       /*certificates=*/base::nullopt);
+  CallUpdateDeviceData(kTestDeviceName, TestContactList(),
+                       TestCertificateList());
+  CallUpdateDeviceData(kTestDeviceName,
+                       /*contacts=*/base::nullopt,
+                       /*certificates=*/base::nullopt);
+
+  // Requests are processed in the order they are received.
+  ProcessNextUpdateDeviceDataRequest(
+      /*expected_device_name=*/base::nullopt,
+      /*expected_contacts=*/base::nullopt,
+      /*expected_certificates=*/base::nullopt,
+      UpdateDeviceRequestResult::kSuccess);
+  ProcessNextUpdateDeviceDataRequest(kTestDeviceName, TestContactList(),
+                                     TestCertificateList(),
+                                     UpdateDeviceRequestResult::kTimeout);
+  ProcessNextUpdateDeviceDataRequest(kTestDeviceName,
+                                     /*expected_contacts=*/base::nullopt,
+                                     /*expected_certificates=*/base::nullopt,
+                                     UpdateDeviceRequestResult::kHttpFailure);
+}

chrome/test/BUILD.gn

@@ -4341,6 +4341,7 @@ test("unit_tests") {
     deps += [
       "//chrome/browser/nearby_sharing/certificates:unit_tests",
       "//chrome/browser/nearby_sharing/client:unit_tests",
+      "//chrome/browser/nearby_sharing/local_device_data:unit_tests",
       "//chrome/browser/nearby_sharing/logging:unit_tests",
       "//chrome/browser/nearby_sharing/proto",
       "//chrome/browser/nearby_sharing/scheduling:unit_tests",