revert last two commits webdriver changes to see if windows passes

Signed-off-by: Andrei Gherghescu <[email protected]>

Author: andrei-ng

plotly_static/src/lib.rs

@@ -274,7 +274,7 @@ use serde_json::map::Map as JsonMap;
 use urlencoding::encode;
 use webdriver::WebDriver;
 
-use crate::template::{get_pdf_export_js_script, IMAGE_EXPORT_JS_SCRIPT};
+use crate::template::{IMAGE_EXPORT_JS_SCRIPT, PDF_EXPORT_JS_SCRIPT};
 
 #[cfg(all(feature = "chromedriver", not(target_os = "windows")))]
 fn chrome_default_caps() -> Vec<&'static str> {
@@ -969,7 +969,7 @@ impl StaticExporter {
                     plot.scale.into(),
                 ];
 
-                (get_pdf_export_js_script(), args)
+                (PDF_EXPORT_JS_SCRIPT, args)
             }
             _ => {
                 let args = vec![
@@ -980,11 +980,11 @@ impl StaticExporter {
                     plot.scale.into(),
                 ];
 
-                (IMAGE_EXPORT_JS_SCRIPT.to_string(), args)
+                (IMAGE_EXPORT_JS_SCRIPT, args)
             }
         };
 
-        let data = client.execute_async(&js_script, args).await?;
+        let data = client.execute_async(js_script, args).await?;
 
         // Don't close the client - keep it for reuse
         // client.close().await?;

plotly_static/src/template.rs

@@ -35,15 +35,7 @@ pub(crate) const IMAGE_EXPORT_JS_SCRIPT: &str = r#"
     });
 "#;
 
