Nightly auto-update (134.0.20241113050253)

Author: Firefox Sync Engineering

Package.swift

@@ -1,13 +1,13 @@
 // swift-tools-version:5.4
 import PackageDescription
 
-let checksum = "f66ce1f84d19f395b7c3d4374d739c7187b72238d3c9419d05f2918ec0cd0d33"
-let version = "134.0.20241109050310"
-let url = "https://firefox-ci-tc.services.mozilla.com/api/index/v1/task/project.application-services.v2.swift.134.20241109050310/artifacts/public/build/MozillaRustComponents.xcframework.zip"
+let checksum = "2a2e78cf5ae7d48ed9ccb82966a75b74a05ad2c6de93dfbc22e852d394af29ef"
+let version = "134.0.20241113050253"
+let url = "https://firefox-ci-tc.services.mozilla.com/api/index/v1/task/project.application-services.v2.swift.134.20241113050253/artifacts/public/build/MozillaRustComponents.xcframework.zip"
 
 // Focus xcframework
-let focusChecksum = "76afebf1057b376b8a75e825a94c7659a5f5081b0b50290195b4b7bfea4b4b7c"
-let focusUrl = "https://firefox-ci-tc.services.mozilla.com/api/index/v1/task/project.application-services.v2.swift.134.20241109050310/artifacts/public/build/FocusRustComponents.xcframework.zip"
+let focusChecksum = "c095c6c502fe22883ac3f9fe4b5dfd5cbe0083f7ebdf429bcd0ef4576275d0fb"
+let focusUrl = "https://firefox-ci-tc.services.mozilla.com/api/index/v1/task/project.application-services.v2.swift.134.20241113050253/artifacts/public/build/FocusRustComponents.xcframework.zip"
 let package = Package(
     name: "MozillaRustComponentsSwift",
     platforms: [.iOS(.v14)],

swift-source/all/Generated/Metrics/Metrics.swift

@@ -23,7 +23,7 @@ extension GleanMetrics {
             // Intentionally left private, no external user can instantiate a new global object.
         }
 
-        public static let info = BuildInfo(buildDate: DateComponents(calendar: Calendar.current, timeZone: TimeZone(abbreviation: "UTC"), year: 2024, month: 11, day: 9, hour: 5, minute: 12, second: 47))
+        public static let info = BuildInfo(buildDate: DateComponents(calendar: Calendar.current, timeZone: TimeZone(abbreviation: "UTC"), year: 2024, month: 11, day: 13, hour: 5, minute: 21, second: 16))
     }
 
     enum NimbusEvents {

swift-source/all/Generated/places.swift

@@ -789,7 +789,7 @@ public protocol PlacesConnectionProtocol : AnyObject {
 
     func newInterruptHandle()  -> SqlInterruptHandle
 
-    func noteHistoryMetadataObservation(data: HistoryMetadataObservation) throws 
+    func noteHistoryMetadataObservation(data: HistoryMetadataObservation, options: NoteHistoryMetadataObservationOptions) throws 
 
     func placesHistoryImportFromIos(dbPath: String, lastSyncTimestamp: Int64) throws  -> HistoryMigrationResult
 
@@ -1165,9 +1165,10 @@ open func newInterruptHandle() -> SqlInterruptHandle {
 })
 }
 
