Implement OutgoingShareTargetInfo for NearbyShareService.

Tracks details of an outgoing connection, similar to IncomingShareTargetInfo.
Also addressed feedback in change Id7265fb16da494737b76531b08c8cbc21ddb7c67 for simpler map access.

Bug: 1084644
Change-Id: I39e3306b8c5f09f54fd32d7147019bb7bf44ebe3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2310489
Commit-Queue: Naomi Musgrave <nmusgrave@chromium.org>
Reviewed-by: Alex Chau <alexchau@chromium.org>
Cr-Commit-Position: refs/heads/master@{#790580}

chrome/browser/BUILD.gn

@@ -3324,6 +3324,8 @@ static_library("browser") {
       "nearby_sharing/nearby_sharing_service_factory.h",
       "nearby_sharing/nearby_sharing_service_impl.cc",
       "nearby_sharing/nearby_sharing_service_impl.h",
+      "nearby_sharing/outgoing_share_target_info.cc",
+      "nearby_sharing/outgoing_share_target_info.h",
       "nearby_sharing/share_target.cc",
       "nearby_sharing/share_target.h",
       "nearby_sharing/share_target_discovered_callback.h",

chrome/browser/nearby_sharing/certificates/nearby_share_decrypted_public_certificate.cc

@@ -182,7 +182,6 @@ NearbyShareDecryptedPublicCertificate::NearbyShareDecryptedPublicCertificate(
 
 NearbyShareDecryptedPublicCertificate::NearbyShareDecryptedPublicCertificate(
     NearbyShareDecryptedPublicCertificate&&) = default;
-
 NearbyShareDecryptedPublicCertificate&
 NearbyShareDecryptedPublicCertificate::operator=(
     NearbyShareDecryptedPublicCertificate&&) = default;

chrome/browser/nearby_sharing/nearby_sharing_service_impl.cc

@@ -655,14 +655,19 @@ void NearbySharingServiceImpl::OnIncomingTransferUpdate(
 
 IncomingShareTargetInfo& NearbySharingServiceImpl::GetIncomingShareTargetInfo(
     const ShareTarget& share_target) {
-  auto ret = incoming_share_target_info_map_.insert(
-      {share_target.id(), IncomingShareTargetInfo()});
-  DCHECK(ret.first != incoming_share_target_info_map_.end());
-
-  return ret.first->second;
+  return incoming_share_target_info_map_[share_target.id()];
 }
 
 NearbyConnection* NearbySharingServiceImpl::GetIncomingConnection(
     const ShareTarget& share_target) {
   return GetIncomingShareTargetInfo(share_target).nearby_connection();
 }
+
+OutgoingShareTargetInfo& NearbySharingServiceImpl::GetOutgoingShareTargetInfo(
+    ShareTarget share_target) {
+  return outgoing_share_target_info_map_[share_target.id()];
+}
+
+void NearbySharingServiceImpl::ClearOutgoingShareTargetInfoMap() {
+  outgoing_share_target_info_map_.clear();
+}

chrome/browser/nearby_sharing/nearby_sharing_service_impl.h

@@ -21,6 +21,7 @@
 #include "chrome/browser/nearby_sharing/nearby_notification_manager.h"
 #include "chrome/browser/nearby_sharing/nearby_process_manager.h"
 #include "chrome/browser/nearby_sharing/nearby_sharing_service.h"
+#include "chrome/browser/nearby_sharing/outgoing_share_target_info.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/prefs/pref_change_registrar.h"
 
@@ -110,6 +111,8 @@ class NearbySharingServiceImpl
   IncomingShareTargetInfo& GetIncomingShareTargetInfo(
       const ShareTarget& share_target);
   NearbyConnection* GetIncomingConnection(const ShareTarget& share_target);
+  OutgoingShareTargetInfo& GetOutgoingShareTargetInfo(ShareTarget share_target);
+  void ClearOutgoingShareTargetInfoMap();
 
   PrefService* prefs_;
   Profile* profile_;
@@ -134,6 +137,14 @@ class NearbySharingServiceImpl
   // The most recent outgoing TransferMetadata and ShareTarget.
   base::Optional<std::pair<ShareTarget, TransferMetadata>>
       last_outgoing_metadata_;
+  // A map of ShareTarget id to IncomingShareTargetInfo. This lets us know which
+  // Nearby Connections endpoint and public certificate are related to the
+  // incoming share target.
+  std::map<int, IncomingShareTargetInfo> incoming_share_target_info_map_;
+  // A map of ShareTarget id to OutgoingShareTargetInfo. This lets us know which
+  // endpoint and public certificate are related to the outgoing share target.
+  // TODO(crbug/1085068) update this map when handling payloads
+  std::map<int, OutgoingShareTargetInfo> outgoing_share_target_info_map_;
 
   // The current advertising power level. PowerLevel::kUnknown while not
   // advertising.
@@ -150,11 +161,6 @@ class NearbySharingServiceImpl
   // True if we're currently sending or receiving a file.
   bool is_transferring_files_ = false;
 
-  // A map of ShareTarget id to IncomingShareTargetInfo. This lets us know which
-  // Nearby Connections endpoint and public certificate are related to the
-  // incoming share target.
-  std::map<int, IncomingShareTargetInfo> incoming_share_target_info_map_;
-
   SEQUENCE_CHECKER(sequence_checker_);
   base::WeakPtrFactory<NearbySharingServiceImpl> weak_ptr_factory_{this};
 };

chrome/browser/nearby_sharing/outgoing_share_target_info.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/outgoing_share_target_info.h"
+
+#include <utility>
+
+OutgoingShareTargetInfo::OutgoingShareTargetInfo() = default;
+OutgoingShareTargetInfo::~OutgoingShareTargetInfo() = default;
+
+OutgoingShareTargetInfo::OutgoingShareTargetInfo(OutgoingShareTargetInfo&&) =
+    default;
+OutgoingShareTargetInfo& OutgoingShareTargetInfo::operator=(
+    OutgoingShareTargetInfo&&) = default;
+
+std::ostream& operator<<(std::ostream& out,
+                         const OutgoingShareTargetInfo& share_target) {
+  out << "OutgoingShareTargetInfo<endpoint_id: "
+      << (share_target.endpoint_id().has_value()
+              ? share_target.endpoint_id().value()
+              : "")
+      << ", has_certificate: " << (share_target.certificate().has_value())
+      << ", has_connection: " << (share_target.nearby_connection() != nullptr)
+      << ">";
+  return out;
+}

chrome/browser/nearby_sharing/outgoing_share_target_info.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_OUTGOING_SHARE_TARGET_INFO_H_
+#define CHROME_BROWSER_NEARBY_SHARING_OUTGOING_SHARE_TARGET_INFO_H_
+
+#include <string>
+#include <vector>
+
+#include "base/optional.h"
+#include "chrome/browser/nearby_sharing/certificates/nearby_share_decrypted_public_certificate.h"
+#include "chrome/browser/nearby_sharing/nearby_connection.h"
+
+// A description of the outgoing connection to a remote device.
+class OutgoingShareTargetInfo {
+ public:
+  OutgoingShareTargetInfo();
+  ~OutgoingShareTargetInfo();
+
+  OutgoingShareTargetInfo(const OutgoingShareTargetInfo&) = delete;
+  OutgoingShareTargetInfo& operator=(const OutgoingShareTargetInfo&) = delete;
+
+  OutgoingShareTargetInfo(OutgoingShareTargetInfo&&);
+  OutgoingShareTargetInfo& operator=(OutgoingShareTargetInfo&&);
+
+  void set_endpoint_id(std::string endpoint_id) {
+    endpoint_id_ = std::move(endpoint_id);
+  }
+
+  const base::Optional<std::string>& endpoint_id() const {
+    return endpoint_id_;
+  }
+
+  void set_certificate(NearbyShareDecryptedPublicCertificate certificate) {
+    certificate_ = std::move(certificate);
+  }
+
+  const base::Optional<NearbyShareDecryptedPublicCertificate>& certificate()
+      const {
+    return certificate_;
+  }
+  void set_connection(std::unique_ptr<NearbyConnection> connection) {
+    connection_ = std::move(connection);
+  }
+
+  NearbyConnection* nearby_connection() const { return connection_.get(); }
+
+  void set_obfuscated_gaia_id(std::string obfuscated_gaia_id) {
+    obfuscated_gaia_id_ = std::move(obfuscated_gaia_id);
+  }
+
+  const base::Optional<std::string>& obfuscated_gaia_id() const {
+    return obfuscated_gaia_id_;
+  }
+
+  void set_token(std::string token) { token_ = std::move(token); }
+
+  const base::Optional<std::string>& token() const { return token_; }
+
+  void set_is_connected(bool is_connected) { is_connected_ = is_connected; }
+
+  bool is_connected() const { return is_connected_; }
+
+ private:
+  base::Optional<std::string> endpoint_id_;
+  base::Optional<NearbyShareDecryptedPublicCertificate> certificate_;
+  std::unique_ptr<NearbyConnection> connection_;
+  base::Optional<std::string> obfuscated_gaia_id_;
+  base::Optional<std::string> token_;
+  bool is_connected_;
+};
+
+#endif  // CHROME_BROWSER_NEARBY_SHARING_OUTGOING_SHARE_TARGET_INFO_H_