-pub(crate) fn get_pdf_export_js_script() -> String {
-    let timeout_ms = if cfg!(feature = "ci_pdf_timeout") {
-        500
-    } else {
-        250
-    };
-
-    format!(
-        r##"
+pub(crate) const PDF_EXPORT_JS_SCRIPT: &str = r##"
     const plot = arguments[0];
     const format = arguments[1];
     const width = arguments[2];
@@ -53,26 +45,26 @@ pub(crate) fn get_pdf_export_js_script() -> String {
 
     const graph_div = document.getElementById('plotly-html-element');
 
-    if (typeof html2pdf === 'undefined') {{
+    if (typeof html2pdf === 'undefined') {
         callback('ERROR:html2pdf library not loaded');
         return;
-    }}
+    }
 
     let tempDiv = null;
 
-    const cleanup = () => {{
-        if (tempDiv) {{
+    const cleanup = () => {
+        if (tempDiv) {
             document.body.removeChild(tempDiv);
-        }}
-    }};
+        }
+    };
 
-    Plotly.newPlot(graph_div, plot).then(function() {{
-        return Plotly.toImage(graph_div, {{
+    Plotly.newPlot(graph_div, plot).then(function() {
+        return Plotly.toImage(graph_div, {
             format: format,
             width: width,
             height: height,
-        }});
-    }}).then(function(dataUrl) {{
+        });
+    }).then(function(dataUrl) {
         tempDiv = document.createElement('div');
         tempDiv.style.width = width + 'px';
         tempDiv.style.height = height + 'px';
@@ -96,22 +88,22 @@ pub(crate) fn get_pdf_export_js_script() -> String {
         img.style.boxSizing = 'border-box';
         tempDiv.appendChild(img);
 
-        return new Promise(function(resolve) {{
-            img.onload = function() {{
+        return new Promise(function(resolve) {
+            img.onload = function() {
                 // Brief delay to ensure image is fully rendered
-                setTimeout(resolve, {timeout_ms});
-            }};
-            img.onerror = function() {{
+                setTimeout(resolve, 650);
+            };
+            img.onerror = function() {
                 cleanup();
                 callback('ERROR:Failed to load image');
-            }};
-        }});
-    }}).then(function() {{
-        return html2pdf().from(tempDiv).set({{
+            };
+        });
+    }).then(function() {
+        return html2pdf().from(tempDiv).set({
             margin: 0,
             filename: 'plotly-plot.pdf',
-            image: {{ type: 'jpeg', quality: 1}},
-            html2canvas: {{
+            image: { type: 'jpeg', quality: 1},
+            html2canvas: {
                 scale: scale,
                 backgroundColor: '#fff',
                 useCORS: true,
@@ -124,24 +116,22 @@ pub(crate) fn get_pdf_export_js_script() -> String {
                 foreignObjectRendering: false,
                 scrollY: 0,
                 scrollX: 0
-            }},
-            jsPDF: {{
+            },
+            jsPDF: {
                 unit: 'px',
                 format: [width, height],
                 orientation: width > height ? 'landscape' : 'portrait',
                 compress: true
-            }}
-        }}).toPdf().output('datauristring');
-    }}).then(function(dataUri) {{
+            }
+        }).toPdf().output('datauristring');
+    }).then(function(dataUri) {
         cleanup();
         callback(dataUri);
-    }}).catch(function(err) {{
+    }).catch(function(err) {
         cleanup();
         callback('ERROR:' + err.toString());
-    }});
-"##
-    )
-}
+    });
+"##;
 
 pub(crate) fn get_html_body(offline: bool) -> String {
     let offline_js = offline_js_sources();

plotly_static/src/webdriver.rs

@@ -208,114 +208,93 @@ impl WebDriver {
 
     fn spawn_process(&self, driver_path: &Option<PathBuf>, port: u32) -> Result<Child> {
         let driver_path = driver_path.as_ref().unwrap(); // Safe unwrap since we validated above
+        let mut command = Command::new(driver_path);
+        command.arg(format!("--port={port}"));
+
+        // Add verbose flag only for chromedriver
+        #[cfg(feature = "chromedriver")]
+        command.arg("--verbose");
+
+        command
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+
+        info!(
+            "Executing command: {:?} {:?}",
+            command.get_program(),
+            command.get_args()
+        );
 
-        let mut command = Self::create_command(driver_path, port);
-        Self::log_command(&command);
+        #[cfg(target_os = "windows")]
+        {
+            use std::os::windows::process::CommandExt;
+            // Try with CREATE_NO_WINDOW for headless operation
+            command.creation_flags(0x08000000); // CREATE_NO_WINDOW flag
+        }
 
+        // Try to spawn the process
         match command.spawn() {
             Ok(child) => Ok(child),
             Err(e) => {
-                #[cfg(not(target_os = "windows"))]
-                {
-                    Err(self.handle_spawn_error(e, &command, "standard method"))
-                }
                 #[cfg(target_os = "windows")]
                 {
                     // If CREATE_NO_WINDOW fails, try without any special flags
                     error!("Failed to spawn with CREATE_NO_WINDOW: {e}");
                     error!("Trying without special creation flags...");
 
-                    let mut fallback_command = Self::standard_command(driver_path, port);
-                    Self::log_command(&fallback_command);
+                    let mut fallback_command = Command::new(driver_path);
+                    fallback_command.arg(format!("--port={port}"));
+
+                    #[cfg(feature = "chromedriver")]
+                    fallback_command.arg("--verbose");
+
+                    fallback_command
+                        .stdin(Stdio::piped())
+                        .stdout(Stdio::piped())
+                        .stderr(Stdio::piped());
 
                     match fallback_command.spawn() {
                         Ok(child) => {
                             info!("Successfully spawned WebDriver without special creation flags");
                             Ok(child)
                         }
                         Err(fallback_e) => {
+                            error!("Failed to spawn '{WEBDRIVER_BIN}' with fallback method: {fallback_e}");
                             error!("Original error: {e}");
                             error!("Fallback error: {fallback_e}");
-                            Err(self.handle_spawn_error(
-                                fallback_e,
-                                &fallback_command,
-                                "fallback method",
-                            ))
+                            error!(
+                                "Command was: {:?} {:?}",
+                                command.get_program(),
+                                command.get_args()
+                            );
+                            error!("Windows: Check if antivirus is blocking the process");
+                            error!("Windows: Check if the binary has proper permissions");
+                            error!(
+                                "WebDriver diagnostics after spawn failure:\n{}",
+                                self.get_diagnostics()
+                            );
+                            Err(anyhow!("Failed to spawn '{WEBDRIVER_BIN}': {}", fallback_e))
                         }
                     }
                 }
-            }
-        }
-    }
-
-    /// Creates a command with standard configuration (no Windows flags)
-    fn standard_command(driver_path: &PathBuf, port: u32) -> Command {
-        let mut command = Command::new(driver_path);
-        command.arg(format!("--port={port}"));
-
-        // Add verbose flag only for chromedriver
-        #[cfg(feature = "chromedriver")]
-        command.arg("--verbose");
-
-        command
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped());
-
-        command
-    }
-
-    /// Creates a command with Windows-specific flags
-    #[cfg(target_os = "windows")]
-    fn create_command(driver_path: &PathBuf, port: u32) -> Command {
-        use std::os::windows::process::CommandExt;
-
-        let mut command = Self::standard_command(driver_path, port);
-        // Try with CREATE_NO_WINDOW for headless operation
-        command.creation_flags(0x08000000); // CREATE_NO_WINDOW flag
-        command
-    }
-
-    #[cfg(not(target_os = "windows"))]
-    fn create_command(driver_path: &PathBuf, port: u32) -> Command {
-        Self::standard_command(driver_path, port)
-    }
-
-    /// Logs command execution details
-    fn log_command(command: &Command) {
-        info!(
-            "Executing command: {:?} {:?}",
-            command.get_program(),
-            command.get_args()
-        );
-    }
-
-    /// Handles spawn errors with appropriate logging and diagnostics
-    fn handle_spawn_error(
-        &self,
-        e: std::io::Error,
-        command: &Command,
-        attempt: &str,
-    ) -> anyhow::Error {
-        error!("Failed to spawn '{WEBDRIVER_BIN}' with {attempt}: {e}");
-        error!(
-            "Command was: {:?} {:?}",
-            command.get_program(),
-            command.get_args()
-        );
 
-        #[cfg(target_os = "windows")]
-        if attempt == "CREATE_NO_WINDOW" {
-            error!("Windows: Check if antivirus is blocking the process");
-            error!("Windows: Check if the binary has proper permissions");
+                #[cfg(not(target_os = "windows"))]
+                {
+                    error!("Failed to spawn '{WEBDRIVER_BIN}': {e}");
+                    error!(
+                        "Command was: {:?} {:?}",
+                        command.get_program(),
+                        command.get_args()
+                    );
+                    error!(
+                        "WebDriver diagnostics after spawn failure:\n{}",
+                        self.get_diagnostics()
+                    );
+                    Err(anyhow!("Failed to spawn '{WEBDRIVER_BIN}': {}", e))
+                }
+            }
         }
-
-        error!(
-            "WebDriver diagnostics after spawn failure:\n{}",
-            self.get_diagnostics()
-        );
-
-        anyhow!("Failed to spawn '{WEBDRIVER_BIN}': {}", e)
     }
 
     fn setup_output_monitoring(&self, child: &mut Child, port: u32) {