-open func noteHistoryMetadataObservation(data: HistoryMetadataObservation)throws  {try rustCallWithError(FfiConverterTypePlacesApiError.lift) {
+open func noteHistoryMetadataObservation(data: HistoryMetadataObservation, options: NoteHistoryMetadataObservationOptions)throws  {try rustCallWithError(FfiConverterTypePlacesApiError.lift) {
     uniffi_places_fn_method_placesconnection_note_history_metadata_observation(self.uniffiClonePointer(),
-        FfiConverterTypeHistoryMetadataObservation.lower(data),$0
+        FfiConverterTypeHistoryMetadataObservation.lower(data),
+        FfiConverterTypeNoteHistoryMetadataObservationOptions.lower(options),$0
     )
 }
 }
@@ -2843,6 +2844,67 @@ public func FfiConverterTypeInsertableBookmarkSeparator_lower(_ value: Insertabl
 }
 
 
+/**
+ * Options for recording history metadata observations.
+ */
+public struct NoteHistoryMetadataObservationOptions {
+    public var ifPageMissing: HistoryMetadataPageMissingBehavior
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(ifPageMissing: HistoryMetadataPageMissingBehavior = .ignoreObservation) {
+        self.ifPageMissing = ifPageMissing
+    }
+}
+
+
+
+extension NoteHistoryMetadataObservationOptions: Equatable, Hashable {
+    public static func ==(lhs: NoteHistoryMetadataObservationOptions, rhs: NoteHistoryMetadataObservationOptions) -> Bool {
+        if lhs.ifPageMissing != rhs.ifPageMissing {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(ifPageMissing)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNoteHistoryMetadataObservationOptions: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NoteHistoryMetadataObservationOptions {
+        return
+            try NoteHistoryMetadataObservationOptions(
+                ifPageMissing: FfiConverterTypeHistoryMetadataPageMissingBehavior.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: NoteHistoryMetadataObservationOptions, into buf: inout [UInt8]) {
+        FfiConverterTypeHistoryMetadataPageMissingBehavior.write(value.ifPageMissing, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNoteHistoryMetadataObservationOptions_lift(_ buf: RustBuffer) throws -> NoteHistoryMetadataObservationOptions {
+    return try FfiConverterTypeNoteHistoryMetadataObservationOptions.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNoteHistoryMetadataObservationOptions_lower(_ value: NoteHistoryMetadataObservationOptions) -> RustBuffer {
+    return FfiConverterTypeNoteHistoryMetadataObservationOptions.lower(value)
+}
+
+
 public struct RunMaintenanceMetrics {
     public var prunedVisits: Bool
     public var dbSizeBefore: UInt32
@@ -3555,6 +3617,80 @@ extension FrecencyThresholdOption: Equatable, Hashable {}
 
 
 
+// Note that we don't yet support `indirect` for enums.
+// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
+/**
+ * The action to take when recording a history metadata observation for
+ * a page that doesn't have an entry in the history database.
+ */
+
+public enum HistoryMetadataPageMissingBehavior {
+    
+    /**
+     * Insert an entry for the page into the history database.
+     */
+    case insertPage
+    /**
+     * Ignore and discard the observation. This is the default behavior.
+     */
+    case ignoreObservation
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeHistoryMetadataPageMissingBehavior: FfiConverterRustBuffer {
+    typealias SwiftType = HistoryMetadataPageMissingBehavior
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> HistoryMetadataPageMissingBehavior {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .insertPage
+        
+        case 2: return .ignoreObservation
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: HistoryMetadataPageMissingBehavior, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .insertPage:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .ignoreObservation:
+            writeInt(&buf, Int32(2))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeHistoryMetadataPageMissingBehavior_lift(_ buf: RustBuffer) throws -> HistoryMetadataPageMissingBehavior {
+    return try FfiConverterTypeHistoryMetadataPageMissingBehavior.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeHistoryMetadataPageMissingBehavior_lower(_ value: HistoryMetadataPageMissingBehavior) -> RustBuffer {
+    return FfiConverterTypeHistoryMetadataPageMissingBehavior.lower(value)
+}
+
+
+
+extension HistoryMetadataPageMissingBehavior: Equatable, Hashable {}
+
+
+
 // Note that we don't yet support `indirect` for enums.
 // See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
 
@@ -4792,7 +4928,7 @@ private var initializationResult: InitializationResult = {
     if (uniffi_places_checksum_method_placesconnection_new_interrupt_handle() != 5418) {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_places_checksum_method_placesconnection_note_history_metadata_observation() != 12555) {
+    if (uniffi_places_checksum_method_placesconnection_note_history_metadata_observation() != 31493) {
         return InitializationResult.apiChecksumMismatch
     }
     if (uniffi_places_checksum_method_placesconnection_places_history_import_from_ios() != 596) {

swift-source/all/Generated/placesFFI.h

@@ -463,7 +463,7 @@ void*_Nonnull uniffi_places_fn_method_placesconnection_new_interrupt_handle(void
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PLACES_FN_METHOD_PLACESCONNECTION_NOTE_HISTORY_METADATA_OBSERVATION
 #define UNIFFI_FFIDEF_UNIFFI_PLACES_FN_METHOD_PLACESCONNECTION_NOTE_HISTORY_METADATA_OBSERVATION
-void uniffi_places_fn_method_placesconnection_note_history_metadata_observation(void*_Nonnull ptr, RustBuffer data, RustCallStatus *_Nonnull out_status
+void uniffi_places_fn_method_placesconnection_note_history_metadata_observation(void*_Nonnull ptr, RustBuffer data, RustBuffer options, RustCallStatus *_Nonnull out_status
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PLACES_FN_METHOD_PLACESCONNECTION_PLACES_HISTORY_IMPORT_FROM_IOS

swift-source/all/Places/Places.swift

@@ -299,6 +299,37 @@ public class PlacesReadConnection {
         }
     }
 
+    /**
+     * Counts the number of bookmark items in the bookmark trees under the specified GUIDs.
+     * Empty folders, non-existing GUIDs and non-folder guids will return zero.
+     *
+     * - Parameter folderGuids: The guids of folders to query.
+     * - Returns: Count of all bookmark items (ie, not folders or separators) in all specified folders recursively.
+     * - Throws:
+     *     - `PlacesApiError.databaseInterrupted`: If a call is made to
+     *                                             `interrupt()` on this object
+     *                                             from another thread.
+     *     - `PlacesConnectionError.connUseAfterAPIClosed`: If the PlacesAPI that returned
+     *                                                      this connection object has
+     *                                                      been closed. This indicates
+     *                                                      API misuse.
+     *     - `PlacesApiError.databaseBusy`: If this query times out with a
+     *                                      SQLITE_BUSY error.
+     *     - `PlacesApiError.unexpected`: When an error that has not specifically
+     *                                    been exposed to Swift is encountered (for
+     *                                    example IO errors from the database code,
+     *                                    etc).
+     *     - `PlacesApiError.panic`: If the rust code panics while completing this
+     *                               operation. (If this occurs, please let us
+     *                               know).
+     */
+    open func countBookmarksInTrees(folderGuids: [Guid]) throws -> Int {
+        return try queue.sync {
+            try self.checkApi()
+            return try Int(self.conn.bookmarksCountBookmarksInTrees(folderGuids: folderGuids))
+        }
+    }
+
     open func getLatestHistoryMetadataForUrl(url: Url) throws -> HistoryMetadata? {
         return try queue.sync {
             try self.checkApi()
@@ -700,44 +731,57 @@ public class PlacesWriteConnection: PlacesReadConnection {
     // MARK: History metadata write APIs
 
     open func noteHistoryMetadataObservation(
-        observation: HistoryMetadataObservation
+        observation: HistoryMetadataObservation,
+        _ options: NoteHistoryMetadataObservationOptions = NoteHistoryMetadataObservationOptions()
     ) throws {
         try queue.sync {
             try self.checkApi()
-            try self.conn.noteHistoryMetadataObservation(data: observation)
+            try self.conn.noteHistoryMetadataObservation(data: observation, options: options)
         }
     }
 
     // Keeping these three functions inline with what Kotlin (PlacesConnection.kt)
     // to make future work more symmetrical
-    open func noteHistoryMetadataObservationViewTime(key: HistoryMetadataKey, viewTime: Int32?) throws {
+    open func noteHistoryMetadataObservationViewTime(
+        key: HistoryMetadataKey,
+        viewTime: Int32?,
+        _ options: NoteHistoryMetadataObservationOptions = NoteHistoryMetadataObservationOptions()
+    ) throws {
         let obs = HistoryMetadataObservation(
             url: key.url,
             referrerUrl: key.referrerUrl,
             searchTerm: key.searchTerm,
             viewTime: viewTime
         )
-        try noteHistoryMetadataObservation(observation: obs)
+        try noteHistoryMetadataObservation(observation: obs, options)
     }
 
-    open func noteHistoryMetadataObservationDocumentType(key: HistoryMetadataKey, documentType: DocumentType) throws {
+    open func noteHistoryMetadataObservationDocumentType(
+        key: HistoryMetadataKey,
+        documentType: DocumentType,
+        _ options: NoteHistoryMetadataObservationOptions = NoteHistoryMetadataObservationOptions()
+    ) throws {
         let obs = HistoryMetadataObservation(
             url: key.url,
             referrerUrl: key.referrerUrl,
             searchTerm: key.searchTerm,
             documentType: documentType
         )
-        try noteHistoryMetadataObservation(observation: obs)
+        try noteHistoryMetadataObservation(observation: obs, options)
     }
 
-    open func noteHistoryMetadataObservationTitle(key: HistoryMetadataKey, title: String) throws {
+    open func noteHistoryMetadataObservationTitle(
+        key: HistoryMetadataKey,
+        title: String,
+        _ options: NoteHistoryMetadataObservationOptions = NoteHistoryMetadataObservationOptions()
+    ) throws {
         let obs = HistoryMetadataObservation(
             url: key.url,
             referrerUrl: key.referrerUrl,
             searchTerm: key.searchTerm,
             title: title
         )
-        try noteHistoryMetadataObservation(observation: obs)
+        try noteHistoryMetadataObservation(observation: obs, options)
     }
 
     open func deleteHistoryMetadataOlderThan(olderThan: Int64) throws {

swift-source/focus/Generated/Metrics/Metrics.swift

@@ -23,7 +23,7 @@ extension GleanMetrics {
             // Intentionally left private, no external user can instantiate a new global object.
         }
 
-        public static let info = BuildInfo(buildDate: DateComponents(calendar: Calendar.current, timeZone: TimeZone(abbreviation: "UTC"), year: 2024, month: 11, day: 9, hour: 5, minute: 12, second: 49))
+        public static let info = BuildInfo(buildDate: DateComponents(calendar: Calendar.current, timeZone: TimeZone(abbreviation: "UTC"), year: 2024, month: 11, day: 13, hour: 5, minute: 21, second: 19))
     }
 
     enum NimbusEvents {