Backed out changeset af229d7b8c35 (bug 1947513) for causing build bustages.

Cargo.lock

@@ -5548,7 +5548,6 @@ name = "rsclientcerts"
 version = "0.1.0"
 dependencies = [
  "byteorder",
- "gecko-profiler",
  "pkcs11-bindings",
 ]
 

security/manager/ssl/osclientcerts/src/lib.rs

@@ -130,7 +130,7 @@ extern "C" fn C_Initialize(_pInitArgs: CK_VOID_PTR) -> CK_RV {
         vec![CKM_ECDSA, CKM_RSA_PKCS]
     };
     let mut module_state_guard = try_to_get_module_state_guard!();
-    let manager_proxy = match ManagerProxy::new("osclientcerts", Backend {}) {
+    let manager_proxy = match ManagerProxy::new(Backend {}) {
         Ok(p) => p,
         Err(e) => {
             log_with_thread_id!(error, "C_Initialize: ManagerProxy: {}", e);

security/manager/ssl/rsclientcerts/Cargo.toml

@@ -7,5 +7,4 @@ license = "MPL-2.0"
 
 [dependencies]
 byteorder = "1.3"
-gecko-profiler = { path = "../../../../tools/profiler/rust-api" }
 pkcs11-bindings = "0.1"

security/manager/ssl/rsclientcerts/src/manager.rs

@@ -120,70 +120,71 @@ pub struct ManagerProxy {
 }
 
 impl ManagerProxy {
-    pub fn new<B: ClientCertsBackend + Send + 'static>(
+    pub fn new<B: ClientCertsBackend + Send + 'static>(backend: B) -> Result<ManagerProxy, Error> {
-        name: &'static str,
-        backend: B,
-    ) -> Result<ManagerProxy, Error> {
         let (proxy_sender, manager_receiver) = channel();
         let (manager_sender, proxy_receiver) = channel();
-        let thread_handle = thread::Builder::new().name(name.into()).spawn(move || {
+        let thread_handle = thread::Builder::new()
-            gecko_profiler::register_thread(name);
+            .name("osclientcert".into())
-            let mut real_manager = Manager::new(backend);
+            .spawn(move || {
-            while let Ok(arguments) = manager_receiver.recv() {
+                let mut real_manager = Manager::new(backend);
-                let results = match arguments {
+                while let Ok(arguments) = manager_receiver.recv() {
-                    ManagerArguments::OpenSession(slot_type) => {
+                    let results = match arguments {
-                        ManagerReturnValue::OpenSession(real_manager.open_session(slot_type))
+                        ManagerArguments::OpenSession(slot_type) => {
+                            ManagerReturnValue::OpenSession(real_manager.open_session(slot_type))
+                        }
+                        ManagerArguments::CloseSession(session_handle) => {
+                            ManagerReturnValue::CloseSession(
+                                real_manager.close_session(session_handle),
+                            )
+                        }
+                        ManagerArguments::CloseAllSessions(slot_type) => {
+                            ManagerReturnValue::CloseAllSessions(
+                                real_manager.close_all_sessions(slot_type),
+                            )
+                        }
+                        ManagerArguments::StartSearch(session, attrs) => {
+                            ManagerReturnValue::StartSearch(
+                                real_manager.start_search(session, attrs),
+                            )
+                        }
+                        ManagerArguments::Search(session, max_objects) => {
+                            ManagerReturnValue::Search(real_manager.search(session, max_objects))
+                        }
+                        ManagerArguments::ClearSearch(session) => {
+                            ManagerReturnValue::ClearSearch(real_manager.clear_search(session))
+                        }
+                        ManagerArguments::GetAttributes(object_handle, attr_types) => {
+                            ManagerReturnValue::GetAttributes(
+                                real_manager.get_attributes(object_handle, attr_types),
+                            )
+                        }
+                        ManagerArguments::StartSign(session, key_handle, params) => {
+                            ManagerReturnValue::StartSign(
+                                real_manager.start_sign(session, key_handle, params),
+                            )
+                        }
+                        ManagerArguments::GetSignatureLength(session, data) => {
+                            ManagerReturnValue::GetSignatureLength(
+                                real_manager.get_signature_length(session, data),
+                            )
+                        }
+                        ManagerArguments::Sign(session, data) => {
+                            ManagerReturnValue::Sign(real_manager.sign(session, data))
+                        }
+                        ManagerArguments::Stop => ManagerReturnValue::Stop(Ok(())),
+                    };
+                    let stop_after_send = matches!(&results, &ManagerReturnValue::Stop(_));
+                    match manager_sender.send(results) {
+                        Ok(()) => {}
+                        Err(_) => {
+                            break;
+                        }
                     }
-                    ManagerArguments::CloseSession(session_handle) => {
+                    if stop_after_send {
-                        ManagerReturnValue::CloseSession(real_manager.close_session(session_handle))
-                    }
-                    ManagerArguments::CloseAllSessions(slot_type) => {
-                        ManagerReturnValue::CloseAllSessions(
-                            real_manager.close_all_sessions(slot_type),
-                        )
-                    }
-                    ManagerArguments::StartSearch(session, attrs) => {
-                        ManagerReturnValue::StartSearch(real_manager.start_search(session, attrs))
-                    }
-                    ManagerArguments::Search(session, max_objects) => {
-                        ManagerReturnValue::Search(real_manager.search(session, max_objects))
-                    }
-                    ManagerArguments::ClearSearch(session) => {
-                        ManagerReturnValue::ClearSearch(real_manager.clear_search(session))
-                    }
-                    ManagerArguments::GetAttributes(object_handle, attr_types) => {
-                        ManagerReturnValue::GetAttributes(
-                            real_manager.get_attributes(object_handle, attr_types),
-                        )
-                    }
-                    ManagerArguments::StartSign(session, key_handle, params) => {
-                        ManagerReturnValue::StartSign(
-                            real_manager.start_sign(session, key_handle, params),
-                        )
-                    }
-                    ManagerArguments::GetSignatureLength(session, data) => {
-                        ManagerReturnValue::GetSignatureLength(
-                            real_manager.get_signature_length(session, data),
-                        )
-                    }
-                    ManagerArguments::Sign(session, data) => {
-                        ManagerReturnValue::Sign(real_manager.sign(session, data))
-                    }
-                    ManagerArguments::Stop => ManagerReturnValue::Stop(Ok(())),
-                };
-                let stop_after_send = matches!(&results, &ManagerReturnValue::Stop(_));
-                match manager_sender.send(results) {
-                    Ok(()) => {}
-                    Err(_) => {
                         break;
                     }
                 }
-                if stop_after_send {
+            });
-                    break;
-                }
-            }
-            gecko_profiler::unregister_thread();
-        });
         match thread_handle {
             Ok(thread_handle) => Ok(ManagerProxy {
                 sender: proxy_sender,