Exposed webext-storage bridged engine logic

CHANGELOG.md

@@ -3,6 +3,13 @@
 ### Glean
 - Updated to v60.1.0 ([#6241](https://github.com/mozilla/application-services/pull/6241))
 
+## ⚠️ Breaking Changes ⚠️
+
+### Webext-Storage
+- Exposed the bridged engine logic for use in desktop ([#6180](https://github.com/mozilla/application-services/pull/6180)).
+  - This updates the signature of the `bridged_engine` function technically making this a breaking change though the
+    references to function with the old signature are being removed in a desktop patch.
+
 [Full Changelog](In progress)
 
 # v127.0 (_2024-05-13_)

components/webext-storage/src/error.rs

@@ -143,3 +143,11 @@ impl From<serde_json::Error> for WebExtStorageApiError {
         }
     }
 }
+
+impl From<anyhow::Error> for WebExtStorageApiError {
+    fn from(value: anyhow::Error) -> Self {
+        WebExtStorageApiError::UnexpectedError {
+            reason: value.to_string(),
+        }
+    }
+}

components/webext-storage/src/lib.rs

@@ -25,6 +25,7 @@ pub use api::SYNC_QUOTA_BYTES_PER_ITEM;
 
 pub use crate::error::{QuotaReason, WebExtStorageApiError};
 pub use crate::store::WebExtStorageStore;
+pub use crate::sync::{bridge::WebExtStorageBridgedEngine, SyncedExtensionChange};
 pub use api::UsageInfo;
 pub use api::{StorageChanges, StorageValueChange};
 
@@ -42,3 +43,17 @@ impl UniffiCustomTypeConverter for JsonValue {
         obj.to_string()
     }
 }
+
+// Our UDL uses a `Guid` type.
+use sync_guid::Guid as WebExtStorageGuid;
+impl UniffiCustomTypeConverter for WebExtStorageGuid {
+    type Builtin = String;
+
+    fn into_custom(val: Self::Builtin) -> uniffi::Result<WebExtStorageGuid> {
+        Ok(WebExtStorageGuid::new(val.as_str()))
+    }
+
+    fn from_custom(obj: Self) -> Self::Builtin {
+        obj.into()
+    }
+}

components/webext-storage/src/store.rs

@@ -29,7 +29,7 @@ use serde_json::Value as JsonValue;
 /// connection with our sync engines - ie, these engines also hold an Arc<>
 /// around the same object.
 pub struct WebExtStorageStore {
-    db: Arc<ThreadSafeStorageDb>,
+    pub db: Arc<ThreadSafeStorageDb>,
 }
 
 impl WebExtStorageStore {
@@ -119,14 +119,9 @@ impl WebExtStorageStore {
 
     /// Returns the bytes in use for the specified items (which can be null,
     /// a string, or an array)
-    pub fn get_bytes_in_use(&self, ext_id: &str, keys: JsonValue) -> Result<usize> {
+    pub fn get_bytes_in_use(&self, ext_id: &str, keys: JsonValue) -> Result<u64> {
         let db = self.db.lock();
-        api::get_bytes_in_use(&db, ext_id, keys)
-    }
-
-    /// Returns a bridged sync engine for Desktop for this store.
-    pub fn bridged_engine(&self) -> sync::BridgedEngine {
-        sync::BridgedEngine::new(&self.db)
+        Ok(api::get_bytes_in_use(&db, ext_id, keys)? as u64)
     }
 
     /// Closes the store and its database connection. See the docs for

components/webext-storage/src/sync/bridge.rs

@@ -5,18 +5,30 @@
 use anyhow::Result;
 use rusqlite::Transaction;
 use std::sync::{Arc, Weak};
-use sync15::bso::IncomingBso;
-use sync15::engine::ApplyResults;
+use sync15::bso::{IncomingBso, OutgoingBso};
+use sync15::engine::{ApplyResults, BridgedEngine as Sync15BridgedEngine};
 use sync_guid::Guid as SyncGuid;
 
 use crate::db::{delete_meta, get_meta, put_meta, ThreadSafeStorageDb};
 use crate::schema;
 use crate::sync::incoming::{apply_actions, get_incoming, plan_incoming, stage_incoming};
 use crate::sync::outgoing::{get_outgoing, record_uploaded, stage_outgoing};
+use crate::WebExtStorageStore;
 
 const LAST_SYNC_META_KEY: &str = "last_sync_time";
 const SYNC_ID_META_KEY: &str = "sync_id";
 
+impl WebExtStorageStore {
+    // Returns a bridged sync engine for Desktop for this store.
+    pub fn bridged_engine(self: Arc<Self>) -> Arc<WebExtStorageBridgedEngine> {
+        let engine = Box::new(BridgedEngine::new(&self.db));
+        let bridged_engine = WebExtStorageBridgedEngine {
+            bridge_impl: engine,
+        };
+        Arc::new(bridged_engine)
+    }
+}
+
 /// A bridged engine implements all the methods needed to make the
 /// `storage.sync` store work with Desktop's Sync implementation.
 /// Conceptually, it's similar to `sync15::Store`, which we
@@ -54,7 +66,7 @@ impl BridgedEngine {
     }
 }
 
-impl sync15::engine::BridgedEngine for BridgedEngine {
+impl Sync15BridgedEngine for BridgedEngine {
     fn last_sync(&self) -> Result<i64> {
         let shared_db = self.thread_safe_storage_db()?;
         let db = shared_db.lock();
@@ -182,6 +194,88 @@ impl sync15::engine::BridgedEngine for BridgedEngine {
     }
 }
 
+pub struct WebExtStorageBridgedEngine {
+    bridge_impl: Box<dyn Sync15BridgedEngine>,
+}
+
+impl WebExtStorageBridgedEngine {
+    pub fn new(bridge_impl: Box<dyn Sync15BridgedEngine>) -> Self {
+        Self { bridge_impl }
+    }
+
+    pub fn last_sync(&self) -> Result<i64> {
+        self.bridge_impl.last_sync()
+    }
+
+    pub fn set_last_sync(&self, last_sync: i64) -> Result<()> {
+        self.bridge_impl.set_last_sync(last_sync)
+    }
+
+    pub fn sync_id(&self) -> Result<Option<String>> {
+        self.bridge_impl.sync_id()
+    }
+
+    pub fn reset_sync_id(&self) -> Result<String> {
+        self.bridge_impl.reset_sync_id()
+    }
+
+    pub fn ensure_current_sync_id(&self, sync_id: &str) -> Result<String> {
+        self.bridge_impl.ensure_current_sync_id(sync_id)
+    }
+
+    pub fn prepare_for_sync(&self, client_data: &str) -> Result<()> {
+        self.bridge_impl.prepare_for_sync(client_data)
+    }
+
+    pub fn store_incoming(&self, incoming: Vec<String>) -> Result<()> {
+        self.bridge_impl
+            .store_incoming(self.convert_incoming_bsos(incoming)?)
+    }
+
+    pub fn apply(&self) -> Result<Vec<String>> {
+        let apply_results = self.bridge_impl.apply()?;
+        self.convert_outgoing_bsos(apply_results.records)
+    }
+
+    pub fn set_uploaded(&self, server_modified_millis: i64, guids: Vec<SyncGuid>) -> Result<()> {
+        self.bridge_impl
+            .set_uploaded(server_modified_millis, &guids)
+    }
+
+    pub fn sync_started(&self) -> Result<()> {
+        self.bridge_impl.sync_started()
+    }
+
+    pub fn sync_finished(&self) -> Result<()> {
+        self.bridge_impl.sync_finished()
+    }
+
+    pub fn reset(&self) -> Result<()> {
+        self.bridge_impl.reset()
+    }
+
+    pub fn wipe(&self) -> Result<()> {
+        self.bridge_impl.wipe()
+    }
+
+    fn convert_incoming_bsos(&self, incoming: Vec<String>) -> Result<Vec<IncomingBso>> {
+        let mut bsos = Vec::with_capacity(incoming.len());
+        for inc in incoming {
+            bsos.push(serde_json::from_str::<IncomingBso>(&inc)?);
+        }
+        Ok(bsos)
+    }
+
+    // Encode OutgoingBso's into JSON for UniFFI
+    fn convert_outgoing_bsos(&self, outgoing: Vec<OutgoingBso>) -> Result<Vec<String>> {
+        let mut bsos = Vec::with_capacity(outgoing.len());
+        for e in outgoing {
+            bsos.push(serde_json::to_string(&e)?);
+        }
+        Ok(bsos)
+    }
+}
+
 impl From<anyhow::Error> for crate::error::Error {
     fn from(value: anyhow::Error) -> Self {
         crate::error::Error::SyncError(value.to_string())

components/webext-storage/src/sync/mod.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-mod bridge;
+pub mod bridge;
 mod incoming;
 mod outgoing;
 
@@ -17,7 +17,6 @@ use serde_derive::*;
 use sql_support::ConnExt;
 use sync_guid::Guid as SyncGuid;
 
-pub use bridge::BridgedEngine;
 use incoming::IncomingAction;
 
 type JsonMap = serde_json::Map<String, serde_json::Value>;

components/webext-storage/src/webext-storage.udl

@@ -5,6 +5,9 @@
 [Custom]
 typedef string JsonValue;
 
+[Custom]
+typedef string WebExtStorageGuid;
+
 namespace webextstorage {
 
 };
@@ -22,6 +25,11 @@ interface WebExtStorageApiError {
     QuotaError(QuotaReason reason);
 };
 
+dictionary SyncedExtensionChange {
+    string ext_id;
+    string changes;
+};
+
 dictionary StorageValueChange {
     string key;
     JsonValue? old_value;
@@ -32,6 +40,9 @@ dictionary StorageChanges {
     sequence<StorageValueChange> changes;
 };
 
+// Note that the `close` function has been intentionally excluded from `WebExtStorageStore` because at present
+// it is not necessary for our current use in mozilla central and converting `close` to pass a reference to
+// the store resulted in errors.
 interface WebExtStorageStore {
     [Throws=WebExtStorageApiError]
     constructor(string path);
@@ -42,9 +53,62 @@ interface WebExtStorageStore {
     [Throws=WebExtStorageApiError]
     JsonValue get([ByRef] string ext_id, JsonValue keys);
 
+    [Throws=WebExtStorageApiError]
+    u64 get_bytes_in_use([ByRef] string ext_id, JsonValue keys);
+
     [Throws=WebExtStorageApiError]
     StorageChanges remove([ByRef] string ext_id, JsonValue keys);
 
     [Throws=WebExtStorageApiError]
     StorageChanges clear([ByRef] string ext_id);
+
+    [Self=ByArc]
+    WebExtStorageBridgedEngine bridged_engine();
+
+    [Throws=WebExtStorageApiError]
+    sequence<SyncedExtensionChange> get_synced_changes();
+};
+
+// Note the canonical docs for this are in https://searchfox.org/mozilla-central/source/services/interfaces/mozIBridgedSyncEngine.idl
+// It's only actually used in desktop, but it's fine to expose this everywhere.
+// NOTE: all timestamps here are milliseconds.
+interface WebExtStorageBridgedEngine {
+    [Throws=WebExtStorageApiError]
+    i64 last_sync();
+
+    [Throws=WebExtStorageApiError]
+    void set_last_sync(i64 last_sync);
+
+    [Throws=WebExtStorageApiError]
+    string? sync_id();
+
+    [Throws=WebExtStorageApiError]
+    string reset_sync_id();
+
+    [Throws=WebExtStorageApiError]
+    string ensure_current_sync_id([ByRef]string new_sync_id);
+
+    [Throws=WebExtStorageApiError]
+    void prepare_for_sync([ByRef]string client_data);
+
+    [Throws=WebExtStorageApiError]
+    void sync_started();
+
+    [Throws=WebExtStorageApiError]
+    void store_incoming(sequence<string> incoming);
+
+    [Throws=WebExtStorageApiError]
+    sequence<string> apply();
+
+    [Throws=WebExtStorageApiError]
+    void set_uploaded(i64 server_modified_millis, sequence<WebExtStorageGuid> guids);
+
+    [Throws=WebExtStorageApiError]
+    void sync_finished();
+
+    [Throws=WebExtStorageApiError]
+    void reset();
+
+    [Throws=WebExtStorageApiError]
+    void wipe();
 };