Implement multi-strategy full-page screenshot with CDP and Firefox native support

- Add Chrome DevTools Protocol (CDP) method for Chrome/Edge browsers
  Works in both headless and non-headless mode without screen size limits
- Add Firefox native full-page screenshot support
- Implement browser detection and capability checking
- Use strategy pattern with automatic fallback to window resize method
- Window resize method validates actual dimensions and warns on limitations
- Update documentation to describe the three screenshot strategies
- Resolves screen size limitation concerns in non-headless mode

Author: certainly-param

src/SeleniumLibrary/keywords/screenshot.py

@@ -14,8 +14,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import os
+import base64
 from typing import Optional, Union
-from base64 import b64decode
 
 from robot.utils import get_link_path
 from selenium.webdriver.remote.webelement import WebElement
@@ -204,9 +204,22 @@ def _capture_element_screen_to_log(self, element, return_val):
     def capture_fullpage_screenshot(self, filename: str = DEFAULT_FILENAME_FULLPAGE) -> str:
         """Takes a screenshot of the entire page, including parts not visible in viewport.
 
-        This keyword is useful when you need to capture a long page that requires
-        scrolling. It works by temporarily resizing the browser window to show
-        the full page height, taking the screenshot, then restoring the original size.
+        This keyword captures the full height and width of a web page, even if it extends
+        beyond the current viewport. The implementation automatically selects the best
+        available method based on the browser:
+
+        *Screenshot Methods (in order of preference):*
+
+        1. **Chrome DevTools Protocol (CDP)**: Used for Chrome, Edge, and Chromium browsers.
+           Works in both headless and non-headless mode without screen size limitations.
+
+        2. **Firefox Native Method**: Used for Firefox browsers. Captures full page
+           using the browser's built-in capability.
+
+        3. **Window Resize Method**: Fallback for other browsers. Temporarily resizes
+           the browser window to match page dimensions. In non-headless mode, this may
+           be limited by physical screen size, and a warning will be logged if the full
+           page cannot be captured.
 
         ``filename`` argument specifies where to save the screenshot file.
         The directory can be set with `Set Screenshot Directory` keyword or
@@ -241,7 +254,27 @@ def capture_fullpage_screenshot(self, filename: str = DEFAULT_FILENAME_FULLPAGE)
         return self._capture_fullpage_screenshot_to_file(filename)
 
     def _capture_fullpage_screenshot_to_file(self, filename):
-        """Save fullpage screenshot to file."""
+        """Save fullpage screenshot to file using best available method."""
+        # Try CDP first (Chrome/Edge/Chromium) - works in both headless and non-headless
+        if self._supports_cdp():
+            result = self._capture_fullpage_via_cdp(filename)
+            if result:
+                self.debug("Full-page screenshot captured using Chrome DevTools Protocol")
+                return result
+        
+        # Try Firefox native method
+        if self._supports_native_fullpage():
+            result = self._capture_fullpage_via_firefox(filename)
+            if result:
+                self.debug("Full-page screenshot captured using Firefox native method")
+                return result
+        
+        # Fallback to resize method (works in headless mode for all browsers)
+        self.debug("Using window resize method for full-page screenshot")
+        return self._capture_fullpage_via_resize(filename)
+
+    def _capture_fullpage_via_resize(self, filename):
+        """Fallback method: Save fullpage screenshot by resizing window."""
         # Remember current window size so we can restore it later
         original_size = self.driver.get_window_size()
 
@@ -256,6 +289,17 @@ def _capture_fullpage_screenshot_to_file(self, filename):
             import time
             time.sleep(0.5)
 
+            # Verify the window actually resized to requested dimensions
+            # In non-headless mode, browsers may be limited by screen size
+            actual_size = self.driver.get_window_size()
+            if actual_size['height'] < full_height * 0.95:  # Allow 5% tolerance for browser chrome
+                self.warn(
+                    f"Browser window could not be resized to full page height. "
+                    f"Requested: {full_height}px, Actual: {actual_size['height']}px. "
+                    f"Screenshot may not capture the complete page. "
+                    f"Consider running in headless mode for better full-page screenshot support."
+                )
+            
             # Now take the screenshot
             path = self._get_screenshot_path(filename)
             self._create_directory(path)
@@ -269,7 +313,34 @@ def _capture_fullpage_screenshot_to_file(self, filename):
             self.driver.set_window_size(original_size['width'], original_size['height'])
 
     def _capture_fullpage_screen_to_log(self, return_val):
-        """Get fullpage screenshot as base64 or embed it."""
+        """Get fullpage screenshot as base64 or embed it using best available method."""
+        screenshot_as_base64 = None
+        
+        # Try CDP first (Chrome/Edge/Chromium) - works in both headless and non-headless
+        if self._supports_cdp():
+            screenshot_as_base64 = self._capture_fullpage_via_cdp_base64()
+            if screenshot_as_base64:
+                self.debug("Full-page screenshot captured using Chrome DevTools Protocol")
+        
+        # Try Firefox native method
+        if not screenshot_as_base64 and self._supports_native_fullpage():
+            screenshot_as_base64 = self._capture_fullpage_via_firefox_base64()
+            if screenshot_as_base64:
+                self.debug("Full-page screenshot captured using Firefox native method")
+        
+        # Fallback to resize method
+        if not screenshot_as_base64:
+            self.debug("Using window resize method for full-page screenshot")
+            screenshot_as_base64 = self._capture_fullpage_via_resize_base64()
+        
+        # Embed to log
+        base64_str = self._embed_to_log_as_base64(screenshot_as_base64, 800)
+        if return_val == BASE64:
+            return base64_str
+        return EMBED
+
+    def _capture_fullpage_via_resize_base64(self):
+        """Fallback method: Get fullpage screenshot as base64 by resizing window."""
         # Remember current window size so we can restore it later
         original_size = self.driver.get_window_size()
 
@@ -284,17 +355,127 @@ def _capture_fullpage_screen_to_log(self, return_val):
             import time
             time.sleep(0.5)
 
+            # Verify the window actually resized to requested dimensions
+            # In non-headless mode, browsers may be limited by screen size
+            actual_size = self.driver.get_window_size()
+            if actual_size['height'] < full_height * 0.95:  # Allow 5% tolerance for browser chrome
+                self.warn(
+                    f"Browser window could not be resized to full page height. "
+                    f"Requested: {full_height}px, Actual: {actual_size['height']}px. "
+                    f"Screenshot may not capture the complete page. "
+                    f"Consider running in headless mode for better full-page screenshot support."
+                )
+            
             # Take the screenshot as base64
             screenshot_as_base64 = self.driver.get_screenshot_as_base64()
-            base64_str = self._embed_to_log_as_base64(screenshot_as_base64, 800)
-            if return_val == BASE64:
-                return base64_str
-            return EMBED
+            return screenshot_as_base64
 
         finally:
             # Put the window back to its original size
             self.driver.set_window_size(original_size['width'], original_size['height'])
 
+    def _get_browser_name(self):
+        """Get the name of the current browser."""
+        try:
+            return self.driver.capabilities.get('browserName', '').lower()
+        except:
+            return ''
+
+    def _supports_cdp(self):
+        """Check if browser supports Chrome DevTools Protocol."""
+        browser_name = self._get_browser_name()
+        return browser_name in ['chrome', 'chromium', 'msedge', 'edge', 'MicrosoftEdge']
+
+    def _supports_native_fullpage(self):
+        """Check if browser supports native full-page screenshots."""
+        browser_name = self._get_browser_name()
+        return browser_name == 'firefox'
+
+    def _capture_fullpage_via_cdp(self, filename):
+        """Capture full-page screenshot using Chrome DevTools Protocol."""
+        try:
+            # Get page dimensions
+            metrics = self.driver.execute_cdp_cmd('Page.getLayoutMetrics', {})
+            width = int(metrics['contentSize']['width'])
+            height = int(metrics['contentSize']['height'])
+            
+            # Capture screenshot with full page dimensions
+            screenshot = self.driver.execute_cdp_cmd('Page.captureScreenshot', {
+                'clip': {
+                    'width': width,
+                    'height': height,
+                    'x': 0,
+                    'y': 0,
+                    'scale': 1
+                },
+                'captureBeyondViewport': True
+            })
+            
+            # Save the screenshot
+            path = self._get_screenshot_path(filename)
+            self._create_directory(path)
+            
+            with open(path, 'wb') as f:
+                f.write(base64.b64decode(screenshot['data']))
+            
+            self._embed_to_log_as_file(path, 800)
+            return path
+        except Exception as e:
+            self.debug(f"CDP full-page screenshot failed: {e}. Falling back to resize method.")
+            return None
+
+    def _capture_fullpage_via_cdp_base64(self):
+        """Capture full-page screenshot using CDP and return as base64."""
+        try:
+            # Get page dimensions
+            metrics = self.driver.execute_cdp_cmd('Page.getLayoutMetrics', {})
+            width = int(metrics['contentSize']['width'])
+            height = int(metrics['contentSize']['height'])
+            
+            # Capture screenshot with full page dimensions
+            screenshot = self.driver.execute_cdp_cmd('Page.captureScreenshot', {
+                'clip': {
+                    'width': width,
+                    'height': height,
+                    'x': 0,
+                    'y': 0,
+                    'scale': 1
+                },
+                'captureBeyondViewport': True
+            })
+            
+            return screenshot['data']
+        except Exception as e:
+            self.debug(f"CDP full-page screenshot failed: {e}. Falling back to resize method.")
+            return None
+
+    def _capture_fullpage_via_firefox(self, filename):
+        """Capture full-page screenshot using Firefox native method."""
+        try:
+            path = self._get_screenshot_path(filename)
+            self._create_directory(path)
+            
+            # Firefox has a native full-page screenshot method
+            screenshot_binary = self.driver.get_full_page_screenshot_as_png()
+            
+            with open(path, 'wb') as f:
+                f.write(screenshot_binary)
+            
+            self._embed_to_log_as_file(path, 800)
+            return path
+        except Exception as e:
+            self.debug(f"Firefox native full-page screenshot failed: {e}. Falling back to resize method.")
+            return None
+
+    def _capture_fullpage_via_firefox_base64(self):
+        """Capture full-page screenshot using Firefox and return as base64."""
+        try:
+            screenshot_binary = self.driver.get_full_page_screenshot_as_png()
+            return base64.b64encode(screenshot_binary).decode('utf-8')
+        except Exception as e:
+            self.debug(f"Firefox native full-page screenshot failed: {e}. Falling back to resize method.")
+            return None
+
     @property
     def _screenshot_root_directory(self):
         return self.ctx.screenshot_root_directory
@@ -445,7 +626,7 @@ def _print_page_as_pdf_to_file(self, filename, options):
         return path
 
     def _save_pdf_to_file(self, pdfbase64, path):
-        pdfdata = b64decode(pdfbase64)
+        pdfdata = base64.b64decode(pdfbase64)
         with open(path, mode='wb') as pdf:
             pdf.write(pdfdata)