[Nearby] Implement SendAttachments

This implements attachment handling for outgoing transfers. It reuses
the key verification step of incoming payloads and sends the
introduction payload to the remote device.

Bug: 1085067
Change-Id: I3534d60e5ad40a09d692278e312fb2d3dd3fb4aa
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2352877
Commit-Queue: Richard Knoll <knollr@chromium.org>
Reviewed-by: Alex Chau <alexchau@chromium.org>
Cr-Commit-Position: refs/heads/master@{#800228}

chrome/browser/nearby_sharing/constants.h

@@ -24,4 +24,8 @@ constexpr base::TimeDelta kReadFramesTimeout = base::TimeDelta::FromSeconds(15);
 constexpr base::TimeDelta kInvalidateDelay =
     base::TimeDelta::FromMilliseconds(500);
 
+// If total size of all attachments is larger than this limit, online share will
+// be disabled even if it would be allowed by the user.
+constexpr int64_t kOnlineFileSizeLimitBytes = 25 * 1024 * 1024;  // 25MB
+
 #endif  // CHROME_BROWSER_NEARBY_SHARING_CONSTANTS_H_

chrome/browser/nearby_sharing/fake_nearby_connections_manager.cc

@@ -28,7 +28,7 @@ void FakeNearbyConnectionsManager::StartAdvertising(
 
 void FakeNearbyConnectionsManager::StopAdvertising() {
   DCHECK(IsAdvertising());
-  DCHECK(!IsShutdown());
+  DCHECK(!is_shutdown());
   advertising_listener_ = nullptr;
   advertising_data_usage_ = DataUsage::kUnknown;
   advertising_power_level_ = PowerLevel::kUnknown;
@@ -44,7 +44,7 @@ void FakeNearbyConnectionsManager::StartDiscovery(
 
 void FakeNearbyConnectionsManager::StopDiscovery() {
   DCHECK(IsDiscovering());
-  DCHECK(!IsShutdown());
+  DCHECK(!is_shutdown());
   discovery_listener_ = nullptr;
   // TODO(alexchau): Implement.
 }
@@ -55,26 +55,27 @@ void FakeNearbyConnectionsManager::Connect(
     base::Optional<std::vector<uint8_t>> bluetooth_mac_address,
     DataUsage data_usage,
     NearbyConnectionCallback callback) {
-  DCHECK(!IsShutdown());
-  // TODO(alexchau): Implement.
+  DCHECK(!is_shutdown());
+  connected_data_usage_ = data_usage;
+  std::move(callback).Run(connection_);
 }
 
 void FakeNearbyConnectionsManager::Disconnect(const std::string& endpoint_id) {
-  DCHECK(!IsShutdown());
+  DCHECK(!is_shutdown());
   // TODO(alexchau): Implement.
 }
 
 void FakeNearbyConnectionsManager::Send(const std::string& endpoint_id,
                                         PayloadPtr payload,
                                         PayloadStatusListener* listener) {
-  DCHECK(!IsShutdown());
+  DCHECK(!is_shutdown());
   // TODO(alexchau): Implement.
 }
 
 void FakeNearbyConnectionsManager::RegisterPayloadStatusListener(
     int64_t payload_id,
     PayloadStatusListener* listener) {
-  DCHECK(!IsShutdown());
+  DCHECK(!is_shutdown());
   // TODO(alexchau): Implement.
 }
 
@@ -82,31 +83,31 @@ void FakeNearbyConnectionsManager::RegisterPayloadPath(
     int64_t payload_id,
     const base::FilePath& file_path,
     ConnectionsCallback callback) {
-  DCHECK(!IsShutdown());
+  DCHECK(!is_shutdown());
   // TODO(alexchau): Implement.
 }
 
 FakeNearbyConnectionsManager::Payload*
 FakeNearbyConnectionsManager::GetIncomingPayload(int64_t payload_id) {
-  DCHECK(!IsShutdown());
+  DCHECK(!is_shutdown());
   // TODO(alexchau): Implement.
   return nullptr;
 }
 
 void FakeNearbyConnectionsManager::Cancel(int64_t payload_id) {
-  DCHECK(!IsShutdown());
+  DCHECK(!is_shutdown());
   // TODO(alexchau): Implement.
 }
 
 void FakeNearbyConnectionsManager::ClearIncomingPayloads() {
-  DCHECK(!IsShutdown());
+  DCHECK(!is_shutdown());
   // TODO(alexchau): Implement.
 }
 
 base::Optional<std::vector<uint8_t>>
 FakeNearbyConnectionsManager::GetRawAuthenticationToken(
     const std::string& endpoint_id) {
-  DCHECK(!IsShutdown());
+  DCHECK(!is_shutdown());
 
   auto iter = endpoint_auth_tokens_.find(endpoint_id);
   if (iter != endpoint_auth_tokens_.end())
@@ -143,27 +144,16 @@ void FakeNearbyConnectionsManager::OnEndpointLost(
   discovery_listener_->OnEndpointLost(endpoint_id);
 }
 
-bool FakeNearbyConnectionsManager::IsAdvertising() {
+bool FakeNearbyConnectionsManager::IsAdvertising() const {
   return advertising_listener_ != nullptr;
 }
 
-bool FakeNearbyConnectionsManager::IsDiscovering() {
+bool FakeNearbyConnectionsManager::IsDiscovering() const {
   return discovery_listener_ != nullptr;
 }
 
-bool FakeNearbyConnectionsManager::IsShutdown() {
-  return is_shutdown_;
-}
-
-DataUsage FakeNearbyConnectionsManager::GetAdvertisingDataUsage() {
-  return advertising_data_usage_;
-}
-
-PowerLevel FakeNearbyConnectionsManager::GetAdvertisingPowerLevel() {
-  return advertising_power_level_;
-}
-
 bool FakeNearbyConnectionsManager::DidUpgradeBandwidth(
-    const std::string& endpoint_id) {
-  return (upgrade_bandwidth_endpoint_ids_.count(endpoint_id) > 0);
+    const std::string& endpoint_id) const {
+  return upgrade_bandwidth_endpoint_ids_.find(endpoint_id) !=
+         upgrade_bandwidth_endpoint_ids_.end();
 }

chrome/browser/nearby_sharing/fake_nearby_connections_manager.h

@@ -14,6 +14,8 @@
 #include "chrome/browser/nearby_sharing/nearby_connections_manager.h"
 #include "chrome/services/sharing/public/mojom/nearby_connections.mojom.h"
 
+class NearbyConnection;
+
 // Fake NearbyConnectionsManager for testing.
 class FakeNearbyConnectionsManager
     : public NearbyConnectionsManager,
@@ -65,12 +67,19 @@ class FakeNearbyConnectionsManager
   void OnEndpointLost(const std::string& endpoint_id) override;
 
   // Testing methods
-  bool IsAdvertising();
-  bool IsDiscovering();
-  bool IsShutdown();
-  DataUsage GetAdvertisingDataUsage();
-  PowerLevel GetAdvertisingPowerLevel();
-  bool DidUpgradeBandwidth(const std::string& endpoint_id);
+  bool IsAdvertising() const;
+  bool IsDiscovering() const;
+  bool DidUpgradeBandwidth(const std::string& endpoint_id) const;
+
+  bool is_shutdown() const { return is_shutdown_; }
+  DataUsage advertising_data_usage() const { return advertising_data_usage_; }
+  PowerLevel advertising_power_level() const {
+    return advertising_power_level_;
+  }
+  void set_nearby_connection(NearbyConnection* connection) {
+    connection_ = connection;
+  }
+  DataUsage connected_data_usage() const { return connected_data_usage_; }
 
  private:
   IncomingConnectionListener* advertising_listener_ = nullptr;
@@ -80,6 +89,8 @@ class FakeNearbyConnectionsManager
   PowerLevel advertising_power_level_ = PowerLevel::kUnknown;
   std::set<std::string> upgrade_bandwidth_endpoint_ids_;
   std::map<std::string, std::vector<uint8_t>> endpoint_auth_tokens_;
+  NearbyConnection* connection_ = nullptr;
+  DataUsage connected_data_usage_ = DataUsage::kUnknown;
 };
 
 #endif  // CHROME_BROWSER_NEARBY_SHARING_FAKE_NEARBY_CONNECTIONS_MANAGER_H_

chrome/browser/nearby_sharing/mock_nearby_sharing_service.h

@@ -32,15 +32,13 @@ class MockNearbySharingService : public NearbySharingService {
               UnregisterReceiveSurface,
               (TransferUpdateCallback*),
               (override));
-  MOCK_METHOD(void,
+  MOCK_METHOD(StatusCodes,
               SendText,
-              (const ShareTarget&, std::string, StatusCodesCallback),
+              (const ShareTarget&, std::string),
               (override));
-  MOCK_METHOD(void,
+  MOCK_METHOD(StatusCodes,
               SendFiles,
-              (const ShareTarget&,
-               const std::vector<base::FilePath>&,
-               StatusCodesCallback),
+              (const ShareTarget&, const std::vector<base::FilePath>&),
               (override));
   MOCK_METHOD(void,
               Accept,

chrome/browser/nearby_sharing/nearby_per_session_discovery_manager.cc

@@ -106,14 +106,9 @@ void NearbyPerSessionDiscoveryManager::SelectShareTarget(
 
   select_share_target_callback_ = std::move(callback);
   // TODO(crbug.com/1099710): Call correct method and pass attachments.
-  nearby_sharing_service_->SendText(
-      iter->second, "Example Text",
-      base::BindOnce(&NearbyPerSessionDiscoveryManager::OnSend,
-                     weak_ptr_factory_.GetWeakPtr()));
-}
+  NearbySharingService::StatusCodes status =
+      nearby_sharing_service_->SendText(iter->second, "Example Text");
 
-void NearbyPerSessionDiscoveryManager::OnSend(
-    NearbySharingService::StatusCodes status) {
   // Nothing to do if the result has been returned already.
   if (!select_share_target_callback_)
     return;

chrome/browser/nearby_sharing/nearby_per_session_discovery_manager.h

@@ -43,11 +43,6 @@ class NearbyPerSessionDiscoveryManager
                          SelectShareTargetCallback callback) override;
 
  private:
-  // Called as a result of NearbySharingService::Send() to indicate if the
-  // transfer has been initiated successfully. OnTransferUpdate() will be called
-  // multiple times as the transfer progresses.
-  void OnSend(NearbySharingService::StatusCodes status);
-
   // Unregisters this class from the NearbySharingService.
   void UnregisterSendSurface();
 

chrome/browser/nearby_sharing/nearby_per_session_discovery_manager_unittest.cc

@@ -177,12 +177,11 @@ TEST_F(NearbyPerSessionDiscoveryManagerTest, SelectShareTarget_SendSuccess) {
   EXPECT_CALL(callback, Run(_, _, _)).Times(0);
 
   // TODO(crbug.com/1099710): Call correct method and pass attachments.
-  EXPECT_CALL(sharing_service(), SendText(_, _, _))
+  EXPECT_CALL(sharing_service(), SendText(_, _))
       .WillOnce(testing::Invoke(
-          [&share_target](const ShareTarget& target, std::string text,
-                          NearbySharingService::StatusCodesCallback callback) {
+          [&share_target](const ShareTarget& target, std::string text) {
             EXPECT_EQ(share_target.id, target.id);
-            std::move(callback).Run(NearbySharingService::StatusCodes::kOk);
+            return NearbySharingService::StatusCodes::kOk;
           }));
 
   manager().SelectShareTarget(share_target.id, callback.Get());
@@ -206,12 +205,11 @@ TEST_F(NearbyPerSessionDiscoveryManagerTest, SelectShareTarget_SendError) {
                   testing::Eq(base::nullopt), testing::IsFalse()));
 
   // TODO(crbug.com/1099710): Call correct method and pass attachments.
-  EXPECT_CALL(sharing_service(), SendText(_, _, _))
+  EXPECT_CALL(sharing_service(), SendText(_, _))
       .WillOnce(testing::Invoke(
-          [&share_target](const ShareTarget& target, std::string text,
-                          NearbySharingService::StatusCodesCallback callback) {
+          [&share_target](const ShareTarget& target, std::string text) {
             EXPECT_EQ(share_target.id, target.id);
-            std::move(callback).Run(NearbySharingService::StatusCodes::kError);
+            return NearbySharingService::StatusCodes::kError;
           }));
 
   manager().SelectShareTarget(share_target.id, callback.Get());
@@ -233,6 +231,10 @@ TEST_F(NearbyPerSessionDiscoveryManagerTest, OnTransferUpdate_WaitRemote) {
   EXPECT_CALL(callback, Run(nearby_share::mojom::SelectShareTargetResult::kOk,
                             testing::Eq(base::nullopt), testing::IsFalse()));
 
+  // TODO(crbug.com/1099710): Call correct method and pass attachments.
+  EXPECT_CALL(sharing_service(), SendText(_, _))
+      .WillOnce(testing::Return(NearbySharingService::StatusCodes::kOk));
+
   manager().SelectShareTarget(share_target.id, callback.Get());
 
   auto metadata =
@@ -260,6 +262,10 @@ TEST_F(NearbyPerSessionDiscoveryManagerTest, OnTransferUpdate_WaitLocal) {
   EXPECT_CALL(callback, Run(nearby_share::mojom::SelectShareTargetResult::kOk,
                             testing::Eq(token), testing::IsTrue()));
 
+  // TODO(crbug.com/1099710): Call correct method and pass attachments.
+  EXPECT_CALL(sharing_service(), SendText(_, _))
+      .WillOnce(testing::Return(NearbySharingService::StatusCodes::kOk));
+
   manager().SelectShareTarget(share_target.id, callback.Get());
 
   auto metadata =

chrome/browser/nearby_sharing/nearby_sharing_service.h

@@ -88,14 +88,12 @@ class NearbySharingService : public KeyedService {
       TransferUpdateCallback* transfer_callback) = 0;
 
   // Sends text to the remote |share_target|.
-  virtual void SendText(const ShareTarget& share_target,
-                        std::string text,
-                        StatusCodesCallback status_codes_callback) = 0;
+  virtual StatusCodes SendText(const ShareTarget& share_target,
+                               std::string text) = 0;
 
   // Sends files to the remote |share_target|.
-  virtual void SendFiles(const ShareTarget& share_target,
-                         const std::vector<base::FilePath>& files,
-                         StatusCodesCallback status_codes_callback) = 0;
+  virtual StatusCodes SendFiles(const ShareTarget& share_target,
+                                const std::vector<base::FilePath>& files) = 0;
 
   // Accepts incoming share from the remote |share_target|.
   virtual void Accept(const ShareTarget& share_target,

chrome/browser/nearby_sharing/nearby_sharing_service_impl.h

@@ -78,12 +78,10 @@ class NearbySharingServiceImpl
                                      ReceiveSurfaceState state) override;
   StatusCodes UnregisterReceiveSurface(
       TransferUpdateCallback* transfer_callback) override;
-  void SendText(const ShareTarget& share_target,
-                std::string text,
-                StatusCodesCallback status_codes_callback) override;
-  void SendFiles(const ShareTarget& share_target,
-                 const std::vector<base::FilePath>& files,
-                 StatusCodesCallback status_codes_callback) override;
+  StatusCodes SendText(const ShareTarget& share_target,
+                       std::string text) override;
+  StatusCodes SendFiles(const ShareTarget& share_target,
+                        const std::vector<base::FilePath>& files) override;
   void Accept(const ShareTarget& share_target,
               StatusCodesCallback status_codes_callback) override;
   void Reject(const ShareTarget& share_target,
@@ -164,6 +162,18 @@ class NearbySharingServiceImpl
   StatusCodes ReceivePayloads(const ShareTarget& share_target);
   StatusCodes SendPayloads(const ShareTarget& share_target);
 
+  StatusCodes SendAttachments(const ShareTarget& share_target);
+  void OnOutgoingConnection(const ShareTarget& share_target,
+                            NearbyConnection* connection);
+  void SendIntroduction(const ShareTarget& share_target,
+                        base::Optional<std::string> four_digit_token);
+
+  bool CreatePayloads(const ShareTarget& share_target);
+  std::vector<location::nearby::connections::mojom::PayloadPtr>
+  CreateFilePayloads(const std::vector<FileAttachment>& attachments);
+  std::vector<location::nearby::connections::mojom::PayloadPtr>
+  CreateTextPayloads(const std::vector<TextAttachment>& attachments);
+
   void WriteResponse(
       NearbyConnection& connection,
       sharing::nearby::ConnectionResponseFrame::Status reponse_status);
@@ -178,24 +188,35 @@ class NearbySharingServiceImpl
       sharing::mojom::AdvertisementPtr advertisement);
   void OnIncomingTransferUpdate(const ShareTarget& share_target,
                                 TransferMetadata metadata);
+  void OnOutgoingTransferUpdate(const ShareTarget& share_target,
+                                TransferMetadata metadata);
   void CloseConnection(const ShareTarget& share_target);
   void OnIncomingDecryptedCertificate(
       const std::string& endpoint_id,
       sharing::mojom::AdvertisementPtr advertisement,
       ShareTarget placeholder_share_target,
       base::Optional<NearbyShareDecryptedPublicCertificate> certificate);
+  void RunPairedKeyVerification(
+      const ShareTarget& share_target,
+      const std::string& endpoint_id,
+      base::OnceCallback<void(
+          PairedKeyVerificationRunner::PairedKeyVerificationResult)> callback);
   void OnIncomingConnectionKeyVerificationDone(
       ShareTarget share_target,
-      base::Optional<std::vector<uint8_t>> token,
+      base::Optional<std::string> four_digit_token,
+      PairedKeyVerificationRunner::PairedKeyVerificationResult result);
+  void OnOutgoingConnectionKeyVerificationDone(
+      const ShareTarget& share_target,
+      base::Optional<std::string> four_digit_token,
       PairedKeyVerificationRunner::PairedKeyVerificationResult result);
   void RefreshUIOnDisconnection(ShareTarget share_target);
   void ReceiveIntroduction(ShareTarget share_target,
-                           base::Optional<std::string> token);
+                           base::Optional<std::string> four_digit_token);
   void OnReceivedIntroduction(ShareTarget share_target,
-                              base::Optional<std::string> token,
+                              base::Optional<std::string> four_digit_token,
                               base::Optional<sharing::mojom::V1FramePtr> frame);
   void OnStorageCheckCompleted(ShareTarget share_target,
-                               base::Optional<std::string> token,
+                               base::Optional<std::string> four_digit_token,
                                bool is_out_of_storage);
   void OnFrameRead(ShareTarget share_target,
                    base::Optional<sharing::mojom::V1FramePtr> frame);
@@ -203,8 +224,11 @@ class NearbySharingServiceImpl
       const sharing::mojom::CertificateInfoFramePtr& certificate_frame);
 
   void OnIncomingConnectionDisconnected(const ShareTarget& share_target);
+  void OnOutgoingConnectionDisconnected(const ShareTarget& share_target);
 
   void OnIncomingMutualAcceptanceTimeout(const ShareTarget& share_target);
+  void OnOutgoingMutualAcceptanceTimeout(const ShareTarget& share_target);
+
   base::Optional<ShareTarget> CreateShareTarget(
       const std::string& endpoint_id,
       const sharing::mojom::AdvertisementPtr& advertisement,
@@ -221,6 +245,8 @@ class NearbySharingServiceImpl
       const ShareTarget& share_target);
 
   NearbyConnection* GetConnection(const ShareTarget& share_target);
+  base::Optional<std::vector<uint8_t>> GetBluetoothMacAddress(
+      const ShareTarget& share_target);
 
   void ClearOutgoingShareTargetInfoMap();
   void SetAttachmentPayloadId(const Attachment& attachment, int64_t payload_id);

chrome/browser/resources/nearby_internals/nearby_ui_trigger_browser_proxy.js

@@ -21,9 +21,10 @@ export class NearbyUiTriggerBrowserProxy {
    * Invokes the NearbyShare service's SendText() method for the input
    * ShareTarget |id|
    * @param {string} id
+   * @return {!Promise<!StatusCode>}
    */
   sendText(id) {
-    chrome.send('sendText', [id]);
+    return sendWithPromise('sendText', id);
   }
 
   /**

chrome/browser/resources/nearby_internals/ui_trigger_tab.js

@@ -147,7 +147,8 @@ Polymer({
    * @private
    */
   onSendTextClicked_() {
-    this.browserProxy_.sendText(this.selectedShareTargetId_);
+    this.browserProxy_.sendText(this.selectedShareTargetId_)
+        .then(statusCode => this.onStatusCodeReturned_(statusCode));
   },
 
   /**

chrome/browser/ui/webui/nearby_internals/nearby_internals_ui_trigger_handler.cc

@@ -371,13 +371,6 @@ void NearbyInternalsUiTriggerHandler::OnShareTargetLost(
                     ShareTargetMapToList(id_to_share_target_map_));
 }
 
-void NearbyInternalsUiTriggerHandler::OnSendTextCalled(
-    NearbySharingService::StatusCodes status_codes) {
-  FireWebUIListener(
-      "on-status-code-returned",
-      StatusCodeToDictionary(status_codes, TriggerEvent::kSendText));
-}
-
 void NearbyInternalsUiTriggerHandler::OnAcceptCalled(
     NearbySharingService::StatusCodes status_codes) {
   FireWebUIListener(
@@ -413,7 +406,7 @@ void NearbyInternalsUiTriggerHandler::SendText(const base::ListValue* args) {
     return;
   }
 
-  std::string share_target_id = args->GetList()[0].GetString();
+  std::string share_target_id = args->GetList()[1].GetString();
   auto it = id_to_share_target_map_.find(share_target_id);
   if (it == id_to_share_target_map_.end()) {
     NS_LOG(ERROR) << "Invalid ShareTarget ID " << share_target_id
@@ -421,10 +414,11 @@ void NearbyInternalsUiTriggerHandler::SendText(const base::ListValue* args) {
     return;
   }
 
-  service_->SendText(
-      it->second, kPayloadExample,
-      base::BindOnce(&NearbyInternalsUiTriggerHandler::OnSendTextCalled,
-                     weak_ptr_factory_.GetWeakPtr()));
+  const base::Value& callback_id = args->GetList()[0];
+  ResolveJavascriptCallback(
+      callback_id,
+      StatusCodeToDictionary(service_->SendText(it->second, kPayloadExample),
+                             TriggerEvent::kSendText));
 }
 
 void NearbyInternalsUiTriggerHandler::Accept(const base::ListValue* args) {

chrome/browser/ui/webui/nearby_internals/nearby_internals_ui_trigger_handler.h

@@ -51,7 +51,6 @@ class NearbyInternalsUiTriggerHandler : public content::WebUIMessageHandler,
   void OnOpenCalled(NearbySharingService::StatusCodes status_codes);
   void OnRejectCalled(NearbySharingService::StatusCodes status_codes);
   void OnCancelCalled(NearbySharingService::StatusCodes status_codes);
-  void OnSendTextCalled(NearbySharingService::StatusCodes status_codes);
 
   // Message handler callback that initializes JavaScript.
   void InitializeContents(const base::ListValue* args);