diff --git a/core/java/android/widget/TextView.java b/core/java/android/widget/TextView.java
index 72bfc88fb9550..a6844e8b72a91 100644
--- a/core/java/android/widget/TextView.java
+++ b/core/java/android/widget/TextView.java
@@ -6761,6 +6761,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
                                  BoringLayout.Metrics boring,
                                  BoringLayout.Metrics hintBoring,
                                  int ellipsisWidth, boolean bringIntoView) {
+        android.util.Log.e("TextView", "makeNewLayout", new Exception());
         stopMarquee();
 
         // Update "old" cached values
diff --git a/core/jni/android/graphics/FontFamily.cpp b/core/jni/android/graphics/FontFamily.cpp
index 3ff75dc56e7ba..1232675525b46 100644
--- a/core/jni/android/graphics/FontFamily.cpp
+++ b/core/jni/android/graphics/FontFamily.cpp
@@ -41,21 +41,21 @@ namespace android {
 
 static jlong FontFamily_create(JNIEnv* env, jobject clazz, jstring lang, jint variant) {
     if (lang == NULL) {
-        return (jlong)new FontFamily(variant);
+        return (jlong)new minikin::FontFamily(variant);
     }
     ScopedUtfChars str(env, lang);
-    uint32_t langId = FontStyle::registerLanguageList(str.c_str());
-    return (jlong)new FontFamily(langId, variant);
+    uint32_t langId = minikin::FontStyle::registerLanguageList(str.c_str());
+    return (jlong)new minikin::FontFamily(langId, variant);
 }
 
 static void FontFamily_unref(JNIEnv* env, jobject clazz, jlong familyPtr) {
-    FontFamily* fontFamily = reinterpret_cast<FontFamily*>(familyPtr);
+    minikin::FontFamily* fontFamily = reinterpret_cast<minikin::FontFamily*>(familyPtr);
     fontFamily->Unref();
 }
 
-static jboolean addSkTypeface(FontFamily* family, SkTypeface* face, const void* fontData,
+static jboolean addSkTypeface(minikin::FontFamily* family, SkTypeface* face, const void* fontData,
         size_t fontSize, int ttcIndex) {
-    MinikinFont* minikinFont = new MinikinFontSkia(face, fontData, fontSize, ttcIndex);
+    minikin::MinikinFont* minikinFont = new MinikinFontSkia(face, fontData, fontSize, ttcIndex);
     bool result = family->addFont(minikinFont);
     minikinFont->Unref();
     return result;
@@ -111,7 +111,7 @@ static jboolean FontFamily_addFont(JNIEnv* env, jobject clazz, jlong familyPtr,
         ALOGE("addFont failed to create font");
         return false;
     }
-    FontFamily* fontFamily = reinterpret_cast<FontFamily*>(familyPtr);
+    minikin::FontFamily* fontFamily = reinterpret_cast<minikin::FontFamily*>(familyPtr);
     return addSkTypeface(fontFamily, face, fontPtr, (size_t)fontSize, ttcIndex);
 }
 
@@ -177,9 +177,10 @@ static jboolean FontFamily_addFontWeightStyle(JNIEnv* env, jobject clazz, jlong
         ALOGE("addFont failed to create font, invalid request");
         return false;
     }
-    FontFamily* fontFamily = reinterpret_cast<FontFamily*>(familyPtr);
-    MinikinFont* minikinFont = new MinikinFontSkia(face, fontPtr, (size_t)fontSize, ttcIndex);
-    fontFamily->addFont(minikinFont, FontStyle(weight / 100, isItalic));
+    minikin::FontFamily* fontFamily = reinterpret_cast<minikin::FontFamily*>(familyPtr);
+    minikin::MinikinFont* minikinFont =
+            new MinikinFontSkia(face, fontPtr, (size_t)fontSize, ttcIndex);
+    fontFamily->addFont(minikinFont, minikin::FontStyle(weight / 100, isItalic));
     minikinFont->Unref();
     return true;
 }
@@ -219,7 +220,7 @@ static jboolean FontFamily_addFontFromAsset(JNIEnv* env, jobject, jlong familyPt
         ALOGE("addFontFromAsset failed to create font %s", str.c_str());
         return false;
     }
-    FontFamily* fontFamily = reinterpret_cast<FontFamily*>(familyPtr);
+    minikin::FontFamily* fontFamily = reinterpret_cast<minikin::FontFamily*>(familyPtr);
     return addSkTypeface(fontFamily, face, buf, bufSize, /* ttcIndex */ 0);
 }
 
diff --git a/core/jni/android/graphics/Paint.cpp b/core/jni/android/graphics/Paint.cpp
index 898cf77cb32dc..b586c43aacea5 100644
--- a/core/jni/android/graphics/Paint.cpp
+++ b/core/jni/android/graphics/Paint.cpp
@@ -319,7 +319,7 @@ namespace PaintGlue {
     static jint setTextLocales(JNIEnv* env, jobject clazz, jlong objHandle, jstring locales) {
         Paint* obj = reinterpret_cast<Paint*>(objHandle);
         ScopedUtfChars localesChars(env, locales);
-        jint minikinLangListId = FontStyle::registerLanguageList(localesChars.c_str());
+        jint minikinLangListId = minikin::FontStyle::registerLanguageList(localesChars.c_str());
         obj->setMinikinLangListId(minikinLangListId);
         return minikinLangListId;
     }
@@ -332,12 +332,12 @@ namespace PaintGlue {
 
     static jboolean isElegantTextHeight(JNIEnv* env, jobject, jlong paintHandle) {
         Paint* obj = reinterpret_cast<Paint*>(paintHandle);
-        return obj->getFontVariant() == VARIANT_ELEGANT;
+        return obj->getFontVariant() == minikin::VARIANT_ELEGANT;
     }
 
     static void setElegantTextHeight(JNIEnv* env, jobject, jlong paintHandle, jboolean aa) {
         Paint* obj = reinterpret_cast<Paint*>(paintHandle);
-        obj->setFontVariant(aa ? VARIANT_ELEGANT : VARIANT_DEFAULT);
+        obj->setFontVariant(aa ? minikin::VARIANT_ELEGANT : minikin::VARIANT_DEFAULT);
     }
 
     static jfloat getTextSize(JNIEnv* env, jobject, jlong paintHandle) {
@@ -404,7 +404,7 @@ namespace PaintGlue {
         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
         typeface = Typeface::resolveDefault(typeface);
-        FakedFont baseFont = typeface->fFontCollection->baseFontFaked(typeface->fStyle);
+        minikin::FakedFont baseFont = typeface->fFontCollection->baseFontFaked(typeface->fStyle);
         float saveSkewX = paint->getTextSkewX();
         bool savefakeBold = paint->isFakeBoldText();
         MinikinFontSkia::populateSkPaint(paint, baseFont.font, baseFont.fakery);
@@ -414,7 +414,7 @@ namespace PaintGlue {
         // restore the original settings.
         paint->setTextSkewX(saveSkewX);
         paint->setFakeBoldText(savefakeBold);
-        if (paint->getFontVariant() == VARIANT_ELEGANT) {
+        if (paint->getFontVariant() == minikin::VARIANT_ELEGANT) {
             SkScalar size = paint->getTextSize();
             metrics->fTop = -size * kElegantTop / 2048;
             metrics->fBottom = -size * kElegantBottom / 2048;
@@ -534,8 +534,9 @@ namespace PaintGlue {
 
     static jint doTextRunCursor(JNIEnv *env, Paint* paint, const jchar *text, jint start,
             jint count, jint flags, jint offset, jint opt) {
-        GraphemeBreak::MoveOpt moveOpt = GraphemeBreak::MoveOpt(opt);
-        size_t result = GraphemeBreak::getTextRunCursor(text, start, count, offset, moveOpt);
+        minikin::GraphemeBreak::MoveOpt moveOpt = minikin::GraphemeBreak::MoveOpt(opt);
+        size_t result = minikin::GraphemeBreak::getTextRunCursor(text, start, count, offset,
+                moveOpt);
         return static_cast<jint>(result);
     }
 
@@ -561,8 +562,8 @@ namespace PaintGlue {
 
     class GetTextFunctor {
     public:
-        GetTextFunctor(const Layout& layout, SkPath* path, jfloat x, jfloat y, Paint* paint,
-                    uint16_t* glyphs, SkPoint* pos)
+        GetTextFunctor(const minikin::Layout& layout, SkPath* path, jfloat x, jfloat y,
+                    Paint* paint, uint16_t* glyphs, SkPoint* pos)
                 : layout(layout), path(path), x(x), y(y), paint(paint), glyphs(glyphs), pos(pos) {
         }
 
@@ -580,7 +581,7 @@ namespace PaintGlue {
             }
         }
     private:
-        const Layout& layout;
+        const minikin::Layout& layout;
         SkPath* path;
         jfloat x;
         jfloat y;
@@ -592,7 +593,7 @@ namespace PaintGlue {
 
     static void getTextPath(JNIEnv* env, Paint* paint, Typeface* typeface, const jchar* text,
             jint count, jint bidiFlags, jfloat x, jfloat y, SkPath* path) {
-        Layout layout;
+        minikin::Layout layout;
         MinikinUtils::doLayout(&layout, paint, bidiFlags, typeface, text, 0, count, count);
         size_t nGlyphs = layout.nGlyphs();
         uint16_t* glyphs = new uint16_t[nGlyphs];
@@ -728,9 +729,9 @@ namespace PaintGlue {
         SkRect  r;
         SkIRect ir;
 
-        Layout layout;
+        minikin::Layout layout;
         MinikinUtils::doLayout(&layout, &paint, bidiFlags, typeface, text, 0, count, count);
-        MinikinRect rect;
+        minikin::MinikinRect rect;
         layout.getBounds(&rect);
         r.fLeft = rect.mLeft;
         r.fTop = rect.mTop;
@@ -759,7 +760,7 @@ namespace PaintGlue {
                                       JNI_ABORT);
     }
 
-    static jboolean layoutContainsNotdef(const Layout& layout) {
+    static jboolean layoutContainsNotdef(const minikin::Layout& layout) {
         for (size_t i = 0; i < layout.nGlyphs(); i++) {
             if (layout.getGlyphId(i) == 0) {
                 return true;
@@ -828,7 +829,7 @@ namespace PaintGlue {
             nChars++;
             prevCp = cp;
         }
-        Layout layout;
+        minikin::Layout layout;
         MinikinUtils::doLayout(&layout, paint, bidiFlags, typeface, str.get(), 0, str.size(),
                 str.size());
         size_t nGlyphs = layout.nGlyphs();
@@ -849,7 +850,7 @@ namespace PaintGlue {
             // since ZZ is reserved for unknown or invalid territory.
             // U+1F1FF (REGIONAL INDICATOR SYMBOL LETTER Z) is \uD83C\uDDFF in UTF16.
             static const jchar ZZ_FLAG_STR[] = { 0xD83C, 0xDDFF, 0xD83C, 0xDDFF };
-            Layout zzLayout;
+            minikin::Layout zzLayout;
             MinikinUtils::doLayout(&zzLayout, paint, bidiFlags, typeface, ZZ_FLAG_STR, 0, 4, 4);
             if (zzLayout.nGlyphs() != 1 || layoutContainsNotdef(zzLayout)) {
                 // The font collection doesn't have a glyph for unknown flag. Just return true.
@@ -862,7 +863,7 @@ namespace PaintGlue {
 
     static jfloat doRunAdvance(const Paint* paint, Typeface* typeface, const jchar buf[],
             jint start, jint count, jint bufSize, jboolean isRtl, jint offset) {
-        int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR;
+        int bidiFlags = isRtl ? minikin::kBidi_Force_RTL : minikin::kBidi_Force_LTR;
         if (offset == start + count) {
             return MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count,
                     bufSize, nullptr);
@@ -870,7 +871,7 @@ namespace PaintGlue {
         std::unique_ptr<float[]> advancesArray(new float[count]);
         MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count, bufSize,
                 advancesArray.get());
-        return getRunAdvance(advancesArray.get(), buf, start, count, offset);
+        return minikin::getRunAdvance(advancesArray.get(), buf, start, count, offset);
     }
 
     static jfloat getRunAdvance___CIIIIZI_F(JNIEnv *env, jclass, jlong paintHandle,
@@ -888,11 +889,11 @@ namespace PaintGlue {
 
     static jint doOffsetForAdvance(const Paint* paint, Typeface* typeface, const jchar buf[],
             jint start, jint count, jint bufSize, jboolean isRtl, jfloat advance) {
-        int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR;
+        int bidiFlags = isRtl ? minikin::kBidi_Force_RTL : minikin::kBidi_Force_LTR;
         std::unique_ptr<float[]> advancesArray(new float[count]);
         MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count, bufSize,
                 advancesArray.get());
-        return getOffsetForAdvance(advancesArray.get(), buf, start, count, advance);
+        return minikin::getOffsetForAdvance(advancesArray.get(), buf, start, count, advance);
     }
 
     static jint getOffsetForAdvance___CIIIIZF_I(JNIEnv *env, jclass, jlong paintHandle,
diff --git a/core/jni/android/graphics/Typeface.cpp b/core/jni/android/graphics/Typeface.cpp
index 9a53cadf355b7..7fc79d29f0466 100644
--- a/core/jni/android/graphics/Typeface.cpp
+++ b/core/jni/android/graphics/Typeface.cpp
@@ -60,9 +60,9 @@ static jint Typeface_getStyle(JNIEnv* env, jobject obj, jlong faceHandle) {
 
 static jlong Typeface_createFromArray(JNIEnv *env, jobject, jlongArray familyArray) {
     ScopedLongArrayRO families(env, familyArray);
-    std::vector<FontFamily*> familyVec;
+    std::vector<minikin::FontFamily*> familyVec;
     for (size_t i = 0; i < families.size(); i++) {
-        FontFamily* family = reinterpret_cast<FontFamily*>(families[i]);
+        minikin::FontFamily* family = reinterpret_cast<minikin::FontFamily*>(families[i]);
         familyVec.push_back(family);
     }
     return reinterpret_cast<jlong>(Typeface::createFromFamilies(familyVec));
diff --git a/core/jni/android_graphics_Canvas.cpp b/core/jni/android_graphics_Canvas.cpp
index ded4daca07073..03a50dd550ecd 100644
--- a/core/jni/android_graphics_Canvas.cpp
+++ b/core/jni/android_graphics_Canvas.cpp
@@ -503,7 +503,7 @@ static void drawTextRunChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArra
     Paint* paint = reinterpret_cast<Paint*>(paintHandle);
     Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 
-    const int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR;
+    const int bidiFlags = isRtl ? minikin::kBidi_Force_RTL : minikin::kBidi_Force_LTR;
     jchar* jchars = env->GetCharArrayElements(text, NULL);
     get_canvas(canvasHandle)->drawText(jchars + contextIndex, index - contextIndex, count,
                                        contextCount, x, y, bidiFlags, *paint, typeface);
@@ -517,7 +517,7 @@ static void drawTextRunString(JNIEnv* env, jobject obj, jlong canvasHandle, jstr
     Paint* paint = reinterpret_cast<Paint*>(paintHandle);
     Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 
-    int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR;
+    int bidiFlags = isRtl ? minikin::kBidi_Force_RTL : minikin::kBidi_Force_LTR;
     jint count = end - start;
     jint contextCount = contextEnd - contextStart;
     const jchar* jchars = env->GetStringChars(text, NULL);
@@ -567,7 +567,7 @@ static void freeCaches(JNIEnv* env, jobject) {
 }
 
 static void freeTextLayoutCaches(JNIEnv* env, jobject) {
-    Layout::purgeCaches();
+    minikin::Layout::purgeCaches();
 }
 
 }; // namespace CanvasJNI
diff --git a/core/jni/android_text_StaticLayout.cpp b/core/jni/android_text_StaticLayout.cpp
index 13e4f1a59fd8d..02fa8720d5d2a 100644
--- a/core/jni/android_text_StaticLayout.cpp
+++ b/core/jni/android_text_StaticLayout.cpp
@@ -55,7 +55,7 @@ static JLineBreaksID gLineBreaks_fieldID;
 static void nSetupParagraph(JNIEnv* env, jclass, jlong nativePtr, jcharArray text, jint length,
         jfloat firstWidth, jint firstWidthLineLimit, jfloat restWidth,
         jintArray variableTabStops, jint defaultTabStop, jint strategy, jint hyphenFrequency) {
-    LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
+    minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
     b->resize(length);
     env->GetCharArrayRegion(text, 0, length, b->buffer());
     b->setText();
@@ -66,8 +66,8 @@ static void nSetupParagraph(JNIEnv* env, jclass, jlong nativePtr, jcharArray tex
         ScopedIntArrayRO stops(env, variableTabStops);
         b->setTabStops(stops.get(), stops.size(), defaultTabStop);
     }
-    b->setStrategy(static_cast<BreakStrategy>(strategy));
-    b->setHyphenationFrequency(static_cast<HyphenationFrequency>(hyphenFrequency));
+    b->setStrategy(static_cast<minikin::BreakStrategy>(strategy));
+    b->setHyphenationFrequency(static_cast<minikin::HyphenationFrequency>(hyphenFrequency));
 }
 
 static void recycleCopy(JNIEnv* env, jobject recycle, jintArray recycleBreaks,
@@ -94,7 +94,7 @@ static jint nComputeLineBreaks(JNIEnv* env, jclass, jlong nativePtr,
                                jobject recycle, jintArray recycleBreaks,
                                jfloatArray recycleWidths, jintArray recycleFlags,
                                jint recycleLength) {
-    LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
+    minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
 
     size_t nBreaks = b->computeBreaks();
 
@@ -107,15 +107,15 @@ static jint nComputeLineBreaks(JNIEnv* env, jclass, jlong nativePtr,
 }
 
 static jlong nNewBuilder(JNIEnv*, jclass) {
-    return reinterpret_cast<jlong>(new LineBreaker);
+    return reinterpret_cast<jlong>(new minikin::LineBreaker);
 }
 
 static void nFreeBuilder(JNIEnv*, jclass, jlong nativePtr) {
-    delete reinterpret_cast<LineBreaker*>(nativePtr);
+    delete reinterpret_cast<minikin::LineBreaker*>(nativePtr);
 }
 
 static void nFinishBuilder(JNIEnv*, jclass, jlong nativePtr) {
-    LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
+    minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
     b->finish();
 }
 
@@ -129,15 +129,15 @@ static jlong nLoadHyphenator(JNIEnv* env, jclass, jobject buffer, jint offset) {
             ALOGE("failed to get direct buffer address");
         }
     }
-    Hyphenator* hyphenator = Hyphenator::loadBinary(bytebuf);
+    minikin::Hyphenator* hyphenator = minikin::Hyphenator::loadBinary(bytebuf);
     return reinterpret_cast<jlong>(hyphenator);
 }
 
 static void nSetLocale(JNIEnv* env, jclass, jlong nativePtr, jstring javaLocaleName,
         jlong nativeHyphenator) {
     ScopedIcuLocale icuLocale(env, javaLocaleName);
-    LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
-    Hyphenator* hyphenator = reinterpret_cast<Hyphenator*>(nativeHyphenator);
+    minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
+    minikin::Hyphenator* hyphenator = reinterpret_cast<minikin::Hyphenator*>(nativeHyphenator);
 
     if (icuLocale.valid()) {
         b->setLocale(icuLocale.locale(), hyphenator);
@@ -147,38 +147,39 @@ static void nSetLocale(JNIEnv* env, jclass, jlong nativePtr, jstring javaLocaleN
 static void nSetIndents(JNIEnv* env, jclass, jlong nativePtr, jintArray indents) {
     ScopedIntArrayRO indentArr(env, indents);
     std::vector<float> indentVec(indentArr.get(), indentArr.get() + indentArr.size());
-    LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
+    minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
     b->setIndents(indentVec);
 }
 
 // Basically similar to Paint.getTextRunAdvances but with C++ interface
 static jfloat nAddStyleRun(JNIEnv* env, jclass, jlong nativePtr,
         jlong nativePaint, jlong nativeTypeface, jint start, jint end, jboolean isRtl) {
-    LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
+    minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
     Paint* paint = reinterpret_cast<Paint*>(nativePaint);
     Typeface* typeface = reinterpret_cast<Typeface*>(nativeTypeface);
-    FontCollection *font;
-    MinikinPaint minikinPaint;
-    FontStyle style = MinikinUtils::prepareMinikinPaint(&minikinPaint, &font, paint, typeface);
+    minikin::FontCollection *font;
+    minikin::MinikinPaint minikinPaint;
+    minikin::FontStyle style = MinikinUtils::prepareMinikinPaint(&minikinPaint, &font, paint,
+            typeface);
     return b->addStyleRun(&minikinPaint, font, style, start, end, isRtl);
 }
 
 // Accept width measurements for the run, passed in from Java
 static void nAddMeasuredRun(JNIEnv* env, jclass, jlong nativePtr,
         jint start, jint end, jfloatArray widths) {
-    LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
+    minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
     env->GetFloatArrayRegion(widths, start, end - start, b->charWidths() + start);
-    b->addStyleRun(nullptr, nullptr, FontStyle{}, start, end, false);
+    b->addStyleRun(nullptr, nullptr, minikin::FontStyle{}, start, end, false);
 }
 
 static void nAddReplacementRun(JNIEnv* env, jclass, jlong nativePtr,
         jint start, jint end, jfloat width) {
-    LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
+    minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
     b->addReplacement(start, end, width);
 }
 
 static void nGetWidths(JNIEnv* env, jclass, jlong nativePtr, jfloatArray widths) {
-    LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
+    minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
     env->SetFloatArrayRegion(widths, 0, b->size(), b->charWidths());
 }
 
diff --git a/libs/hwui/hwui/Canvas.cpp b/libs/hwui/hwui/Canvas.cpp
index 7bfa15a26d568..dd0d72b76d4d8 100644
--- a/libs/hwui/hwui/Canvas.cpp
+++ b/libs/hwui/hwui/Canvas.cpp
@@ -79,8 +79,9 @@ static void simplifyPaint(int color, SkPaint* paint) {
 
 class DrawTextFunctor {
 public:
-    DrawTextFunctor(const Layout& layout, Canvas* canvas, uint16_t* glyphs, float* pos,
-            const SkPaint& paint, float x, float y, MinikinRect& bounds, float totalAdvance)
+    DrawTextFunctor(const minikin::Layout& layout, Canvas* canvas, uint16_t* glyphs, float* pos,
+            const SkPaint& paint, float x, float y, minikin::MinikinRect& bounds,
+            float totalAdvance)
         : layout(layout)
         , canvas(canvas)
         , glyphs(glyphs)
@@ -135,14 +136,14 @@ public:
         }
     }
 private:
-    const Layout& layout;
+    const minikin::Layout& layout;
     Canvas* canvas;
     uint16_t* glyphs;
     float* pos;
     const SkPaint& paint;
     float x;
     float y;
-    MinikinRect& bounds;
+    minikin::MinikinRect& bounds;
     float totalAdvance;
 };
 
@@ -151,7 +152,7 @@ void Canvas::drawText(const uint16_t* text, int start, int count, int contextCou
     // minikin may modify the original paint
     Paint paint(origPaint);
 
-    Layout layout;
+    minikin::Layout layout;
     MinikinUtils::doLayout(&layout, &paint, bidiFlags, typeface, text, start, count, contextCount);
 
     size_t nGlyphs = layout.nGlyphs();
@@ -160,7 +161,7 @@ void Canvas::drawText(const uint16_t* text, int start, int count, int contextCou
 
     x += MinikinUtils::xOffsetForTextAlign(&paint, layout);
 
-    MinikinRect bounds;
+    minikin::MinikinRect bounds;
     layout.getBounds(&bounds);
     if (!drawTextAbsolutePos()) {
         bounds.offset(x, y);
@@ -178,7 +179,7 @@ void Canvas::drawText(const uint16_t* text, int start, int count, int contextCou
 
 class DrawTextOnPathFunctor {
 public:
-    DrawTextOnPathFunctor(const Layout& layout, Canvas* canvas, float hOffset,
+    DrawTextOnPathFunctor(const minikin::Layout& layout, Canvas* canvas, float hOffset,
             float vOffset, const Paint& paint, const SkPath& path)
         : layout(layout)
         , canvas(canvas)
@@ -198,7 +199,7 @@ public:
         }
     }
 private:
-    const Layout& layout;
+    const minikin::Layout& layout;
     Canvas* canvas;
     float hOffset;
     float vOffset;
@@ -209,7 +210,7 @@ private:
 void Canvas::drawTextOnPath(const uint16_t* text, int count, int bidiFlags, const SkPath& path,
         float hOffset, float vOffset, const Paint& paint, Typeface* typeface) {
     Paint paintCopy(paint);
-    Layout layout;
+    minikin::Layout layout;
     MinikinUtils::doLayout(&layout, &paintCopy, bidiFlags, typeface, text, 0, count, count);
     hOffset += MinikinUtils::hOffsetForTextAlign(&paintCopy, layout, path);
 
diff --git a/libs/hwui/hwui/MinikinSkia.cpp b/libs/hwui/hwui/MinikinSkia.cpp
index a455f576e38d7..d16b64415f528 100644
--- a/libs/hwui/hwui/MinikinSkia.cpp
+++ b/libs/hwui/hwui/MinikinSkia.cpp
@@ -24,7 +24,7 @@ namespace android {
 
 MinikinFontSkia::MinikinFontSkia(SkTypeface* typeface, const void* fontData, size_t fontSize,
         int ttcIndex) :
-    MinikinFont(typeface->uniqueID()), mTypeface(typeface), mFontData(fontData),
+    minikin::MinikinFont(typeface->uniqueID()), mTypeface(typeface), mFontData(fontData),
     mFontSize(fontSize), mTtcIndex(ttcIndex) {
 }
 
@@ -32,7 +32,8 @@ MinikinFontSkia::~MinikinFontSkia() {
     SkSafeUnref(mTypeface);
 }
 
-static void MinikinFontSkia_SetSkiaPaint(const MinikinFont* font, SkPaint* skPaint, const MinikinPaint& paint) {
+static void MinikinFontSkia_SetSkiaPaint(const minikin::MinikinFont* font, SkPaint* skPaint,
+        const minikin::MinikinPaint& paint) {
     skPaint->setTextEncoding(SkPaint::kGlyphID_TextEncoding);
     skPaint->setTextSize(paint.size);
     skPaint->setTextScaleX(paint.scaleX);
@@ -43,7 +44,7 @@ static void MinikinFontSkia_SetSkiaPaint(const MinikinFont* font, SkPaint* skPai
 }
 
 float MinikinFontSkia::GetHorizontalAdvance(uint32_t glyph_id,
-    const MinikinPaint &paint) const {
+        const minikin::MinikinPaint &paint) const {
     SkPaint skPaint;
     uint16_t glyph16 = glyph_id;
     SkScalar skWidth;
@@ -55,8 +56,8 @@ float MinikinFontSkia::GetHorizontalAdvance(uint32_t glyph_id,
     return skWidth;
 }
 
-void MinikinFontSkia::GetBounds(MinikinRect* bounds, uint32_t glyph_id,
-    const MinikinPaint& paint) const {
+void MinikinFontSkia::GetBounds(minikin::MinikinRect* bounds, uint32_t glyph_id,
+        const minikin::MinikinPaint& paint) const {
     SkPaint skPaint;
     uint16_t glyph16 = glyph_id;
     SkRect skBounds;
@@ -68,7 +69,8 @@ void MinikinFontSkia::GetBounds(MinikinRect* bounds, uint32_t glyph_id,
     bounds->mBottom = skBounds.fBottom;
 }
 
-const void* MinikinFontSkia::GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) {
+const void* MinikinFontSkia::GetTable(uint32_t tag, size_t* size,
+        minikin::MinikinDestroyFunc* destroy) {
     // we don't have a buffer to the font data, copy to own buffer
     const size_t tableSize = mTypeface->getTableSize(tag);
     *size = tableSize;
@@ -117,7 +119,8 @@ void MinikinFontSkia::unpackPaintFlags(SkPaint* paint, uint32_t paintFlags) {
     paint->setHinting(static_cast<SkPaint::Hinting>(paintFlags >> 16));
 }
 
-void MinikinFontSkia::populateSkPaint(SkPaint* paint, const MinikinFont* font, FontFakery fakery) {
+void MinikinFontSkia::populateSkPaint(SkPaint* paint, const MinikinFont* font,
+        minikin::FontFakery fakery) {
     paint->setTypeface(reinterpret_cast<const MinikinFontSkia*>(font)->GetSkTypeface());
     paint->setFakeBoldText(paint->isFakeBoldText() || fakery.isFakeBold());
     if (fakery.isFakeItalic()) {
diff --git a/libs/hwui/hwui/MinikinSkia.h b/libs/hwui/hwui/MinikinSkia.h
index a7c9fb0b09d41..96b256d1b8afb 100644
--- a/libs/hwui/hwui/MinikinSkia.h
+++ b/libs/hwui/hwui/MinikinSkia.h
@@ -25,7 +25,7 @@ class SkTypeface;
 
 namespace android {
 
-class ANDROID_API MinikinFontSkia : public MinikinFont {
+class ANDROID_API MinikinFontSkia : public minikin::MinikinFont {
 public:
     // Note: this takes ownership of the reference (will unref on dtor)
     explicit MinikinFontSkia(SkTypeface *typeface, const void* fontData, size_t fontSize,
@@ -34,12 +34,12 @@ public:
     ~MinikinFontSkia();
 
     float GetHorizontalAdvance(uint32_t glyph_id,
-        const MinikinPaint &paint) const;
+        const minikin::MinikinPaint &paint) const;
 
-    void GetBounds(MinikinRect* bounds, uint32_t glyph_id,
-        const MinikinPaint &paint) const;
+    void GetBounds(minikin::MinikinRect* bounds, uint32_t glyph_id,
+        const minikin::MinikinPaint &paint) const;
 
-    const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy);
+    const void* GetTable(uint32_t tag, size_t* size, minikin::MinikinDestroyFunc* destroy);
 
     SkTypeface* GetSkTypeface() const;
 
@@ -52,7 +52,8 @@ public:
     static void unpackPaintFlags(SkPaint* paint, uint32_t paintFlags);
 
     // set typeface and fake bold/italic parameters
-    static void populateSkPaint(SkPaint* paint, const MinikinFont* font, FontFakery fakery);
+    static void populateSkPaint(SkPaint* paint, const minikin::MinikinFont* font,
+            minikin::FontFakery fakery);
 private:
     SkTypeface* mTypeface;
 
diff --git a/libs/hwui/hwui/MinikinUtils.cpp b/libs/hwui/hwui/MinikinUtils.cpp
index 67b775d983569..a06cc37f944e7 100644
--- a/libs/hwui/hwui/MinikinUtils.cpp
+++ b/libs/hwui/hwui/MinikinUtils.cpp
@@ -24,17 +24,18 @@
 
 namespace android {
 
-FontStyle MinikinUtils::prepareMinikinPaint(MinikinPaint* minikinPaint, FontCollection** pFont,
-        const Paint* paint, Typeface* typeface) {
+minikin::FontStyle MinikinUtils::prepareMinikinPaint(minikin::MinikinPaint* minikinPaint,
+        minikin::FontCollection** pFont, const Paint* paint, Typeface* typeface) {
     const Typeface* resolvedFace = Typeface::resolveDefault(typeface);
     *pFont = resolvedFace->fFontCollection;
-    FontStyle resolved = resolvedFace->fStyle;
+    minikin::FontStyle resolved = resolvedFace->fStyle;
 
     /* Prepare minikin FontStyle */
-    FontVariant minikinVariant = (paint->getFontVariant() == VARIANT_ELEGANT) ? VARIANT_ELEGANT
-            : VARIANT_COMPACT;
+    minikin::FontVariant minikinVariant = (paint->getFontVariant() == minikin::VARIANT_ELEGANT) ?
+            minikin::VARIANT_ELEGANT : minikin::VARIANT_COMPACT;
     const uint32_t langListId = paint->getMinikinLangListId();
-    FontStyle minikinStyle(langListId, minikinVariant, resolved.getWeight(), resolved.getItalic());
+    minikin::FontStyle minikinStyle(langListId, minikinVariant, resolved.getWeight(),
+            resolved.getItalic());
 
     /* Prepare minikin Paint */
     // Note: it would be nice to handle fractional size values (it would improve smooth zoom
@@ -46,27 +47,27 @@ FontStyle MinikinUtils::prepareMinikinPaint(MinikinPaint* minikinPaint, FontColl
     minikinPaint->letterSpacing = paint->getLetterSpacing();
     minikinPaint->paintFlags = MinikinFontSkia::packPaintFlags(paint);
     minikinPaint->fontFeatureSettings = paint->getFontFeatureSettings();
-    minikinPaint->hyphenEdit = HyphenEdit(paint->getHyphenEdit());
+    minikinPaint->hyphenEdit = minikin::HyphenEdit(paint->getHyphenEdit());
     return minikinStyle;
 }
 
-void MinikinUtils::doLayout(Layout* layout, const Paint* paint, int bidiFlags,
+void MinikinUtils::doLayout(minikin::Layout* layout, const Paint* paint, int bidiFlags,
         Typeface* typeface, const uint16_t* buf, size_t start, size_t count,
         size_t bufSize) {
-    FontCollection *font;
-    MinikinPaint minikinPaint;
-    FontStyle minikinStyle = prepareMinikinPaint(&minikinPaint, &font, paint, typeface);
+    minikin::FontCollection *font;
+    minikin::MinikinPaint minikinPaint;
+    minikin::FontStyle minikinStyle = prepareMinikinPaint(&minikinPaint, &font, paint, typeface);
     layout->setFontCollection(font);
     layout->doLayout(buf, start, count, bufSize, bidiFlags, minikinStyle, minikinPaint);
 }
 
 float MinikinUtils::measureText(const Paint* paint, int bidiFlags, Typeface* typeface,
         const uint16_t* buf, size_t start, size_t count, size_t bufSize, float *advances) {
-    FontCollection *font;
-    MinikinPaint minikinPaint;
-    FontStyle minikinStyle = prepareMinikinPaint(&minikinPaint, &font, paint, typeface);
-    return Layout::measureText(buf, start, count, bufSize, bidiFlags, minikinStyle, minikinPaint,
-            font, advances);
+    minikin::FontCollection *font;
+    minikin::MinikinPaint minikinPaint;
+    minikin::FontStyle minikinStyle = prepareMinikinPaint(&minikinPaint, &font, paint, typeface);
+    return minikin::Layout::measureText(buf, start, count, bufSize, bidiFlags, minikinStyle,
+            minikinPaint, font, advances);
 }
 
 bool MinikinUtils::hasVariationSelector(Typeface* typeface, uint32_t codepoint, uint32_t vs) {
@@ -74,7 +75,7 @@ bool MinikinUtils::hasVariationSelector(Typeface* typeface, uint32_t codepoint,
     return resolvedFace->fFontCollection->hasVariationSelector(codepoint, vs);
 }
 
-float MinikinUtils::xOffsetForTextAlign(Paint* paint, const Layout& layout) {
+float MinikinUtils::xOffsetForTextAlign(Paint* paint, const minikin::Layout& layout) {
     switch (paint->getTextAlign()) {
         case Paint::kCenter_Align:
             return layout.getAdvance() * -0.5f;
@@ -88,7 +89,8 @@ float MinikinUtils::xOffsetForTextAlign(Paint* paint, const Layout& layout) {
     return 0;
 }
 
-float MinikinUtils::hOffsetForTextAlign(Paint* paint, const Layout& layout, const SkPath& path) {
+float MinikinUtils::hOffsetForTextAlign(Paint* paint, const minikin::Layout& layout,
+        const SkPath& path) {
     float align = 0;
     switch (paint->getTextAlign()) {
         case Paint::kCenter_Align:
diff --git a/libs/hwui/hwui/MinikinUtils.h b/libs/hwui/hwui/MinikinUtils.h
index cfaa961ac1fcf..d6f64d2418d50 100644
--- a/libs/hwui/hwui/MinikinUtils.h
+++ b/libs/hwui/hwui/MinikinUtils.h
@@ -34,31 +34,33 @@ namespace android {
 
 class MinikinUtils {
 public:
-    ANDROID_API static FontStyle prepareMinikinPaint(MinikinPaint* minikinPaint, FontCollection** pFont,
-            const Paint* paint, Typeface* typeface);
+    ANDROID_API static minikin::FontStyle prepareMinikinPaint(minikin::MinikinPaint* minikinPaint,
+            minikin::FontCollection** pFont, const Paint* paint, Typeface* typeface);
 
-    ANDROID_API static void doLayout(Layout* layout, const Paint* paint, int bidiFlags,
+    ANDROID_API static void doLayout(minikin::Layout* layout, const Paint* paint, int bidiFlags,
             Typeface* typeface, const uint16_t* buf, size_t start, size_t count,
             size_t bufSize);
 
     ANDROID_API static float measureText(const Paint* paint, int bidiFlags, Typeface* typeface,
             const uint16_t* buf, size_t start, size_t count, size_t bufSize, float *advances);
 
-    ANDROID_API static bool hasVariationSelector(Typeface* typeface, uint32_t codepoint, uint32_t vs);
+    ANDROID_API static bool hasVariationSelector(Typeface* typeface, uint32_t codepoint,
+            uint32_t vs);
 
-    ANDROID_API static float xOffsetForTextAlign(Paint* paint, const Layout& layout);
+    ANDROID_API static float xOffsetForTextAlign(Paint* paint, const minikin::Layout& layout);
 
-    ANDROID_API static float hOffsetForTextAlign(Paint* paint, const Layout& layout, const SkPath& path);
+    ANDROID_API static float hOffsetForTextAlign(Paint* paint, const minikin::Layout& layout,
+            const SkPath& path);
     // f is a functor of type void f(size_t start, size_t end);
     template <typename F>
-    ANDROID_API static void forFontRun(const Layout& layout, Paint* paint, F& f) {
+    ANDROID_API static void forFontRun(const minikin::Layout& layout, Paint* paint, F& f) {
         float saveSkewX = paint->getTextSkewX();
         bool savefakeBold = paint->isFakeBoldText();
-        MinikinFont* curFont = NULL;
+        minikin::MinikinFont* curFont = NULL;
         size_t start = 0;
         size_t nGlyphs = layout.nGlyphs();
         for (size_t i = 0; i < nGlyphs; i++) {
-            MinikinFont* nextFont = layout.getFont(i);
+          minikin::MinikinFont* nextFont = layout.getFont(i);
             if (i > 0 && nextFont != curFont) {
                 MinikinFontSkia::populateSkPaint(paint, curFont, layout.getFakery(start));
                 f(start, i);
diff --git a/libs/hwui/hwui/Paint.h b/libs/hwui/hwui/Paint.h
index 9599c30c639b2..6307926ec43e5 100644
--- a/libs/hwui/hwui/Paint.h
+++ b/libs/hwui/hwui/Paint.h
@@ -64,11 +64,11 @@ public:
         return mMinikinLangListId;
     }
 
-    void setFontVariant(FontVariant variant) {
+    void setFontVariant(minikin::FontVariant variant) {
         mFontVariant = variant;
     }
 
-    FontVariant getFontVariant() const {
+    minikin::FontVariant getFontVariant() const {
         return mFontVariant;
     }
 
@@ -84,7 +84,7 @@ private:
     float mLetterSpacing = 0;
     std::string mFontFeatureSettings;
     uint32_t mMinikinLangListId;
-    FontVariant mFontVariant;
+    minikin::FontVariant mFontVariant;
     uint32_t mHyphenEdit = 0;
 };
 
diff --git a/libs/hwui/hwui/PaintImpl.cpp b/libs/hwui/hwui/PaintImpl.cpp
index b27672ce16a09..84122d7680892 100644
--- a/libs/hwui/hwui/PaintImpl.cpp
+++ b/libs/hwui/hwui/PaintImpl.cpp
@@ -20,7 +20,7 @@ namespace android {
 
 Paint::Paint() :
         SkPaint(), mLetterSpacing(0), mFontFeatureSettings(), mMinikinLangListId(0),
-        mFontVariant(VARIANT_DEFAULT) {
+        mFontVariant(minikin::VARIANT_DEFAULT) {
 }
 
 Paint::Paint(const Paint& paint) : SkPaint(paint),
@@ -31,7 +31,7 @@ Paint::Paint(const Paint& paint) : SkPaint(paint),
 
 Paint::Paint(const SkPaint& paint) : SkPaint(paint),
         mLetterSpacing(0), mFontFeatureSettings(), mMinikinLangListId(0),
-        mFontVariant(VARIANT_DEFAULT) {
+        mFontVariant(minikin::VARIANT_DEFAULT) {
 }
 
 Paint::~Paint() {
diff --git a/libs/hwui/hwui/Typeface.cpp b/libs/hwui/hwui/Typeface.cpp
index c583988554c72..b5c5ef9a59152 100644
--- a/libs/hwui/hwui/Typeface.cpp
+++ b/libs/hwui/hwui/Typeface.cpp
@@ -43,7 +43,7 @@ static void resolveStyle(Typeface* typeface) {
         weight = 9;
     }
     bool italic = (typeface->fSkiaStyle & SkTypeface::kItalic) != 0;
-    typeface->fStyle = FontStyle(weight, italic);
+    typeface->fStyle = minikin::FontStyle(weight, italic);
 }
 
 Typeface* gDefaultTypeface = NULL;
@@ -54,13 +54,13 @@ pthread_once_t gDefaultTypefaceOnce = PTHREAD_ONCE_INIT;
 // typeface is set.
 // TODO: investigate why layouts are being created before Typeface.java
 // class initialization.
-static FontCollection *makeFontCollection() {
-    std::vector<FontFamily *>typefaces;
+static minikin::FontCollection *makeFontCollection() {
+    std::vector<minikin::FontFamily *>typefaces;
     const char *fns[] = {
         "/system/fonts/Roboto-Regular.ttf",
     };
 
-    FontFamily *family = new FontFamily();
+    minikin::FontFamily *family = new minikin::FontFamily();
     for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) {
         const char *fn = fns[i];
         ALOGD("makeFontCollection adding %s", fn);
@@ -69,7 +69,7 @@ static FontCollection *makeFontCollection() {
             // TODO: might be a nice optimization to get access to the underlying font
             // data, but would require us opening the file ourselves and passing that
             // to the appropriate Create method of SkTypeface.
-            MinikinFont *font = new MinikinFontSkia(skFace, NULL, 0, 0);
+            minikin::MinikinFont *font = new MinikinFontSkia(skFace, NULL, 0, 0);
             family->addFont(font);
             font->Unref();
         } else {
@@ -78,13 +78,13 @@ static FontCollection *makeFontCollection() {
     }
     typefaces.push_back(family);
 
-    FontCollection *result = new FontCollection(typefaces);
+    minikin::FontCollection *result = new minikin::FontCollection(typefaces);
     family->Unref();
     return result;
 }
 
 static void getDefaultTypefaceOnce() {
-    Layout::init();
+  minikin::Layout::init();
     if (gDefaultTypeface == NULL) {
         // We expect the client to set a default typeface, but provide a
         // default so we can make progress before that happens.
@@ -131,16 +131,16 @@ Typeface* Typeface::createWeightAlias(Typeface* src, int weight) {
     return result;
 }
 
-Typeface* Typeface::createFromFamilies(const std::vector<FontFamily*>& families) {
+Typeface* Typeface::createFromFamilies(const std::vector<minikin::FontFamily*>& families) {
     Typeface* result = new Typeface;
-    result->fFontCollection = new FontCollection(families);
+    result->fFontCollection = new minikin::FontCollection(families);
     if (families.empty()) {
         ALOGW("createFromFamilies creating empty collection");
         result->fSkiaStyle = SkTypeface::kNormal;
     } else {
-        const FontStyle defaultStyle;
-        FontFamily* firstFamily = reinterpret_cast<FontFamily*>(families[0]);
-        MinikinFont* mf = firstFamily->getClosestMatch(defaultStyle).font;
+        const minikin::FontStyle defaultStyle;
+        minikin::FontFamily* firstFamily = reinterpret_cast<minikin::FontFamily*>(families[0]);
+        minikin::MinikinFont* mf = firstFamily->getClosestMatch(defaultStyle).font;
         if (mf != NULL) {
             SkTypeface* skTypeface = reinterpret_cast<MinikinFontSkia*>(mf)->GetSkTypeface();
             // TODO: probably better to query more precise style from family, will be important
diff --git a/libs/hwui/hwui/Typeface.h b/libs/hwui/hwui/Typeface.h
index 8862e5a5a9115..ed0a7ebd56ae2 100644
--- a/libs/hwui/hwui/Typeface.h
+++ b/libs/hwui/hwui/Typeface.h
@@ -27,7 +27,7 @@
 namespace android {
 
 struct ANDROID_API Typeface {
-    FontCollection *fFontCollection;
+  minikin::FontCollection *fFontCollection;
 
     // style used for constructing and querying Typeface objects
     SkTypeface::Style fSkiaStyle;
@@ -35,7 +35,7 @@ struct ANDROID_API Typeface {
     int fBaseWeight;
 
     // resolved style actually used for rendering
-    FontStyle fStyle;
+    minikin::FontStyle fStyle;
 
     void unref();
 
@@ -45,7 +45,7 @@ struct ANDROID_API Typeface {
 
     static Typeface* createWeightAlias(Typeface* src, int baseweight);
 
-    static Typeface* createFromFamilies(const std::vector<FontFamily*>& families);
+    static Typeface* createFromFamilies(const std::vector<minikin::FontFamily*>& families);
 
     static void setDefault(Typeface* face);
 };
diff --git a/libs/hwui/tests/common/scenes/GlyphStressAnimation.cpp b/libs/hwui/tests/common/scenes/GlyphStressAnimation.cpp
index f184411b4139f..a61f6d0f1e7cd 100644
--- a/libs/hwui/tests/common/scenes/GlyphStressAnimation.cpp
+++ b/libs/hwui/tests/common/scenes/GlyphStressAnimation.cpp
@@ -17,8 +17,8 @@
 #include "TestSceneBase.h"
 #include "utils/Color.h"
 
-#include <minikin/Layout.h>
 #include <hwui/Paint.h>
+#include <minikin/Layout.h>
 
 #include <cstdio>
 
@@ -56,7 +56,7 @@ public:
         for (int i = 0; i < 5; i++) {
             paint.setTextSize(10 + (frameNr % 20) + i * 20);
             canvas.drawText(text.get(), 0, textLength, textLength,
-                    0, 100 * (i + 2), kBidi_Force_LTR, paint, nullptr);
+                    0, 100 * (i + 2), minikin::kBidi_Force_LTR, paint, nullptr);
         }
 
         container->setStagingDisplayList(canvas.finishRecording(), nullptr);
diff --git a/libs/hwui/tests/unit/RecordingCanvasTests.cpp b/libs/hwui/tests/unit/RecordingCanvasTests.cpp
index 18171de250d0e..a6eaa81799dac 100644
--- a/libs/hwui/tests/unit/RecordingCanvasTests.cpp
+++ b/libs/hwui/tests/unit/RecordingCanvasTests.cpp
@@ -716,7 +716,7 @@ TEST(RecordingCanvas, drawText) {
         paint.setTextSize(20);
         paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
         std::unique_ptr<uint16_t[]> dst = TestUtils::asciiToUtf16("HELLO");
-        canvas.drawText(dst.get(), 0, 5, 5, 25, 25, kBidi_Force_LTR, paint, NULL);
+        canvas.drawText(dst.get(), 0, 5, 5, 25, 25, minikin::kBidi_Force_LTR, paint, NULL);
     });
 
     int count = 0;
@@ -740,7 +740,7 @@ TEST(RecordingCanvas, drawTextInHighContrast) {
         paint.setTextSize(20);
         paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
         std::unique_ptr<uint16_t[]> dst = TestUtils::asciiToUtf16("HELLO");
-        canvas.drawText(dst.get(), 0, 5, 5, 25, 25, kBidi_Force_LTR, paint, NULL);
+        canvas.drawText(dst.get(), 0, 5, 5, 25, 25, minikin::kBidi_Force_LTR, paint, NULL);
     });
 
     int count = 0;