Merge pull request #130 from mozilla/enterprise_bug1998475-start_thread_later

Bug 1998475 - Move felt connection thread start later r?mossop

Author: lissyx

browser/extensions/felt/rust/src/client.rs

@@ -150,6 +150,7 @@ impl FeltClientThread {
         // Define an observer
         #[xpcom(implement(nsIObserver), nonatomic)]
         struct Observer {
+            profile_ready: Arc<AtomicBool>,
             thread_stop: Arc<AtomicBool>,
             notify_restart: Arc<AtomicBool>,
         }
@@ -163,6 +164,10 @@ impl FeltClientThread {
                 data: *const u16,
             ) -> nsresult {
                 match unsafe { CStr::from_ptr(topic).to_str() } {
+                    Ok("profile-after-change") => {
+                        trace!("FeltClientThread::start_thread::observe() profile-after-change");
+                        self.profile_ready.store(true, Ordering::Relaxed);
+                    }
                     Ok("xpcom-shutdown-threads") => {
                         trace!("FeltClientThread::start_thread::observe() xpcom-shutdown-threads");
                         self.thread_stop.store(true, Ordering::Relaxed);
@@ -213,24 +218,35 @@ impl FeltClientThread {
         trace!("FeltClientThread::start_thread(): get observer service");
         let obssvc: RefPtr<nsIObserverService> = xpcom::components::Observer::service().unwrap();
 
+        let profile_after_change = CString::new("profile-after-change").unwrap();
         let xpcom_shutdown = CString::new("xpcom-shutdown-threads").unwrap();
         let quit_application = CString::new("quit-application").unwrap();
 
+        let profile_ready = Arc::new(AtomicBool::new(false));
         let thread_stop = Arc::new(AtomicBool::new(false));
         let notify_restart = Arc::new(AtomicBool::new(false));
         let observer = Observer::allocate(InitObserver {
+            profile_ready: profile_ready.clone(),
             thread_stop: thread_stop.clone(),
             notify_restart: notify_restart.clone(),
         });
         let mut rv = unsafe {
+            obssvc.AddObserver(
+                observer.coerce::<nsIObserver>(),
+                profile_after_change.as_ptr(),
+                false,
+            )
+        };
+        assert!(rv.succeeded());
+
+        rv = unsafe {
             obssvc.AddObserver(
                 observer.coerce::<nsIObserver>(),
                 xpcom_shutdown.as_ptr(),
                 false,
             )
         };
         assert!(rv.succeeded());
-        trace!("FeltClientThread::start_thread(): added observers");
 
         rv = unsafe {
             obssvc.AddObserver(
@@ -240,8 +256,10 @@ impl FeltClientThread {
             )
         };
         assert!(rv.succeeded());
+        trace!("FeltClientThread::start_thread(): added observers");
 
         let barrier = self.startup_ready.clone();
+        let profile_ready_internal = profile_ready.clone();
         let thread_stop_internal = thread_stop.clone();
         let notify_restart_internal = notify_restart.clone();
         let mut felt_client = self.ipc_client.take();
@@ -250,17 +268,31 @@ impl FeltClientThread {
             trace!("FeltClientThread::start_thread(): felt_client thread runnable");
                 trace!("FeltClientThread::start_thread(): felt_client version OK");
                 if let Some(rx) = felt_client.rx.take() {
+                    let mut pending_cookies: Vec<String> = Vec::new();
+
                     loop {
                         if notify_restart_internal.load(Ordering::Relaxed) {
                             notify_restart_internal.store(false, Ordering::Relaxed);
                             trace!("FeltClientThread::felt_client::ipc_loop(): restart notification required!");
                             felt_client.notify_restart();
                         }
 
+                        if pending_cookies.len() > 0 && profile_ready_internal.load(Ordering::Relaxed) {
+                            trace!("FeltClientThread::felt_client::ipc_loop(): Profile ready! Start cookies injection!");
+                            while let Some(one_cookie) = pending_cookies.pop() {
+                                utils::inject_one_cookie(one_cookie);
+                            }
+                            trace!("FeltClientThread::felt_client::ipc_loop(): Profile ready! Finished cookies injection!");
+                        }
+
                         match rx.try_recv_timeout(Duration::from_millis(250)) {
                             Ok(FeltMessage::Cookie(felt_cookie)) => {
                                 trace!("FeltClientThread::felt_client::ipc_loop(): received cookie: {}", felt_cookie.clone());
-                                utils::inject_one_cookie(felt_cookie);
+                                if profile_ready_internal.load(Ordering::Relaxed) {
+                                    utils::inject_one_cookie(felt_cookie);
+                                } else {
+                                    pending_cookies.push(felt_cookie);
+                                }
                             },
                             Ok(FeltMessage::BoolPreference((name, value))) => {
                                 trace!("FeltClientThread::felt_client::ipc_loop(): BoolPreference({}, {})", name, value);

testing/enterprise/base_test.py

@@ -179,10 +179,26 @@ def __init__(
         self._logger.info(f"Exiting with {ec}")
         self._logger.suite_end()
 
+        ec = self.check_for_crashes(ec)
+
         shutil.rmtree(profile_path, ignore_errors=True)
 
         sys.exit(ec)
 
+    def check_for_crashes(self, exit_code):
+        for log_file in ["geckodriver.log", "geckodriver_child.log"]:
+            if log_file != "geckodriver.log" and not os.path.isfile(log_file):
+                # Only geckodriver.log is really required others can be missing
+                continue
+
+            with open(log_file) as log_content:
+                for line in log_content:
+                    if "MOZ_CRASH()" in line:
+                        print("Crash reported at =>", line)
+                        return 1
+
+        return exit_code
+
     def get_screenshot_destination(self, name):
         final_name = name
         if "MOZ_AUTOMATION" in os.environ.keys():