PayloadTracker integration

- Integrates PayloadTracker in NearbySharingService.
- Registers PayloadPaths for incoming connections.
- Handles transfer completion and cleanup for incoming connections.

Bug: 1085068
Change-Id: Ic8df7bab0077c3fd3c95042831dcff7b07faf29b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2367677
Commit-Queue: Himanshu Jaju <himanshujaju@chromium.org>
Reviewed-by: Alex Chau <alexchau@chromium.org>
Cr-Commit-Position: refs/heads/master@{#802610}

chrome/browser/nearby_sharing/attachment_info.h

@@ -8,6 +8,7 @@
 #include <stdint.h>
 #include <string>
 
+#include "base/files/file.h"
 #include "base/optional.h"
 
 // Ties associated information to an Attachment.
@@ -20,6 +21,7 @@ struct AttachmentInfo {
 
   base::Optional<int64_t> payload_id;
   std::string text_body;
+  base::FilePath file_path;
 };
 
 #endif  // CHROME_BROWSER_NEARBY_SHARING_ATTACHMENT_INFO_H_

chrome/browser/nearby_sharing/fake_nearby_connections_manager.cc

@@ -59,13 +59,13 @@ void FakeNearbyConnectionsManager::Connect(
     NearbyConnectionCallback callback) {
   DCHECK(!is_shutdown());
   connected_data_usage_ = data_usage;
-  connection_endpoint_info_ = std::move(endpoint_info);
+  connection_endpoint_infos_.emplace(endpoint_id, std::move(endpoint_info));
   std::move(callback).Run(connection_);
 }
 
 void FakeNearbyConnectionsManager::Disconnect(const std::string& endpoint_id) {
   DCHECK(!is_shutdown());
-  connection_endpoint_info_.reset();
+  connection_endpoint_infos_.erase(endpoint_id);
 }
 
 void FakeNearbyConnectionsManager::Send(const std::string& endpoint_id,
@@ -80,7 +80,8 @@ void FakeNearbyConnectionsManager::RegisterPayloadStatusListener(
     int64_t payload_id,
     PayloadStatusListener* listener) {
   DCHECK(!is_shutdown());
-  // TODO(alexchau): Implement.
+
+  payload_status_listeners_[payload_id] = listener;
 }
 
 void FakeNearbyConnectionsManager::RegisterPayloadPath(
@@ -88,14 +89,33 @@ void FakeNearbyConnectionsManager::RegisterPayloadPath(
     const base::FilePath& file_path,
     ConnectionsCallback callback) {
   DCHECK(!is_shutdown());
-  // TODO(alexchau): Implement.
+
+  registered_payload_paths_[payload_id] = file_path;
+  {
+    base::ScopedAllowBlockingForTesting allow_blocking;
+    base::File file(file_path, base::File::Flags::FLAG_CREATE_ALWAYS |
+                                   base::File::Flags::FLAG_READ |
+                                   base::File::Flags::FLAG_WRITE);
+  }
+
+  auto it = payload_path_status_.find(payload_id);
+  if (it == payload_path_status_.end()) {
+    std::move(callback).Run(
+        location::nearby::connections::mojom::Status::kPayloadUnknown);
+    return;
+  }
+
+  std::move(callback).Run(it->second);
 }
 
 FakeNearbyConnectionsManager::Payload*
 FakeNearbyConnectionsManager::GetIncomingPayload(int64_t payload_id) {
   DCHECK(!is_shutdown());
-  // TODO(alexchau): Implement.
-  return nullptr;
+  auto it = incoming_payloads_.find(payload_id);
+  if (it == incoming_payloads_.end())
+    return nullptr;
+
+  return it->second.get();
 }
 
 void FakeNearbyConnectionsManager::Cancel(int64_t payload_id) {
@@ -105,7 +125,10 @@ void FakeNearbyConnectionsManager::Cancel(int64_t payload_id) {
 
 void FakeNearbyConnectionsManager::ClearIncomingPayloads() {
   DCHECK(!is_shutdown());
-  // TODO(alexchau): Implement.
+  base::ScopedAllowBlockingForTesting allow_blocking;
+
+  incoming_payloads_.clear();
+  payload_status_listeners_.clear();
 }
 
 base::Optional<std::vector<uint8_t>>
@@ -161,3 +184,33 @@ bool FakeNearbyConnectionsManager::DidUpgradeBandwidth(
   return upgrade_bandwidth_endpoint_ids_.find(endpoint_id) !=
          upgrade_bandwidth_endpoint_ids_.end();
 }
+
+void FakeNearbyConnectionsManager::SetPayloadPathStatus(
+    int64_t payload_id,
+    ConnectionsStatus status) {
+  payload_path_status_[payload_id] = status;
+}
+
+FakeNearbyConnectionsManager::PayloadStatusListener*
+FakeNearbyConnectionsManager::GetRegisteredPayloadStatusListener(
+    int64_t payload_id) {
+  auto it = payload_status_listeners_.find(payload_id);
+  if (it != payload_status_listeners_.end())
+    return it->second;
+
+  return nullptr;
+}
+
+void FakeNearbyConnectionsManager::SetIncomingPayload(int64_t payload_id,
+                                                      PayloadPtr payload) {
+  incoming_payloads_[payload_id] = std::move(payload);
+}
+
+base::Optional<base::FilePath>
+FakeNearbyConnectionsManager::GetRegisteredPayloadPath(int64_t payload_id) {
+  auto it = registered_payload_paths_.find(payload_id);
+  if (it == registered_payload_paths_.end())
+    return base::nullopt;
+
+  return it->second;
+}

chrome/browser/nearby_sharing/fake_nearby_connections_manager.h

@@ -72,6 +72,10 @@ class FakeNearbyConnectionsManager
   bool IsAdvertising() const;
   bool IsDiscovering() const;
   bool DidUpgradeBandwidth(const std::string& endpoint_id) const;
+  void SetPayloadPathStatus(int64_t payload_id, ConnectionsStatus status);
+  PayloadStatusListener* GetRegisteredPayloadStatusListener(int64_t payload_id);
+  void SetIncomingPayload(int64_t payload_id, PayloadPtr payload);
+  base::Optional<base::FilePath> GetRegisteredPayloadPath(int64_t payload_id);
 
   bool is_shutdown() const { return is_shutdown_; }
   DataUsage advertising_data_usage() const { return advertising_data_usage_; }
@@ -89,10 +93,18 @@ class FakeNearbyConnectionsManager
   const base::Optional<std::vector<uint8_t>>& adverting_endpoint_info() {
     return adverting_endpoint_info_;
   }
-  const base::Optional<std::vector<uint8_t>>& connection_endpoint_info() {
-    return connection_endpoint_info_;
+
+  base::Optional<std::vector<uint8_t>> connection_endpoint_info(
+      const std::string& endpoint_id) {
+    auto it = connection_endpoint_infos_.find(endpoint_id);
+    if (it == connection_endpoint_infos_.end())
+      return base::nullopt;
+
+    return it->second;
   }
 
+  bool has_incoming_payloads() { return !incoming_payloads_.empty(); }
+
  private:
   IncomingConnectionListener* advertising_listener_ = nullptr;
   DiscoveryListener* discovery_listener_ = nullptr;
@@ -105,7 +117,15 @@ class FakeNearbyConnectionsManager
   DataUsage connected_data_usage_ = DataUsage::kUnknown;
   base::RepeatingCallback<void(PayloadPtr payload)> send_payload_callback_;
   base::Optional<std::vector<uint8_t>> adverting_endpoint_info_;
-  base::Optional<std::vector<uint8_t>> connection_endpoint_info_;
+  std::set<std::string> disconnected_endpoints_;
+
+  // Maps endpoint_id to endpoint_info.
+  std::map<std::string, std::vector<uint8_t>> connection_endpoint_infos_;
+
+  std::map<int64_t, ConnectionsStatus> payload_path_status_;
+  std::map<int64_t, PayloadStatusListener*> payload_status_listeners_;
+  std::map<int64_t, PayloadPtr> incoming_payloads_;
+  std::map<int64_t, base::FilePath> registered_payload_paths_;
 };
 
 #endif  // CHROME_BROWSER_NEARBY_SHARING_FAKE_NEARBY_CONNECTIONS_MANAGER_H_

chrome/browser/nearby_sharing/file_attachment.h

@@ -38,6 +38,10 @@ class FileAttachment : public Attachment {
   // Attachment:
   void MoveToShareTarget(ShareTarget& share_target) override;
 
+  void set_file_path(base::Optional<base::FilePath> path) {
+    file_path_ = std::move(path);
+  }
+
  private:
   std::string file_name_;
   std::string mime_type_;

chrome/browser/nearby_sharing/nearby_connections_manager_impl_unittest.cc

@@ -966,48 +966,6 @@ TEST_F(NearbyConnectionsManagerImplTest, IncomingRegisterPayloadPath) {
   register_payload_run_loop.Run();
 }
 
-TEST_F(NearbyConnectionsManagerImplTest,
-       IncomingRegisterPayloadPathAlreadyExist) {
-  mojo::Remote<ConnectionLifecycleListener> connection_listener_remote;
-  testing::NiceMock<MockIncomingConnectionListener>
-      incoming_connection_listener;
-  StartAdvertising(connection_listener_remote, incoming_connection_listener);
-
-  mojo::Remote<PayloadListener> payload_listener_remote;
-  NearbyConnection* connection = OnIncomingConnection(
-      connection_listener_remote, incoming_connection_listener,
-      payload_listener_remote);
-  EXPECT_TRUE(connection);
-
-  base::File file;
-  base::FilePath path = InitializeTemporaryFile(file);
-  {
-    base::ScopedAllowBlockingForTesting allow_blocking;
-    file.Close();
-  }
-
-  base::RunLoop register_payload_run_loop;
-  EXPECT_CALL(nearby_connections_, RegisterPayloadFile)
-      .WillOnce(
-          [&](int64_t payload_id, base::File input_file, base::File output_file,
-              NearbyConnectionsMojom::RegisterPayloadFileCallback callback) {
-            EXPECT_EQ(kPayloadId, payload_id);
-            ASSERT_TRUE(input_file.IsValid());
-            ASSERT_TRUE(output_file.IsValid());
-            VerifyFileReadWrite(input_file, output_file);
-
-            std::move(callback).Run(Status::kSuccess);
-            register_payload_run_loop.Quit();
-          });
-
-  // Register a path that already exists.
-  base::MockCallback<NearbyConnectionsManager::ConnectionsCallback> callback;
-  EXPECT_CALL(callback, Run(testing::Eq(Status::kSuccess)));
-  nearby_connections_manager_.RegisterPayloadPath(kPayloadId, path,
-                                                  callback.Get());
-  register_payload_run_loop.Run();
-}
-
 TEST_F(NearbyConnectionsManagerImplTest, IncomingBytesPayload) {
   mojo::Remote<ConnectionLifecycleListener> connection_listener_remote;
   testing::NiceMock<MockIncomingConnectionListener>

chrome/browser/nearby_sharing/nearby_file_handler.cc

@@ -37,13 +37,12 @@ std::vector<NearbyFileHandler::FileInfo> DoOpenFiles(
 }
 
 NearbyFileHandler::CreateFileResult DoCreateFile(base::FilePath file_path) {
-  base::FilePath unique_path = base::GetUniquePath(file_path);
   NearbyFileHandler::CreateFileResult result;
   result.output_file.Initialize(
-      unique_path,
+      file_path,
       base::File::Flags::FLAG_CREATE_ALWAYS | base::File::Flags::FLAG_WRITE);
   result.input_file.Initialize(
-      unique_path, base::File::Flags::FLAG_OPEN | base::File::Flags::FLAG_READ);
+      file_path, base::File::Flags::FLAG_OPEN | base::File::Flags::FLAG_READ);
   return result;
 }
 
@@ -60,6 +59,15 @@ void NearbyFileHandler::OpenFiles(std::vector<base::FilePath> file_paths,
       std::move(callback));
 }
 
+void NearbyFileHandler::GetUniquePath(const base::FilePath& file_path,
+                                      GetUniquePathCallback callback) {
+  // TODO(crbug.com/1085068) - Confirm if this should be run on
+  // DownloadManager's task runner.
+  task_runner_->PostTaskAndReplyWithResult(
+      FROM_HERE, base::BindOnce(&base::GetUniquePath, file_path),
+      std::move(callback));
+}
+
 void NearbyFileHandler::ReleaseFilePayloads(std::vector<PayloadPtr> payloads) {
   auto files = std::make_unique<std::vector<base::File>>();
   for (auto& payload : payloads) {
@@ -75,3 +83,12 @@ void NearbyFileHandler::CreateFile(const base::FilePath& file_path,
   task_runner_->PostTaskAndReplyWithResult(
       FROM_HERE, base::BindOnce(&DoCreateFile, file_path), std::move(callback));
 }
+
+void NearbyFileHandler::DeleteFilesFromDisk(std::vector<base::FilePath> paths) {
+  task_runner_->PostTask(FROM_HERE, base::BindOnce(
+                                        [](std::vector<base::FilePath> paths) {
+                                          for (const auto& path : paths)
+                                            base::DeleteFile(path);
+                                        },
+                                        std::move(paths)));
+}

chrome/browser/nearby_sharing/nearby_file_handler.h

@@ -30,6 +30,7 @@ class NearbyFileHandler {
   using PayloadPtr = location::nearby::connections::mojom::PayloadPtr;
   using OpenFilesCallback = base::OnceCallback<void(std::vector<FileInfo>)>;
   using CreateFileCallback = base::OnceCallback<void(CreateFileResult)>;
+  using GetUniquePathCallback = base::OnceCallback<void(base::FilePath)>;
 
   NearbyFileHandler();
   ~NearbyFileHandler();
@@ -48,6 +49,12 @@ class NearbyFileHandler {
   // via |callback|.
   void CreateFile(const base::FilePath& file_path, CreateFileCallback callback);
 
+  void DeleteFilesFromDisk(std::vector<base::FilePath> file_paths);
+
+  // Finds a unique path name for |file_path| and runs |callback| with the same.
+  void GetUniquePath(const base::FilePath& file_path,
+                     GetUniquePathCallback callback);
+
  private:
   // Task runner for doing file operations.
   const scoped_refptr<base::SequencedTaskRunner> task_runner_;

chrome/browser/nearby_sharing/nearby_sharing_service_impl.h

@@ -165,8 +165,22 @@ class NearbySharingServiceImpl
   void OnTransferComplete();
   void OnTransferStarted(bool is_incoming);
 
-  StatusCodes ReceivePayloads(const ShareTarget& share_target);
+  void ReceivePayloads(ShareTarget share_target,
+                       StatusCodesCallback status_codes_callback);
   StatusCodes SendPayloads(const ShareTarget& share_target);
+  void OnUniquePathFetched(
+      int64_t attachment_id,
+      int64_t payload_id,
+      base::OnceCallback<void(location::nearby::connections::mojom::Status)>
+          callback,
+      base::FilePath path);
+  void OnPayloadPathRegistered(
+      base::ScopedClosureRunner closure_runner,
+      bool* aggregated_success,
+      location::nearby::connections::mojom::Status status);
+  void OnPayloadPathsRegistered(const ShareTarget& share_target,
+                                std::unique_ptr<bool> aggregated_success,
+                                StatusCodesCallback status_codes_callback);
 
   void OnOutgoingConnection(const ShareTarget& share_target,
                             NearbyConnection* connection);
@@ -245,6 +259,12 @@ class NearbySharingServiceImpl
       base::Optional<NearbyShareDecryptedPublicCertificate> certificate,
       bool is_incoming);
 
+  void OnPayloadTransferUpdate(ShareTarget share_target,
+                               TransferMetadata metadata);
+  bool OnIncomingPayloadsComplete(ShareTarget& share_target);
+  void OnPayloadsFailed(ShareTarget share_target);
+  void Disconnect(const ShareTarget& share_target, TransferMetadata metadata);
+
   ShareTargetInfo& GetOrCreateShareTargetInfo(const ShareTarget& share_target,
                                               const std::string& endpoint_id);
 

chrome/browser/nearby_sharing/text_attachment.cc

@@ -121,3 +121,8 @@ TextAttachment::~TextAttachment() = default;
 void TextAttachment::MoveToShareTarget(ShareTarget& share_target) {
   share_target.text_attachments.push_back(std::move(*this));
 }
+
+void TextAttachment::set_text_body(std::string text_body) {
+  text_body_ = std::move(text_body);
+  text_title_ = GetTextTitle(text_body_, type_);
+}

chrome/browser/nearby_sharing/text_attachment.h

@@ -31,6 +31,8 @@ class TextAttachment : public Attachment {
   // Attachment:
   void MoveToShareTarget(ShareTarget& share_target) override;
 
+  void set_text_body(std::string text_body);
+
  private:
   Type type_;
   std::string text_title_;