Cross-domain linking of data types

• US 8,103,740 B1
• Filed: 05/13/2009
• Issued: 01/24/2012
• Est. Priority Date: 05/13/2009
• Status: Expired due to Fees

• Current Assignee: Google LLC (Alphabet Inc.)
• Original Assignee: Google Inc. (Alphabet Inc.)
• Inventors: Appleton, Benjamin Charles, Abramov, Dmitri, Jones, Michael Greystock
• Primary Examiner(s): Bates, Kevin
• Application Number:
  US12/465,524
• Time in Patent Office: 986 Days
• Field of Search: 709/203, 709/217, 719/328, 719/329
• US Class Current: 709/217
• CPC Class Codes: G06F 9/44521 Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading

Abstract

In one implementation, a computer-implemented method can include receiving, at a first server corresponding to a first domain, a request from a client computer for a vector graphics file that includes instructions that implement a first method. The method can further include sending the vector graphics file to the client computer, the client computer having received a library file from a second server corresponding to a second domain, wherein the library file includes instructions that implement a second method to direct calls to the first method, and wherein executing the vector graphics file and the library file causes the client computer to perform operations. The operations performed by the client computer can include establishing a link between the first method and the second method and directing a call made to the second method with an argument associated with a data type, to the first method using the established link.

Claims

1. A computer-implemented method comprising:

receiving, at a first server corresponding to a first domain, a request from a client computer for a library file that includes instructions that implement a implementation method that is associated with a first unique identifier; and

sending the library file to the client computer, the client computer having received an application file from a second server corresponding to a second domain, wherein the application file includes instructions that implement a stub method to direct calls to the implementation method, wherein the stub method is associated with a second unique identifier, and wherein executing the library file and the application file causes the client computer to perform operations comprising;

associating the implementation method with the first domain and the stub method with the second domain so that the implementation method is restricted to receiving an argument from the stub method as data without an associated data type;

establishing a link between the implementation method and the stub method using the first unique identifier and the second unique identifier;

receiving a call to the stub method made by code executed in association with the second domain, the call having an argument associated with a data type;

in response to receiving the call to the stub method, forwarding the call with the argument to the implementation method using the established link and passing the argument by reference, wherein the argument is received by the implementation method without the associated data type; and

processing the forwarded call with the argument that was passed by reference using the implementation method.

2. The method of claim 1, wherein a single vector graphics application on the client computer executes the library file and the application file, and performs the operations.

3. The method of claim 2, wherein the single vector graphics application synchronously processes the implementation method and the stub method such that the single vector graphics application returns to the stub method after processing the directed call using the implementation method.

4. The method of claim 1, wherein the implementation method is part of a first object that is defined in the library file and wherein the stub method is part of a second object that is defined in the application file, wherein the link between the implementation method and the stub method is between the first object and the second object, and wherein executing the library file and the application file causes the client computer to perform operations further comprising:

instantiating the first object as being associated with the first domain and instantiating the second object as being associated with the second domain, wherein the first object corresponds to the second object such that the second object refers to the first object for a full implementation.

5. The method of claim 4, wherein the first object further contains data and wherein the instructions of the implementation method provide access to the data, and the call made to the stub method seeks access to the data.

6. The method of claim 4, wherein the first object is associated with a data type and the second object is associated with the same data type as defined within the first domain and the second domain, respectively.

7. The method of claim 4, wherein the argument comprises a reference to an instantiated third object associated with the second domain, and wherein the third object is defined in the application file and corresponds to a fourth object defined in the library file.

8. The method of claim 7, wherein executing the library file and the application file causes the client computer to perform operations further comprising:

resolving the argument to be an instantiation of the fourth object associated with the first domain and processing the directed call with the instantiated fourth object using the implementation method.

9. The method of claim 7, wherein executing the library file and the application file causes the client computer to perform operations further comprising:

instantiating the fourth object as being associated with the first domain and processing the directed call with the instantiated fourth object using the implementation method.

10. The method of claim 1, wherein executing the library file and the application file causes the client computer to perform operations further comprising:

instantiating a first object as being associated with the first domain, as part of processing the directed call using the implementation method, the first object being defined in the library file and containing at least a third method having instructions for processing the third method;

in response to instantiating the first object, instantiating a second object as being associated with the second domain, the second object corresponding to the first object and containing at least a fourth method having instructions to direct calls to the third method.

11. The method of claim 1, wherein the call made to the stub method comprises a notification that an event associated with the second domain has occurred and the argument comprises information related to the event, wherein the stub method is designated as a handler for the event and the instructions of the implementation method process the event.

12. The method of claim 11, wherein the stub method overrides a predefined handler for the event.

