Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A computer-implemented method for webpage rendering using a remotely generated layout node tree, at least a portion of the method being performed by a remote network device comprising one or more processors and by a local network device comprising one or more processors, the method comprising: (a) generating, at the remote network device, a layout tree based on webpage data received from a webserver, the webpage data received from the webserver including malicious executable content resulting in the layout tree including the malicious executable content; (b) translating, at the remote network device, the layout tree into a layout node tree by traversing each object in the layout tree, translating traversed markup language objects into markup language nodes and traversed style sheet objects into style sheet nodes, and adding the translated markup language nodes and the translated style sheet nodes to the layout node tree, the translating of the layout tree into the layout node tree resulting in the malicious executable content being excluded from the layout node tree; (c) serializing, at the remote network device, the layout node tree; (d) sending, from the remote network device, the serialized layout node tree to the local network device over a network; (e) receiving, at the local network device, the serialized layout node tree; (f) deserializing, at the local network device, the serialized layout node tree to obtain the layout node tree; (g) constructing, at the local network device, a webpage using the layout node tree; and (h) rendering, at the local network device, the webpage in a browser, the webpage being rendered to appear as if the webpage were rendered on the remote network device using the layout tree.
This invention relates to a computer-implemented method for securely rendering webpages by separating the generation of layout data from the local rendering process. The method addresses the problem of malicious executable content in webpage data, which can compromise security when processed locally. The solution involves a remote network device and a local network device working together to render webpages safely. The remote network device receives webpage data from a webserver, which may include malicious executable content. It generates a layout tree from this data, but the malicious content is excluded during translation into a layout node tree. The remote device traverses the layout tree, converting markup language objects into markup language nodes and style sheet objects into style sheet nodes, while filtering out malicious content. The resulting layout node tree is serialized and sent to the local network device over a network. The local network device receives, deserializes, and uses the layout node tree to construct and render the webpage in a browser. The rendered webpage appears as if it were generated directly on the remote device, but without exposing the local device to the original malicious content. This approach enhances security by isolating the processing of potentially harmful webpage elements on a remote server before transmission to the local device.
2. The method of claim 1 , wherein: the markup language objects are Hypertext Markup Language (HTML) objects; the markup language nodes are HTML nodes; the style sheet objects are Cascading Style Sheet (CSS) objects; and the style sheet nodes are CSS nodes.
This invention relates to a method for processing markup language and style sheet objects in web development. The method addresses the challenge of efficiently managing and transforming the structure and presentation of web content by leveraging the hierarchical relationships between markup language and style sheet objects. Specifically, the method involves analyzing and modifying Hypertext Markup Language (HTML) objects and their corresponding nodes, as well as Cascading Style Sheet (CSS) objects and nodes, to ensure consistent and dynamic rendering of web pages. The technique allows for precise control over the visual and structural aspects of web content by manipulating the relationships between HTML and CSS elements, enabling developers to create responsive and adaptable web designs. The method ensures that changes to the markup language or style sheet objects are accurately reflected in the final rendered output, improving the efficiency and accuracy of web development workflows. This approach is particularly useful in modern web development, where dynamic content and responsive design are essential for delivering a seamless user experience across different devices and platforms.
3. The method of claim 2 , wherein the translating at (b) further includes omitting, from the layout tree, any traversed object that is not an HTML object or a CSS object.
This invention relates to web page rendering and optimization, specifically improving the efficiency of translating a document object model (DOM) into a layout tree for rendering. The problem addressed is the computational overhead and inefficiency in processing non-relevant objects during layout calculations, which can slow down web page rendering. The method involves translating a DOM into a layout tree, where the DOM represents the structure of a web page and the layout tree is used to determine the visual positioning and dimensions of elements. The key improvement is in the translation process, where the method selectively omits objects that are not HTML or CSS objects from the layout tree. HTML objects are elements defined by HTML markup, while CSS objects are styling rules applied to those elements. By excluding non-relevant objects (such as JavaScript-generated elements or other non-visual components), the method reduces the number of objects processed, thereby optimizing performance. The method first traverses the DOM to identify all objects. During traversal, it checks each object to determine if it is an HTML object or a CSS object. Only those objects that meet this criterion are included in the layout tree. This selective inclusion ensures that the layout tree contains only the necessary elements for rendering, avoiding unnecessary computations and improving rendering speed. The approach is particularly useful in complex web pages with many dynamic or non-visual elements, where traditional rendering methods may incur significant overhead.
4. The method of claim 3 , wherein the translating at (b) further includes, for each omitted object, connecting any descendant object of the omitted object in the layout tree to any ancestor object of the omitted object in the layout tree.
This invention relates to a method for processing layout trees in document rendering or web page display systems, addressing the challenge of efficiently handling omitted objects while maintaining structural integrity. The method involves translating a layout tree into a display list, where certain objects may be omitted during the translation process. For each omitted object, the method ensures that any descendant objects (objects nested under the omitted object) are properly connected to any ancestor objects (objects higher in the hierarchy) of the omitted object. This reconnection preserves the hierarchical relationships and ensures correct rendering of the remaining objects. The approach is particularly useful in scenarios where objects are conditionally excluded, such as in dynamic content rendering or accessibility adjustments, where maintaining the document structure is critical. By dynamically adjusting the layout tree during translation, the method avoids rendering errors and ensures a coherent visual output. The technique is applicable in web browsers, document viewers, and other systems that process hierarchical layout structures.
5. The method of claim 2 , wherein the translating at (b) of each traversed HTML object into an HTML node includes computing a CSS for the HTML object and adding the computed CSS to the HTML node.
This invention relates to web rendering and dynamic content processing, specifically addressing the challenge of efficiently translating HTML objects into a structured format for rendering while preserving styling information. The method involves traversing a document object model (DOM) to identify HTML objects, then converting each object into an HTML node. A key aspect is computing cascading style sheets (CSS) properties for each HTML object and incorporating these computed styles into the corresponding HTML node. This ensures that the rendered output maintains the intended visual presentation. The process may involve analyzing the HTML object's attributes, parent-child relationships, and associated style rules to determine the appropriate CSS values. By embedding the computed CSS directly into the HTML node, the method streamlines the rendering pipeline, reducing the need for separate style calculations during display. This approach is particularly useful in environments where performance and accuracy of visual representation are critical, such as web browsers or automated content processing systems. The invention improves upon prior methods by integrating style computation into the node creation phase, enhancing efficiency and consistency in web rendering.
6. The method of claim 1 , wherein the generating at (a) is performed in response to the browser, at the local network device, requesting access to the webserver.
This invention relates to web access control in a local network environment. The problem addressed is the need to generate and manage access credentials dynamically when a browser on a local network device requests access to a web server. The solution involves a method where access credentials are generated in response to such a request, ensuring secure and controlled access to the web server. The method includes generating access credentials at a local network device when the browser on that device attempts to connect to the web server. These credentials are used to authenticate the browser's request, allowing or denying access based on predefined security policies. The generated credentials may include tokens, certificates, or other authentication data that verify the identity of the local network device and the browser. The method ensures that access is granted only after proper authentication, enhancing security in network communications. The invention may also involve additional steps such as validating the generated credentials against a central authentication server or a local security policy before granting access. This ensures that only authorized devices and users can interact with the web server, preventing unauthorized access and potential security breaches. The dynamic generation of credentials in response to access requests provides a flexible and secure way to manage web access in a local network.
7. The method of claim 1 , wherein the webpage data received from the webserver includes one or more of Hypertext Markup Language (HTML) data, Cascading Style Sheet (CSS) data, Fonts data, data, and Scalable Vector Graphics (SVG) data.
This invention relates to a method for processing webpage data received from a webserver, addressing the challenge of efficiently handling and utilizing different types of web content. The method involves receiving webpage data that includes various types of content, such as Hypertext Markup Language (HTML) data, Cascading Style Sheet (CSS) data, Fonts data, and Scalable Vector Graphics (SVG) data. The received data is then processed to extract and utilize these different content types for rendering or further analysis. The method ensures compatibility and proper handling of diverse web content formats, enabling accurate display or manipulation of the webpage. By supporting multiple data types, the invention improves the flexibility and robustness of web content processing systems, allowing them to adapt to different web technologies and standards. This approach enhances the efficiency of web applications, browsers, and other systems that rely on accurate interpretation and rendering of webpage data.
8. The method of claim 1 , further comprising: (i) detecting, at the local network device, input from a user entered into the webpage rendered in the browser; (j) sending, from the local network device to the remote network device, the input; (k) sending, from the remote network device to the webserver, the input; (l) receiving, at the remote network device, updated webpage data from the webserver; and (m) repeating (a) through (h) based on the updated webpage data received from the webserver.
This invention relates to a system for securely transmitting and rendering web content between a local network device and a remote network device, addressing security and performance challenges in web browsing. The system involves a local network device, such as a user's computer or mobile device, and a remote network device, such as a proxy server or gateway, that intermediates communication between the local device and a webserver hosting a webpage. The local device sends a request for a webpage to the remote device, which forwards the request to the webserver. The webserver processes the request and sends webpage data back to the remote device, which then transmits the data to the local device. The local device renders the webpage in a browser, allowing the user to interact with it. The system further includes detecting user input entered into the rendered webpage, sending the input from the local device to the remote device, and forwarding the input from the remote device to the webserver. The webserver processes the input and sends updated webpage data back to the remote device, which then transmits the updated data to the local device. The process repeats, enabling dynamic updates to the webpage based on user interactions. This approach enhances security by isolating the local device from direct exposure to the webserver while maintaining real-time interactivity.
9. The method of claim 8 , wherein: the repeating of (b) is performed by only translating markup language objects and style sheet objects that were not previously translated; and the constructing at (g) includes reusing markup language nodes and style sheet nodes that were previously translated at (b) and previously deserialized at (f).
This invention relates to optimizing the translation and deserialization of markup language and style sheet objects in a computing system. The problem addressed is the inefficiency in repeatedly translating and deserializing the same objects, which consumes unnecessary computational resources and processing time. The method involves a process where markup language objects and style sheet objects are translated from a source format to a target format. During this process, only objects that have not been previously translated are processed. This selective translation avoids redundant work by reusing previously translated objects. Additionally, the method includes deserializing the translated objects into a structured format, such as a document object model (DOM) or a style sheet object model (CSSOM). When constructing the final output, the method reuses markup language nodes and style sheet nodes that were already translated and deserialized in prior iterations. This reuse further reduces computational overhead by avoiding repeated processing of the same data. The approach ensures that only new or unprocessed objects are translated and deserialized, while previously processed objects are efficiently reused. This optimization improves performance, particularly in systems where the same markup and style sheet objects are frequently processed, such as web browsers or document rendering engines. The method is applicable to any system that handles markup languages like HTML or XML and style sheets like CSS.
10. The method of claim 8 , wherein the input from the user includes one or more of mouse input, keyboard input, and touchscreen input.
A system and method for processing user input in a computing environment involves capturing and interpreting various types of user input to control a device or application. The method includes detecting input signals from one or more input devices, such as a mouse, keyboard, or touchscreen, and translating these signals into commands or actions within a software application or operating system. The system may analyze the input to determine the user's intent, such as selecting an object, navigating a user interface, or executing a function. The method may also involve filtering or modifying the input based on predefined rules or user preferences to enhance accuracy or efficiency. Additionally, the system may support multi-modal input, allowing combinations of different input types to perform complex operations. The method ensures compatibility with various input devices and adapts to different user interaction patterns, improving usability and responsiveness in computing systems.
11. One or more non-transitory computer-readable media comprising one or more computer-readable instructions that, when executed by one or more processors of a remote network device or of a local network device, cause the remote network device or the local network device to perform a method for webpage rendering using a remotely generated layout node tree, the method comprising: (a) generating, at the remote network device, a layout tree based on webpage data received from a webserver, the webpage data received from the webserver including malicious executable content resulting in the layout tree including the malicious executable content; (b) translating, at the remote network device, the layout tree into a layout node tree by traversing each object in the layout tree, translating traversed markup language objects into markup language nodes and traversed style sheet objects into style sheet nodes, and adding the translated markup language nodes and the translated style sheet nodes to the layout node tree, the translating of the layout tree into the layout node tree resulting in the malicious executable content being excluded from the layout node tree; (c) serializing, at the remote network device, the layout node tree; (d) sending, from the remote network device, the serialized layout node tree to the local network device over a network; (e) receiving, at the local network device, the serialized layout node tree; (f) deserializing, at the local network device, the serialized layout node tree to obtain the layout node tree; (g) constructing, at the local network device, a webpage using the layout node tree; and (h) rendering, at the local network device, the webpage in a browser, the webpage being rendered to appear as if the webpage were rendered on the remote network device using the layout tree.
This invention relates to secure webpage rendering by separating the generation of a layout node tree from the local device's rendering process. The problem addressed is the risk of executing malicious executable content embedded in webpage data, which can compromise local devices during rendering. The solution involves a remote network device processing the webpage data to generate a layout tree, which includes potentially harmful executable content. The remote device then translates this layout tree into a layout node tree by converting markup language objects (e.g., HTML) and style sheet objects (e.g., CSS) into corresponding nodes, while excluding the malicious executable content. This layout node tree is serialized and transmitted to a local network device over a network. The local device deserializes the layout node tree, constructs the webpage using it, and renders the webpage in a browser. The rendered webpage appears identical to how it would have appeared if rendered directly on the remote device using the original layout tree, but without exposing the local device to the malicious content. This approach enhances security by isolating the processing of untrusted webpage data to a remote system, reducing the risk of local device compromise.
12. The one or more non-transitory computer-readable media of claim 11 , wherein: the markup language objects are Hypertext Markup Language (HTML) objects; the markup language nodes are HTML nodes; the style sheet objects are Cascading Style Sheet (CSS) objects; and the style sheet nodes are CSS nodes.
This invention relates to a system for processing and analyzing markup language and style sheet objects in web development. The technology addresses the challenge of efficiently managing and transforming markup language and style sheet objects to ensure consistent rendering and styling across different web browsers and devices. The system involves parsing markup language documents to identify markup language objects, which are then processed to extract markup language nodes. Similarly, style sheet documents are parsed to identify style sheet objects, which are then processed to extract style sheet nodes. These nodes are used to analyze and modify the structure and presentation of web content. The invention specifies that the markup language objects are Hypertext Markup Language (HTML) objects, the markup language nodes are HTML nodes, the style sheet objects are Cascading Style Sheet (CSS) objects, and the style sheet nodes are CSS nodes. This ensures compatibility with widely used web technologies. The system enables developers to dynamically adjust the rendering of web pages by manipulating these nodes, improving cross-browser consistency and reducing development time. The invention also supports the extraction and transformation of node attributes, enhancing the flexibility of web content management.
13. The one or more non-transitory computer-readable media of claim 12 , wherein the translating at (b) further includes omitting, from the layout tree, any traversed object that is not an HTML object or a CSS object.
This invention relates to web page rendering and optimization, specifically improving the efficiency of layout calculations by selectively processing only relevant objects in a layout tree. The problem addressed is the computational overhead in rendering web pages, where unnecessary objects in the layout tree consume processing resources without contributing to the final layout. The solution involves a method for translating a layout tree into a more efficient structure by filtering out non-HTML and non-CSS objects during traversal. This ensures that only objects directly relevant to the web page's layout (HTML elements and CSS styles) are processed, reducing unnecessary computations and improving rendering performance. The method operates by traversing the layout tree and systematically removing any objects that are not HTML or CSS, thereby streamlining the layout process. This approach is particularly useful in environments where rendering speed is critical, such as mobile devices or high-performance web applications. The invention enhances the efficiency of web rendering engines by minimizing the number of objects processed during layout calculations, leading to faster page load times and reduced resource consumption.
14. The one or more non-transitory computer-readable media of claim 13 , wherein the translating at (b) further includes, for each omitted object, connecting any descendant object of the omitted object in the layout tree to any ancestor object of the omitted object in the layout tree.
This invention relates to computer systems that process and render layout trees, particularly in the context of web browsers or document rendering engines. The problem addressed is the efficient handling of layout trees when certain objects (nodes) are omitted or removed, ensuring that the remaining structure remains logically and hierarchically intact. When an object is omitted from a layout tree, its descendant objects (child nodes) must still maintain a valid connection to the rest of the tree. The invention provides a method to automatically reconnect descendant objects of an omitted object to any ancestor objects of the omitted object, preserving the hierarchical relationships and ensuring proper rendering. This approach avoids structural breaks in the layout tree, which could otherwise lead to rendering errors or incorrect document display. The solution is particularly useful in dynamic environments where layout trees are frequently modified, such as during web page rendering or document processing. By maintaining valid connections between nodes, the system ensures that the visual representation of the document remains accurate and consistent, even when parts of the layout tree are dynamically altered. The method operates by traversing the layout tree, identifying omitted objects, and establishing direct connections between their descendants and ancestors, thereby preserving the integrity of the tree structure.
15. The one or more non-transitory computer-readable media of claim 12 , wherein the translating at (b) of each traversed HTML object into an HTML node includes computing the CSS for the HTML object and adding the computed CSS to the HTML node.
This invention relates to web page rendering and addresses the challenge of efficiently processing HTML objects during page traversal. The system involves a method for converting HTML objects into a structured format, specifically HTML nodes, while incorporating computed Cascading Style Sheets (CSS) properties. The process begins by traversing a web page to identify HTML objects, such as elements, attributes, or embedded content. Each traversed HTML object is then translated into an HTML node, which includes computing the CSS styles applicable to that object and integrating the computed CSS into the resulting HTML node. This ensures that the rendered output accurately reflects the intended styling. The method may also involve generating a document object model (DOM) tree from the HTML nodes, where the DOM tree represents the hierarchical structure of the web page. The computed CSS is dynamically applied to the HTML nodes, allowing for real-time styling adjustments during rendering. This approach improves rendering efficiency by precomputing and embedding CSS properties, reducing the need for repeated style calculations during page display. The invention is particularly useful in web browsers or rendering engines where performance and accuracy in styling are critical.
16. The one or more non-transitory computer-readable media of claim 11 , wherein the generating at (a) is performed in response to the browser, at the local network device, requesting access to the webserver.
A system and method for managing web server access in a network environment addresses the challenge of efficiently handling browser requests to web servers. The invention involves a local network device that monitors and processes browser requests before they reach the web server. When a browser on the local network device attempts to access the web server, the system generates a response based on predefined rules or policies. This response may include modifying the request, blocking it, or redirecting it to another resource. The system ensures secure and controlled access to the web server by intercepting and processing requests at the local network device level, reducing the load on the web server and enhancing security. The method includes detecting the browser request, applying access control policies, and generating an appropriate response without requiring direct interaction with the web server. This approach improves network efficiency and security by decentralizing access management and reducing unnecessary server traffic. The invention is particularly useful in environments where strict access control and performance optimization are critical.
17. The one or more non-transitory computer-readable media of claim 11 , wherein the webpage data received from the webserver includes one or more of Hypertext Markup Language (HTML) data, Cascading Style Sheet (CSS) data, Fonts data, script data, and Scalable Vector Graphics (SVG) data.
This invention relates to systems for processing webpage data received from a webserver. The technology addresses the challenge of efficiently handling and utilizing various types of webpage content, including Hypertext Markup Language (HTML) data, Cascading Style Sheet (CSS) data, Fonts data, script data, and Scalable Vector Graphics (SVG) data. The system is designed to receive and process this diverse set of webpage elements, ensuring proper rendering and functionality. The invention focuses on managing these different data types to optimize performance, compatibility, and user experience. By supporting multiple formats, the system enables seamless integration and display of webpage content, addressing the need for robust and flexible webpage data handling in modern web applications. The solution enhances the ability to process and utilize webpage data effectively, improving the overall efficiency and reliability of web-based systems.
18. The one or more non-transitory computer-readable media of claim 11 , wherein the method further comprises: (i) detecting, at the local network device, input from a user entered into the webpage rendered in the browser; (j) sending, from the local network device to the remote network device, the input; (k) sending, from the remote network device to the webserver, the input; (l) receiving, at the remote network device, updated webpage data from the webserver; and (m) repeating (a) through (h) based on the updated webpage data received from the web server.
This invention relates to a system for dynamically updating web content in a browser without requiring a full page reload. The problem addressed is the inefficiency of traditional web browsing, where user interactions often trigger full page reloads, leading to delays and wasted bandwidth. The system involves a local network device, such as a user's computer or mobile device, running a browser to render a webpage. A remote network device acts as an intermediary between the local device and a webserver. When a user interacts with the webpage—such as clicking a button or entering text—the local device detects the input and sends it to the remote device. The remote device then forwards this input to the webserver, which processes the request and returns updated webpage data. The remote device receives this updated data and triggers a re-rendering of the webpage on the local device's browser, reflecting the changes without a full page reload. This process repeats iteratively as the user continues to interact with the webpage, ensuring seamless and efficient updates. The system optimizes performance by minimizing unnecessary data transfers and reducing latency in dynamic web applications.
19. The one or more non-transitory computer-readable media of claim 18 , wherein: the repeating of (b) is performed by only translating markup language objects and style sheet objects that were not previously translated; and the constructing at (g) includes reusing markup language nodes and style sheet nodes that were previously translated at (b) and previously deserialized at (f).
This invention relates to optimizing the translation and deserialization of markup language and style sheet objects in a computing system. The problem addressed is the inefficiency in processing such objects, particularly when repeated operations are performed, leading to redundant computations and memory usage. The invention involves a method for translating and deserializing markup language and style sheet objects. The process begins by receiving a serialized representation of these objects. The method then translates the markup language and style sheet objects into a structured format, such as a document object model (DOM) or a cascading style sheets object model (CSSOM). This translation step is optimized by only translating objects that were not previously translated, avoiding redundant work. The translated objects are then deserialized into a runtime representation, such as a DOM tree or CSSOM tree, which can be used by a browser or other application. When constructing the runtime representation, the method reuses previously translated and deserialized markup language and style sheet nodes, further improving efficiency. This reuse prevents unnecessary reprocessing of the same objects, reducing computational overhead and memory consumption. The method ensures that only new or modified objects are processed, while previously processed objects are retrieved from a cache or similar storage mechanism. This approach is particularly useful in web browsers and other applications that frequently parse and render markup and style sheet data, such as during dynamic content updates or page navigation. By minimizing redundant operations, the invention enhances performance and resource utilization.
20. The one or more non-transitory computer-readable media of claim 18 , wherein the input from the user includes one or more of mouse input, keyboard input, and touchscreen input.
This invention relates to a system for processing user input in a computing environment. The system addresses the challenge of accurately interpreting and responding to various types of user input, such as mouse, keyboard, and touchscreen interactions, to enhance user experience and system responsiveness. The system includes one or more non-transitory computer-readable media storing instructions that, when executed by a processor, cause the system to receive input from a user through multiple input devices, including a mouse, keyboard, or touchscreen. The system processes this input to determine the user's intended actions, such as selecting, navigating, or entering data, and executes corresponding operations in response. The system may also include a display device to provide visual feedback to the user, ensuring that the system's actions align with the user's input. By supporting multiple input methods, the system improves accessibility and flexibility, allowing users to interact with the computing environment in a manner that suits their preferences or physical capabilities. The system may further include additional components, such as a processor and memory, to facilitate the execution of these operations. The invention aims to provide a robust and adaptable input processing mechanism that enhances the efficiency and usability of computing devices.
Unknown
May 26, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.