Sun Microsystems Inc. developed a software platform known as Java in 1996. The platform made it possible for the same software to be run on different operating systems and different devices. Programmers could write source code in the Java language. That source code could then be translated using the Java virtual machine into a machine code that different operating systems could understand. This facilitated programming. Programmers could write one set of source code in Java and it could run on many operating systems and devices.
Sun wrote programs to perform many basic functions. These programs were grouped into “packages” composing an application programming interface (“API”). Each API package contained two types of source code: the declaring code and the implementing code. The declaring code informed programmers what the functions were, and the implementing code performed those functions. Programmers could use these packages when they wanted to incorporate these basic functions into their own programs.
In 2005, Google began negotiating with Sun for a license to use the Java platform in Google’s Android mobile operating system. Sun insisted that Google make Android interoperable with other Java programs. Google did not agree, and negotiations fell apart. Ultimately, Google developed its own virtual machine and 168 API packages for the Android platform, which it launched in 2007. In order to facilitate Android use by Java application programmers, “Google copied 7,000 lines of declaring code and generally replicated the overall structure, sequence, and organization of Oracle's 37 Java API packages.” Notably, Google wrote almost all of its own implementing code, the actual program to be run; the copied declaring code was only used to call the program which should be run. Google also copied the nine-line rangeCheck function in its implementing code and copied eight decompiled security files that served as test files. Oracle acquired Sun in 2010 and later sued Google for copyright infringement.
At trial, a jury found infringement by Google with respect to the 37 API packages and the rangeCheck function. The jury found that Google did not infringe as to the eight decompiled security files. The jury’s decision was based on an instruction to “assume that the structure, sequence, and organization of the 37 API packages were copyrightable.”
[T]he court informed the jury that Google conceded that it copied the declaring code used in the 37 packages verbatim. The court also instructed the jury that Google conceded copying the rangeCheck function and the eight decompiled security files, but that Google maintained that its use of those lines of code was de minimis.
With regard to infringement of the eight security files, the district court granted Oracle’s motion for judgment as a matter of law. Google’s motion for judgment as a matter of law for the nine-line rangeCheck function as de minimis and not infringing was denied. Oracle’s motion for judgment as a matter of law over fair use was also denied.
The district court separately concluded that the 37 Java API packages were not copyrightable. First, the declaring code of the API packages was not copyrightable because the district court found “there was only one way to write the declaring code” and the declaring code, being short phrases, was categorically uncopyrightable. Second, the overall SSO was uncopyrightable because it was “a system or method of operation,” which is categorically uncopyrightable under 102(b) of the Copyright Act. Thus, according to the district court, Google was not liable for copying the 37 Java API packages, because the elements Google copied were not protected by copyright law. The district court held in favor of Oracle for the copying of the eight decompiled security files and the rangeCheck code, and entered an award of zero dollars as stipulated by the parties. Oracle appealed with respect to the 37 API packages, and Google cross appealed with respect to the eight decompiled security files and the rangeCheck code.
The Federal Circuit heard the appeal because the case included patent claims. On the copyright issues, it applied Ninth Circuit law.
The appellate court found that the district court erred in its copyrightability decision because it confused the “threshold question” of copyrightability with the infringement analysis and included interoperability considerations in the copyrightability analysis that should have fallen into the fair use analysis. The court concluded that the declaring code and the SSO of the 37 API packages were copyrightable and remanded for further proceedings on fair use.
At the beginning of its copyrightability discussion, the court quoted the copyrightability standard from Feist Publications, Inc., v. Rural Telephone Service Co., 499 U.S. 340 (1991): a work is original under 102(a) of the Copyright Act so long as it “was independently created by the author” and “possesses at least some minimal degree of creativity.” The court held that Section 102(b) of the Copyright Act, which codifies the idea/expression dichotomy laid out in Baker v. Selden, 101 U.S. 99 (1879), “‘in no way enlarges or contracts the scope of copyright protection’” and does not render uncopyrightable works that meet the Feist standard. In contrast, Google had argued that 102(b) serves as an additional requirement for copyrightability.
The court noted a circuit split over how to distinguish protectable and unprotectable components during the copyrightability and infringement analyses. The Ninth Circuit uses the Second Circuit’s “abstraction - filtration - comparison” test. The court observed that, based on the case law of Mitel, Inc. v. Iqtel, Inc., 124 F.3d 1366 (10th Cir. 1997), the “abstraction - filtration - comparison” test “rejects the notion that anything that performs a function is necessarily uncopyrightable.” At the other end of the spectrum, as noted in Computer Associates International, Inc. v. Altai, Inc., 982 F.2d 693 (2d Cir. 1992), the test rejects the flawed assumption that “once any separable idea can be identified in a computer program everything else must be protectable expression,” because a single work may contain more than one unprotectable idea.
Quoting the Second Circuit’s decision in Altai, the court laid out the three steps of the “abstraction - filtration - comparison” test. First, the court must “‘break down the allegedly infringed program into its constituent structural parts.’” Next, for filtration, the court “‘sift[s] out all non-protectable material,’ including ideas and ‘expression that is necessarily incidental to those ideas.’” Finally, in the words of this court, “the court compares the remaining creative expression with the allegedly infringing program.” The first step, abstraction, is part of the copyrightability analysis in all circuits, and the third is part of the infringement analysis. The role of the second step varies. In the Ninth Circuit, it is both a copyrightability question and an infringement question. Originality is a copyrightability question, whereas merger and scènes à faire are affirmative defenses and are thus part of the infringement analysis.
First, the court found that the merger doctrine did not apply because there were many ways to express the ideas in the packages, for instance by using different names for the methods or arranging them differently. In addition, the court noted that the merger analysis should focus “on the options available to Sun/Oracle at the time it created the API packages,” instead of the options available to Google when it infringed.
The court then found that the district court wrongly applied the “short phrase doctrine.” Although short phrases are generally not copyrightable, the court found that the short phrases in the declaring code were creative and the combination was original. The court analogized the 7,000 lines of declaring code to the first chapter of “A Tale of Two Cities.” As long as the short phrases were “used or strung together [in a creative way],” the work should be copyrightable.
The Federal Circuit found that the district court had correctly rejected arguments under a third doctrine, the scènes à faire doctrine. Like merger, scènes à faire is part of the infringement question. Thus, it was not a proper ground for affirming the district court’s copyrightability decision. In addition, Google failed to show that Sun’s decisions in creating the Java packages “were driven by external factors or premised on features that were either commonplace or essential to the idea being expressed.”
Next, the court considered the district court’s finding that the SSO of the Java packages was uncopyrightable as a “method of operation.” The court held that “an original work—even one that serves a function—is entitled to copyright protection as long as the author had multiple ways to express the underlying idea.” Oracle’s “particular way of naming and organizing each of the 37 Java API packages” was copyrightable.
The court further found that the district court should not have taken interoperability into consideration when deciding the copyrightability question. If considered at that stage, interoperability arguments should focus on Sun when it was writing the Java platform, and Google provided no evidence on that point. If Google wanted to raise the issue of interoperability with regard to Google trying to make the Android platform interoperable with Java platform, then that would be a fair use question, not a copyrightability one.
Ruling on Google’s cross appeal, the court affirmed Oracle’s motion for judgment as a matter of law with respect to Google’s copying of the eight decompiled security files. According to Oracle’s expert, the use of the security files was significant, and Google did not provide any testimony to the contrary; no reasonable jury could find in favor of Google. The court also affirmed the district court’s denial of Google’s motion for judgment as a matter of law with respect to the rangeCheck function. Trial testimony showed that rangeCheck was “qualitatively significant” and was copied in its entirety. Google’s motion for judgment as a matter of law was rightly denied.