13. The method of claim 1, further comprising:

sending by the first server hosted a scripting language file to the second server, the scripting language file defining the stub method, wherein the second server creates the application file by compiling the scripting language file.

14. A computer-implemented method comprising:

receiving at a first server corresponding to a first domain a request from a client computer for a library file that includes instructions that implement a implementation method that is associated with a first unique identifier; and

sending the library file to the client computer, the client computer having received an application file from a second server corresponding to a second domain, wherein the application file includes instructions that implement a stub method to direct calls to the implementation method, wherein the application file further includes an inherited method that inherits the implementation method and that includes instructions that modify at least a portion of the implementation method, wherein the stub method is associated with a second unique identifier, and wherein executing the library file and the application file causes the client computer to perform operations comprising;

associating the implementation method with the first domain and the stub method with the second domain so that the implementation method is restricted to receiving an argument from the stub method as data without an associated data type;

establishing a first link between the implementation method and the stub method using the first unique identifier and the second unique identifier, wherein the first link is used to forward calls made by code executed in association with the second domain from the stub method to the implementation method;

defining a stub of the inherited method to correspond to the inherited method, wherein the defined stub of the inherited method includes instructions to forward calls to the inherited method and is associated with the first domain, and wherein the inherited method is associated with the second domain such that the inherited method is restricted to receiving an argument from the stub of the inherited method as data without an associated data type; and

establishing a second link between the stub of the inherited method and the inherited method, wherein the second link is used to forward calls made by code executed in association with the first domain from the stub of the inherited method to the inherited method.

15. The method of claim 14, wherein executing the library file and the application file causes the client computer to perform operations further comprising:

directing a call made to the stub of the inherited method with an argument associated with a data type to the inherited method using the established second link, wherein the argument is received by the inherited method without the associated data type;

processing the directed call with the argument using the inherited method, wherein the inherited method is configured to treat the received argument as the associated data type, the inherited method invoking the stub method to process the directed call;

directing the call from the stub method to the implementation method using the established first link, wherein the argument is received by the implementation method without the associated data type; and

processing the directed call with the argument using the implementation method, wherein the implementation method is configured to treat the received argument as the associated data type.

16. A computer-implemented method comprising:

receiving at a client computer a vector graphics file from a third-party server;

receiving at the client computer a library file from a library server corresponding to a first internet domain, wherein the library file includes instructions that implement a implementation method that is associated with a first identifier, wherein the third-party server corresponds to a second internet domain, wherein the vector graphics file includes instructions that implement a stub method to direct calls to the implementation method, and wherein the stub method is associated with a second identifier;

associating the implementation method with the first domain and the stub method with the second domain so that the implementation method is restricted to receiving an argument from the stub method as data that does not have an associated data type;

establishing a link between the implementation method and the stub method using the first identifier and the second identifier;

receiving a call to the stub method made by code executed in association with the second domain, the call having an argument associated with a data type;

in response to receiving the call, forwarding the call with the argument to the implementation method using the established link and passing the argument by reference without change to the argument, wherein the argument is received by the implementation method without the associated data type; and

processing the forwarded call with the argument that was passed by reference using the implementation method, wherein the implementation method is configured to treat the received argument as the associated data type.

17. The method of claim 16, wherein the implementation method is part of a first object that is defined in the vector graphics file and wherein the stub method is part of a second object that is defined in the library file, the method further comprising:

instantiating the first object as being associated with the first domain and instantiating the second object as being associated with the second domain, wherein the first object corresponds to the second object such that the second object is refers to the first object for a full implementation.

18. The method of claim 16, wherein the implementation method and the stub method are processed synchronously such that processing returns to the stub method after the directed call is processed using the implementation method.

19. A system for performing cross-domain linking of data types, the system comprising:

one or more servers corresponding to a first internet domain;

means for creating a library file that includes instructions that implement a implementation method that is associated with a first unique identifier and a development library file that includes instructions that implement a stub method to direct calls to the implementation method, wherein the implementation method is associated with a second unique identifier;

an interface to the one or more servers configured to receive a first request from a third-party server for the development library file to be compiled into a vector graphics file and configured to receive a second request from the client computer for the library file; and

a communication module to transmit the development library file to the third-party server and to transmit the library file to the client computer, wherein the development library file is configured to establish a link between the implementation method and the stub method so that a call with an argument made to the stub method is directed to the implementation method with the argument being passed by reference when the vector graphics file and the library file are executed by the application on the client computer.

20. The system of claim 19, further comprising:

one or more second servers representing the third-party server and corresponding to a second internet domain; and

a processing device representing the client computer that is capable of executing the application, and that is capable of executing the vector graphics file and the library file using the application.