From 0eac36cf9f1d447fb52adabbb0f2f79c02bc466b Mon Sep 17 00:00:00 2001 From: Jonathan Kew Date: Tue, 11 Feb 2014 15:28:21 +0000 Subject: [PATCH 1/6] bug 970891 - don't assume the primary font will always support the character - fall back down the font stack if necessary. r=roc --- gfx/thebes/gfxFont.cpp | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/gfx/thebes/gfxFont.cpp b/gfx/thebes/gfxFont.cpp index 724e08bdff64..6b7ecb9f3add 100644 --- a/gfx/thebes/gfxFont.cpp +++ b/gfx/thebes/gfxFont.cpp @@ -4580,7 +4580,20 @@ gfxFontGroup::MakeSpaceTextRun(const Parameters *aParams, uint32_t aFlags) textRun->AddGlyphRun(font, gfxTextRange::kFontGroup, 0, false); } else { - textRun->SetSpaceGlyph(font, aParams->mContext, 0); + if (font->GetSpaceGlyph()) { + // Normally, the font has a cached space glyph, so we can avoid + // the cost of calling FindFontForChar. + textRun->SetSpaceGlyph(font, aParams->mContext, 0); + } else { + // In case the primary font doesn't have (bug 970891), + // find one that does. + uint8_t matchType; + nsRefPtr spaceFont = + FindFontForChar(' ', 0, MOZ_SCRIPT_LATIN, nullptr, &matchType); + if (spaceFont) { + textRun->SetSpaceGlyph(spaceFont, aParams->mContext, 0); + } + } } // Note that the gfxGlyphExtents glyph bounds storage for the font will From 9c7af361c664ae82ffaf0aba1ee27dea270eb6d1 Mon Sep 17 00:00:00 2001 From: Jonathan Kew Date: Tue, 11 Feb 2014 22:17:25 +0000 Subject: [PATCH 2/6] bug 970891 - reftest for font fallback on the character. r=roc --- layout/reftests/text/reftest.list | 3 +++ layout/reftests/text/space-font-1-ref.html | 26 ++++++++++++++++++++ layout/reftests/text/space-font-1.html | 28 ++++++++++++++++++++++ 3 files changed, 57 insertions(+) create mode 100644 layout/reftests/text/space-font-1-ref.html create mode 100644 layout/reftests/text/space-font-1.html diff --git a/layout/reftests/text/reftest.list b/layout/reftests/text/reftest.list index 395039a16326..343537b08c1e 100644 --- a/layout/reftests/text/reftest.list +++ b/layout/reftests/text/reftest.list @@ -295,3 +295,6 @@ pref(layout.css.text-align-true-value.enabled,true) == text-align-true.html text != control-chars-02.html control-chars-02-notref.html == control-chars-03a.html control-chars-03-ref.html == control-chars-03b.html control-chars-03-ref.html + +# font fallback for when not supported in the primary font family - bug 970891 +HTTP(..) == space-font-1.html space-font-1-ref.html diff --git a/layout/reftests/text/space-font-1-ref.html b/layout/reftests/text/space-font-1-ref.html new file mode 100644 index 000000000000..486ebf806073 --- /dev/null +++ b/layout/reftests/text/space-font-1-ref.html @@ -0,0 +1,26 @@ + + + + + Bug 970891 + + + + +
A A A A
+ + + diff --git a/layout/reftests/text/space-font-1.html b/layout/reftests/text/space-font-1.html new file mode 100644 index 000000000000..2648ca84f519 --- /dev/null +++ b/layout/reftests/text/space-font-1.html @@ -0,0 +1,28 @@ + + + + + Bug 970891 + + + + + +
A A A A 
+ + + From e48f244deace41fcd4b77166027d570dab7cecf1 Mon Sep 17 00:00:00 2001 From: Jim Blandy Date: Fri, 7 Mar 2014 11:50:41 -0800 Subject: [PATCH 3/6] Bug 969273: Move JSPrincipals-related types and functions to their own header. r=mrbkap JSSubsumesOp seems to have gotten dragged into Class.h somehow, but it's not a metaobject protocol type at all. It belongs with JSSecurityCallbacks and friends, which together form a chunk that could be neatly abstracted. --- js/public/Class.h | 6 --- js/public/Principals.h | 100 +++++++++++++++++++++++++++++++++++++++++ js/src/jsapi.h | 87 +---------------------------------- js/src/moz.build | 1 + 4 files changed, 102 insertions(+), 92 deletions(-) create mode 100644 js/public/Principals.h diff --git a/js/public/Class.h b/js/public/Class.h index a665c3b881c5..04815f8137d9 100644 --- a/js/public/Class.h +++ b/js/public/Class.h @@ -265,12 +265,6 @@ struct JSStringFinalizer { void (*finalize)(const JSStringFinalizer *fin, jschar *chars); }; -// Return whether the first principal subsumes the second. The exact meaning of -// 'subsumes' is left up to the browser. Subsumption is checked inside the JS -// engine when determining, e.g., which stack frames to display in a backtrace. -typedef bool -(* JSSubsumesOp)(JSPrincipals *first, JSPrincipals *second); - // Check whether v is an instance of obj. Return false on error or exception, // true on success with true in *bp if v is an instance of obj, false in // *bp otherwise. diff --git a/js/public/Principals.h b/js/public/Principals.h new file mode 100644 index 000000000000..78d8c7e89310 --- /dev/null +++ b/js/public/Principals.h @@ -0,0 +1,100 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * vim: set ts=8 sts=4 et sw=4 tw=99: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* JSPrincipals and related interfaces. */ + +#ifndef js_Principals_h +#define js_Principals_h + +#include "mozilla/Atomics.h" + +#include + +#include "jspubtd.h" + +struct JSPrincipals { + /* Don't call "destroy"; use reference counting macros below. */ +#ifdef JS_THREADSAFE + mozilla::Atomic refcount; +#else + int32_t refcount; +#endif + +#ifdef JS_DEBUG + /* A helper to facilitate principals debugging. */ + uint32_t debugToken; +#endif + + void setDebugToken(uint32_t token) { +# ifdef JS_DEBUG + debugToken = token; +# endif + } + + /* + * This is not defined by the JS engine but should be provided by the + * embedding. + */ + JS_PUBLIC_API(void) dump(); +}; + +extern JS_PUBLIC_API(void) +JS_HoldPrincipals(JSPrincipals *principals); + +extern JS_PUBLIC_API(void) +JS_DropPrincipals(JSRuntime *rt, JSPrincipals *principals); + +// Return whether the first principal subsumes the second. The exact meaning of +// 'subsumes' is left up to the browser. Subsumption is checked inside the JS +// engine when determining, e.g., which stack frames to display in a backtrace. +typedef bool +(* JSSubsumesOp)(JSPrincipals *first, JSPrincipals *second); + +/* + * Used to check if a CSP instance wants to disable eval() and friends. + * See js_CheckCSPPermitsJSAction() in jsobj. + */ +typedef bool +(* JSCSPEvalChecker)(JSContext *cx); + +struct JSSecurityCallbacks { + JSCSPEvalChecker contentSecurityPolicyAllows; + JSSubsumesOp subsumes; +}; + +extern JS_PUBLIC_API(void) +JS_SetSecurityCallbacks(JSRuntime *rt, const JSSecurityCallbacks *callbacks); + +extern JS_PUBLIC_API(const JSSecurityCallbacks *) +JS_GetSecurityCallbacks(JSRuntime *rt); + +/* + * Code running with "trusted" principals will be given a deeper stack + * allocation than ordinary scripts. This allows trusted script to run after + * untrusted script has exhausted the stack. This function sets the + * runtime-wide trusted principal. + * + * This principals is not held (via JS_HoldPrincipals/JS_DropPrincipals) since + * there is no available JSContext. Instead, the caller must ensure that the + * given principals stays valid for as long as 'rt' may point to it. If the + * principals would be destroyed before 'rt', JS_SetTrustedPrincipals must be + * called again, passing nullptr for 'prin'. + */ +extern JS_PUBLIC_API(void) +JS_SetTrustedPrincipals(JSRuntime *rt, const JSPrincipals *prin); + +typedef void +(* JSDestroyPrincipalsOp)(JSPrincipals *principals); + +/* + * Initialize the callback that is called to destroy JSPrincipals instance + * when its reference counter drops to zero. The initialization can be done + * only once per JS runtime. + */ +extern JS_PUBLIC_API(void) +JS_InitDestroyPrincipalsCallback(JSRuntime *rt, JSDestroyPrincipalsOp destroyPrincipals); + +#endif /* js_Principals_h */ diff --git a/js/src/jsapi.h b/js/src/jsapi.h index 26a5f49ba0ef..0fe51abbc415 100644 --- a/js/src/jsapi.h +++ b/js/src/jsapi.h @@ -9,7 +9,6 @@ #ifndef jsapi_h #define jsapi_h -#include "mozilla/Atomics.h" #include "mozilla/FloatingPoint.h" #include "mozilla/MemoryReporting.h" #include "mozilla/RangedPtr.h" @@ -26,6 +25,7 @@ #include "js/Class.h" #include "js/HashTable.h" #include "js/Id.h" +#include "js/Principals.h" #include "js/RootingAPI.h" #include "js/Utility.h" #include "js/Value.h" @@ -779,20 +779,6 @@ typedef bool typedef bool (* JSLocaleToUnicode)(JSContext *cx, const char *src, JS::MutableHandleValue rval); -/* - * Security protocol types. - */ - -typedef void -(* JSDestroyPrincipalsOp)(JSPrincipals *principals); - -/* - * Used to check if a CSP instance wants to disable eval() and friends. - * See js_CheckCSPPermitsJSAction() in jsobj. - */ -typedef bool -(* JSCSPEvalChecker)(JSContext *cx); - /* * Callback used to ask the embedding for the cross compartment wrapper handler * that implements the desired prolicy for this kind of object in the @@ -3202,77 +3188,6 @@ JS_SetReservedSlot(JSObject *obj, uint32_t index, jsval v); /************************************************************************/ -/* - * Security protocol. - */ -struct JSPrincipals { - /* Don't call "destroy"; use reference counting macros below. */ -#ifdef JS_THREADSAFE - mozilla::Atomic refcount; -#else - int32_t refcount; -#endif - -#ifdef JS_DEBUG - /* A helper to facilitate principals debugging. */ - uint32_t debugToken; -#endif - - void setDebugToken(uint32_t token) { -# ifdef JS_DEBUG - debugToken = token; -# endif - } - - /* - * This is not defined by the JS engine but should be provided by the - * embedding. - */ - JS_PUBLIC_API(void) dump(); -}; - -extern JS_PUBLIC_API(void) -JS_HoldPrincipals(JSPrincipals *principals); - -extern JS_PUBLIC_API(void) -JS_DropPrincipals(JSRuntime *rt, JSPrincipals *principals); - -struct JSSecurityCallbacks { - JSCSPEvalChecker contentSecurityPolicyAllows; - JSSubsumesOp subsumes; -}; - -extern JS_PUBLIC_API(void) -JS_SetSecurityCallbacks(JSRuntime *rt, const JSSecurityCallbacks *callbacks); - -extern JS_PUBLIC_API(const JSSecurityCallbacks *) -JS_GetSecurityCallbacks(JSRuntime *rt); - -/* - * Code running with "trusted" principals will be given a deeper stack - * allocation than ordinary scripts. This allows trusted script to run after - * untrusted script has exhausted the stack. This function sets the - * runtime-wide trusted principal. - * - * This principals is not held (via JS_HoldPrincipals/JS_DropPrincipals) since - * there is no available JSContext. Instead, the caller must ensure that the - * given principals stays valid for as long as 'rt' may point to it. If the - * principals would be destroyed before 'rt', JS_SetTrustedPrincipals must be - * called again, passing nullptr for 'prin'. - */ -extern JS_PUBLIC_API(void) -JS_SetTrustedPrincipals(JSRuntime *rt, const JSPrincipals *prin); - -/* - * Initialize the callback that is called to destroy JSPrincipals instance - * when its reference counter drops to zero. The initialization can be done - * only once per JS runtime. - */ -extern JS_PUBLIC_API(void) -JS_InitDestroyPrincipalsCallback(JSRuntime *rt, JSDestroyPrincipalsOp destroyPrincipals); - -/************************************************************************/ - /* * Functions and scripts. */ diff --git a/js/src/moz.build b/js/src/moz.build index 450c80180427..5561034f49e5 100644 --- a/js/src/moz.build +++ b/js/src/moz.build @@ -77,6 +77,7 @@ EXPORTS.js += [ '../public/LegacyIntTypes.h', '../public/MemoryMetrics.h', '../public/OldDebugAPI.h', + '../public/Principals.h', '../public/ProfilingStack.h', '../public/PropertyKey.h', '../public/RequiredDefines.h', From 197fb75c84710187fdea6c5a2e1bcfb61a8f2ad7 Mon Sep 17 00:00:00 2001 From: Jim Blandy Date: Fri, 7 Mar 2014 11:50:41 -0800 Subject: [PATCH 4/6] Bug 969273: Implement a toy principal type for the JS shell, for testing. r=mrbkap r=waldo --- .../jit-test/tests/basic/shell-principals.js | 52 ++++++++++ js/src/shell/js.cpp | 99 ++++++++++++++++--- 2 files changed, 140 insertions(+), 11 deletions(-) create mode 100644 js/src/jit-test/tests/basic/shell-principals.js diff --git a/js/src/jit-test/tests/basic/shell-principals.js b/js/src/jit-test/tests/basic/shell-principals.js new file mode 100644 index 000000000000..2a97914846d4 --- /dev/null +++ b/js/src/jit-test/tests/basic/shell-principals.js @@ -0,0 +1,52 @@ +// Test the JS shell's toy principals. + +var count = 0; + +// Given a string of letters |expected|, say "abc", assert that the stack +// contains calls to a series of functions named by the next letter from +// the string, say a, b, and then c. Younger frames appear earlier in +// |expected| than older frames. +function check(expected, stack) { + print("check(" + uneval(expected) + ") against:\n" + stack); + count++; + + // Extract only the function names from the stack trace. Omit the frames + // for the top-level evaluation, if it is present. + var split = stack.split(/(.)?@.*\n/).slice(0, -1); + if (split[split.length - 1] === undefined) + split = split.slice(0, -2); + + // Check the function names against the expected sequence. + assertEq(split.length, expected.length * 2); + for (var i = 0; i < expected.length; i++) + assertEq(split[i * 2 + 1], expected[i]); +} + +var low = newGlobal({ principal: 0 }); +var mid = newGlobal({ principal: 0xffff }); +var high = newGlobal({ principal: 0xfffff }); + + eval('function a() { check("a", Error().stack); b(); }'); +low .eval('function b() { check("b", Error().stack); c(); }'); +mid .eval('function c() { check("cba", Error().stack); d(); }'); +high.eval('function d() { check("dcba", Error().stack); e(); }'); + eval('function e() { check("edcba", Error().stack); f(); }'); // no principal, so checks skipped +low .eval('function f() { check("fb", Error().stack); g(); }'); +mid .eval('function g() { check("gfecba", Error().stack); h(); }'); +high.eval('function h() { check("hgfedcba", Error().stack); }'); + +// Make everyone's functions visible to each other, as needed. + b = low .b; +low .c = mid .c; +mid .d = high.d; +high.e = e; + f = low .f; +low .g = mid .g; +mid .h = high.h; + +low.check = mid.check = high.check = check; + +// Kick the whole process off. +a(); + +assertEq(count, 8); diff --git a/js/src/shell/js.cpp b/js/src/shell/js.cpp index 03a1c975729c..e6d686af68a9 100644 --- a/js/src/shell/js.cpp +++ b/js/src/shell/js.cpp @@ -190,11 +190,65 @@ static void DestroyContext(JSContext *cx, bool withGC); static JSObject * -NewGlobalObject(JSContext *cx, JS::CompartmentOptions &options); +NewGlobalObject(JSContext *cx, JS::CompartmentOptions &options, + JSPrincipals *principals); static const JSErrorFormatString * my_GetErrorMessage(void *userRef, const char *locale, const unsigned errorNumber); + +/* + * A toy principals type for the shell. + * + * In the shell, a principal is simply a 32-bit mask: P subsumes Q if the + * set bits in P are a superset of those in Q. Thus, the principal 0 is + * subsumed by everything, and the principal ~0 subsumes everything. + * + * As a special case, a null pointer as a principal is treated like 0xffff. + * + * The 'newGlobal' function takes an option indicating which principal the + * new global should have; 'evaluate' does for the new code. + */ +class ShellPrincipals: public JSPrincipals { + uint32_t bits; + + static uint32_t getBits(JSPrincipals *p) { + if (!p) + return 0xffff; + return static_cast(p)->bits; + } + + public: + ShellPrincipals(uint32_t bits, int32_t refcount = 0) : bits(bits) { + this->refcount = refcount; + } + + static void destroy(JSPrincipals *principals) { + MOZ_ASSERT(principals != &fullyTrusted); + MOZ_ASSERT(principals->refcount == 0); + js_free(static_cast(principals)); + } + + static bool subsumes(JSPrincipals *first, JSPrincipals *second) { + uint32_t firstBits = getBits(first); + uint32_t secondBits = getBits(second); + return (firstBits | secondBits) == firstBits; + } + + static JSSecurityCallbacks securityCallbacks; + + // Fully-trusted principals singleton. + static ShellPrincipals fullyTrusted; +}; + +JSSecurityCallbacks ShellPrincipals::securityCallbacks = { + nullptr, // contentSecurityPolicyAllows + subsumes +}; + +// The fully-trusted principal subsumes all other principals. +ShellPrincipals ShellPrincipals::fullyTrusted(-1, 1); + #ifdef EDITLINE extern "C" { extern JS_EXPORT_API(char *) readline(const char *prompt); @@ -2829,7 +2883,7 @@ WorkerMain(void *arg) JS::CompartmentOptions compartmentOptions; compartmentOptions.setVersion(JSVERSION_LATEST); - RootedObject global(cx, NewGlobalObject(cx, compartmentOptions)); + RootedObject global(cx, NewGlobalObject(cx, compartmentOptions, nullptr)); if (!global) break; @@ -4104,6 +4158,7 @@ WrapWithProto(JSContext *cx, unsigned argc, jsval *vp) static bool NewGlobal(JSContext *cx, unsigned argc, jsval *vp) { + JSPrincipals *principals = nullptr; JS::CompartmentOptions options; options.setVersion(JSVERSION_LATEST); @@ -4121,9 +4176,23 @@ NewGlobal(JSContext *cx, unsigned argc, jsval *vp) return false; if (v.isBoolean()) options.setInvisibleToDebugger(v.toBoolean()); + + if (!JS_GetProperty(cx, opts, "principal", &v)) + return false; + if (!v.isUndefined()) { + uint32_t bits; + if (!ToUint32(cx, v, &bits)) + return false; + principals = cx->new_(bits); + if (!principals) + return false; + JS_HoldPrincipals(principals); + } } - RootedObject global(cx, NewGlobalObject(cx, options)); + RootedObject global(cx, NewGlobalObject(cx, options, principals)); + if (principals) + JS_DropPrincipals(cx->runtime(), principals); if (!global) return false; @@ -4601,7 +4670,15 @@ static const JSFunctionSpecWithHelp shell_functions[] = { " Return a new global object in a new compartment. If options\n" " is given, it may have any of the following properties:\n" " sameZoneAs: the compartment will be in the same zone as the given object (defaults to a new zone)\n" -" invisibleToDebugger: the global will be invisible to the debugger (default false)"), +" invisibleToDebugger: the global will be invisible to the debugger (default false)\n" +" principal: if present, its value converted to a number must be an\n" +" integer that fits in 32 bits; use that as the new compartment's\n" +" principal. Shell principals are toys, meant only for testing; one\n" +" shell principal subsumes another if its set bits are a superset of\n" +" the other's. Thus, a principal of 0 subsumes nothing, while a\n" +" principals of ~0 subsumes all other principals. The absence of a\n" +" principal is treated as if its bits were 0xffff, for subsumption\n" +" purposes. If this property is omitted, supply no principal."), JS_FN_HELP("enableStackWalkingAssertion", EnableStackWalkingAssertion, 1, 0, "enableStackWalkingAssertion(enabled)", @@ -5520,9 +5597,10 @@ DestroyContext(JSContext *cx, bool withGC) } static JSObject * -NewGlobalObject(JSContext *cx, JS::CompartmentOptions &options) +NewGlobalObject(JSContext *cx, JS::CompartmentOptions &options, + JSPrincipals *principals) { - RootedObject glob(cx, JS_NewGlobalObject(cx, &global_class, nullptr, + RootedObject glob(cx, JS_NewGlobalObject(cx, &global_class, principals, JS::DontFireOnNewGlobalHook, options)); if (!glob) return nullptr; @@ -5849,7 +5927,7 @@ Shell(JSContext *cx, OptionParser *op, char **envp) RootedObject glob(cx); JS::CompartmentOptions options; options.setVersion(JSVERSION_LATEST); - glob = NewGlobalObject(cx, options); + glob = NewGlobalObject(cx, options, nullptr); if (!glob) return 1; @@ -6103,11 +6181,10 @@ main(int argc, char **argv, char **envp) if (availMem > 0) JS_SetGCParametersBasedOnAvailableMemory(rt, availMem); - /* Set the initial counter to 1 so the principal will never be destroyed. */ - JSPrincipals shellTrustedPrincipals; - shellTrustedPrincipals.refcount = 1; + JS_SetTrustedPrincipals(rt, &ShellPrincipals::fullyTrusted); + JS_SetSecurityCallbacks(rt, &ShellPrincipals::securityCallbacks); + JS_InitDestroyPrincipalsCallback(rt, ShellPrincipals::destroy); - JS_SetTrustedPrincipals(rt, &shellTrustedPrincipals); JS_SetOperationCallback(rt, ShellOperationCallback); JS::SetAsmJSCacheOps(rt, &asmJSCacheOps); From 1f49547ce9e83217c4fad1c801302a6fe348095e Mon Sep 17 00:00:00 2001 From: Benoit Girard Date: Fri, 7 Mar 2014 14:54:45 -0500 Subject: [PATCH 5/6] Bug 980183 - Add support for eclipse CDT 8.3. r=botond NPOTB --- python/mozbuild/mozbuild/backend/cpp_eclipse.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/python/mozbuild/mozbuild/backend/cpp_eclipse.py b/python/mozbuild/mozbuild/backend/cpp_eclipse.py index 3567112888f0..5e8451835cb5 100644 --- a/python/mozbuild/mozbuild/backend/cpp_eclipse.py +++ b/python/mozbuild/mozbuild/backend/cpp_eclipse.py @@ -253,9 +253,7 @@ CPROJECT_TEMPLATE_FOOTER = """ - - - + @@ -298,6 +296,10 @@ LANGUAGE_SETTINGS_TEMPLATE = """ + + + + @@ -325,7 +327,7 @@ LAUNCH_CONFIG_TEMPLATE = """ - + From 10d60c90dfde88c2e87c0219dcdd947239787a30 Mon Sep 17 00:00:00 2001 From: George Wright Date: Fri, 7 Mar 2014 17:11:57 -0500 Subject: [PATCH 6/6] Bug 921670 - Trivial fixup to generate_mozbuild.py to cater for SkFontHost_android_old DONTBUILD --- gfx/skia/generate_mozbuild.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/gfx/skia/generate_mozbuild.py b/gfx/skia/generate_mozbuild.py index 4762fdf3783f..7cd3434b4b4d 100755 --- a/gfx/skia/generate_mozbuild.py +++ b/gfx/skia/generate_mozbuild.py @@ -60,6 +60,9 @@ if CONFIG['MOZ_WIDGET_TOOLKIT'] in ('android', 'gtk2', 'gtk3', 'qt', 'gonk', 'co if CONFIG['INTEL_ARCHITECTURE'] and CONFIG['HAVE_TOOLCHAIN_SUPPORT_MSSSE3']: DEFINES['SK_BUILD_SSSE3'] = 1 +if CONFIG['MOZ_WIDGET_TOOLKIT'] in ('android', 'gonk'): + DEFINES['SK_FONTHOST_CAIRO_STANDALONE'] = 0 + if (CONFIG['MOZ_WIDGET_TOOLKIT'] == 'android') or \ (CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa') or \ (CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gonk') or \ @@ -181,6 +184,7 @@ def generate_separated_sources(platform_sources): }, 'android': { # 'trunk/src/ports/SkDebug_android.cpp', + 'trunk/src/ports/SkFontHost_android_old.cpp', 'trunk/src/ports/SkFontHost_cairo.cpp', # 'trunk/src/ports/SkFontHost_FreeType.cpp', # 'trunk/src/ports/SkFontHost_FreeType_common.cpp',