Bug 2005405 - add isPrivate to send-tab (#7133)

Author: mhammond

components/fxa-client/android/src/main/java/mozilla/appservices/fxaclient/FxaClient.kt

@@ -526,10 +526,12 @@ class FxaClient(inner: FirefoxAccount, persistCallback: PersistCallback?) : Auto
      * @param targetDeviceId The target Device ID
      * @param title The document title of the tab being sent
      * @param url The url of the tab being sent
+     * @param isPrivate Whether the tab is open as a private tab. Has a default value to help with progressive
+     * implementation of this new attribute, but the default should be removed at some point.
      */
-    fun sendSingleTab(targetDeviceId: String, title: String, url: String) {
+    fun sendSingleTab(targetDeviceId: String, title: String, url: String, isPrivate: Boolean = false) {
         withMetrics {
-            this.inner.sendSingleTab(targetDeviceId, title, url)
+            this.inner.sendSingleTab(targetDeviceId, title, url, isPrivate)
         }
     }
 

components/fxa-client/src/fxa_client.udl

@@ -552,7 +552,7 @@ interface FirefoxAccount {
   ///      granted the `https:///identity.mozilla.com/apps/oldsync` scope.
   ///
   [Throws=FxaError]
-  void send_single_tab([ByRef] string target_device_id, [ByRef] string title, [ByRef] string url );
+  void send_single_tab([ByRef] string target_device_id, [ByRef] string title, [ByRef] string url, optional boolean is_private = false );
 
 
   /// Use device commands to close one or more tabs on another device.
@@ -930,11 +930,14 @@ dictionary CloseTabsPayload {
   sequence<string> urls;
 };
 
-/// An individual entry in the navigation history of a sent tab.
+/// A received tab. Mis-named as the original intent was to keep
+/// the full "back" history for a tab, where this would be one such
+/// entry - but that never happened.
 ///
 dictionary TabHistoryEntry {
   string title;
   string url;
+  boolean is_private;
 };
 
 /// A client connected to the user's account.

components/fxa-client/src/internal/commands/send_tab.rs

@@ -38,13 +38,14 @@ impl From<SendTabPayload> for crate::SendTabPayload {
 }
 
 impl SendTabPayload {
-    pub fn single_tab(title: &str, url: &str) -> (Self, telemetry::SentCommand) {
+    pub fn single_tab(title: &str, url: &str, private: bool) -> (Self, telemetry::SentCommand) {
         let sent_telemetry: telemetry::SentCommand = telemetry::SentCommand::for_send_tab();
         (
             SendTabPayload {
                 entries: vec![TabHistoryEntry {
                     title: title.to_string(),
                     url: url.to_string(),
+                    private,
                 }],
                 flow_id: sent_telemetry.flow_id.clone(),
                 stream_id: sent_telemetry.stream_id.clone(),
@@ -58,13 +59,16 @@ impl SendTabPayload {
 pub struct TabHistoryEntry {
     pub title: String,
     pub url: String,
+    #[serde(default)]
+    pub private: bool,
 }
 
 impl From<TabHistoryEntry> for crate::TabHistoryEntry {
     fn from(e: TabHistoryEntry) -> Self {
         crate::TabHistoryEntry {
             title: e.title,
             url: e.url,
+            is_private: e.private,
         }
     }
 }
@@ -82,15 +86,35 @@ mod tests {
 
     #[test]
     fn test_payload() {
-        let (payload, telem) = SendTabPayload::single_tab("title", "http://example.com");
+        let (payload, telem) = SendTabPayload::single_tab("title", "http://example.com", true);
         let json = serde_json::to_string(&payload).expect("should work");
         assert_eq!(telem.flow_id.len(), 12);
         assert_eq!(telem.stream_id.len(), 12);
         assert_ne!(telem.flow_id, telem.stream_id);
         let p2: SendTabPayload = serde_json::from_str(&json).expect("should work");
         // no 'PartialEq' derived so check each field individually...
         assert_eq!(payload.entries[0].url, "http://example.com".to_string());
+        assert!(payload.entries[0].private);
         assert_eq!(payload.flow_id, p2.flow_id);
         assert_eq!(payload.stream_id, p2.stream_id);
     }
+
+    #[test]
+    fn test_raw_payload() {
+        let json = r#"{"title": "new title", "url": "https://example99.com", "private": true}"#;
+        let p: TabHistoryEntry = serde_json::from_str(json).expect("should work");
+        assert_eq!(p.title, "new title");
+        assert_eq!(p.url, "https://example99.com");
+        assert!(p.private);
+    }
+
+    #[test]
+    fn test_raw_payload_without_private() {
+        // no "private" field
+        let json = r#"{"title": "the title", "url": "https://example.com"}"#;
+        let p: TabHistoryEntry = serde_json::from_str(json).expect("should work");
+        assert_eq!(p.title, "the title");
+        assert_eq!(p.url, "https://example.com");
+        assert!(!p.private);
+    }
 }

components/fxa-client/src/internal/send_tab.rs

@@ -43,13 +43,14 @@ impl FirefoxAccount {
         target_device_id: &str,
         title: &str,
         url: &str,
+        private: bool,
     ) -> Result<()> {
         let devices = self.get_devices(false)?;
         let target = devices
             .iter()
             .find(|d| d.id == target_device_id)
             .ok_or_else(|| Error::UnknownTargetDevice(target_device_id.to_owned()))?;
-        let (payload, sent_telemetry) = SendTabPayload::single_tab(title, url);
+        let (payload, sent_telemetry) = SendTabPayload::single_tab(title, url, private);
         let oldsync_key = self.get_scoped_key(scopes::OLD_SYNC)?;
         let command_payload =
             encrypt_command(oldsync_key, target, send_tab::COMMAND_NAME, &payload)?;

components/fxa-client/src/push.rs

@@ -95,10 +95,16 @@ impl FirefoxAccount {
     ///    - Device commands functionality is only available to applications that have been
     ///      granted the `https://identity.mozilla.com/apps/oldsync` scope.
     #[handle_error(Error)]
-    pub fn send_single_tab(&self, target_device_id: &str, title: &str, url: &str) -> ApiResult<()> {
+    pub fn send_single_tab(
+        &self,
+        target_device_id: &str,
+        title: &str,
+        url: &str,
+        private: bool,
+    ) -> ApiResult<()> {
         self.internal
             .lock()
-            .send_single_tab(target_device_id, title, url)
+            .send_single_tab(target_device_id, title, url, private)
     }
 
     /// Use device commands to close one or more tabs on another device.
@@ -240,4 +246,5 @@ pub struct CloseTabsPayload {
 pub struct TabHistoryEntry {
     pub title: String,
     pub url: String,
+    pub is_private: bool,
 }

examples/fxa-client/src/send_tab.rs

@@ -68,7 +68,7 @@ fn poll(account: &FirefoxAccount) -> Result<()> {
 }
 
 fn send(account: &FirefoxAccount, device_id: String, title: String, url: String) -> Result<()> {
-    account.send_single_tab(&device_id, &title, &url)?;
+    account.send_single_tab(&device_id, &title, &url, false)?;
     println!("Tab sent!");
     Ok(())
 }