--- old/src/share/classes/java/text/BreakIterator.java	Mon Aug 13 12:02:15 2012
+++ new/src/share/classes/java/text/BreakIterator.java	Mon Aug 13 12:02:13 2012
@@ -41,20 +41,10 @@
 package java.text;
 
 import java.lang.ref.SoftReference;
-import java.net.URL;
-import java.io.InputStream;
-import java.io.IOException;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
-import java.text.CharacterIterator;
-import java.text.StringCharacterIterator;
 import java.text.spi.BreakIteratorProvider;
 import java.util.Locale;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-import java.util.spi.LocaleServiceProvider;
-import sun.util.LocaleServiceProviderPool;
-import sun.util.resources.LocaleData;
+import sun.util.locale.provider.LocaleProviderAdapter;
+import sun.util.locale.provider.LocaleServiceProviderPool;
 
 
 /**
@@ -248,6 +238,7 @@
      * Create a copy of this iterator
      * @return A copy of this
      */
+    @Override
     public Object clone()
     {
         try {
@@ -360,8 +351,9 @@
         // abstract methods to an existing class.  There is almost ALWAYS a
         // better, faster way to do this.
         int pos = following(offset);
-        while (pos >= offset && pos != DONE)
+        while (pos >= offset && pos != DONE) {
             pos = previous();
+        }
         return pos;
     }
 
@@ -464,10 +456,7 @@
      */
     public static BreakIterator getWordInstance(Locale locale)
     {
-        return getBreakInstance(locale,
-                                WORD_INDEX,
-                                "WordData",
-                                "WordDictionary");
+        return getBreakInstance(locale, WORD_INDEX);
     }
 
     /**
@@ -491,10 +480,7 @@
      */
     public static BreakIterator getLineInstance(Locale locale)
     {
-        return getBreakInstance(locale,
-                                LINE_INDEX,
-                                "LineData",
-                                "LineDictionary");
+        return getBreakInstance(locale, LINE_INDEX);
     }
 
     /**
@@ -518,10 +504,7 @@
      */
     public static BreakIterator getCharacterInstance(Locale locale)
     {
-        return getBreakInstance(locale,
-                                CHARACTER_INDEX,
-                                "CharacterData",
-                                "CharacterDictionary");
+        return getBreakInstance(locale, CHARACTER_INDEX);
     }
 
     /**
@@ -545,16 +528,10 @@
      */
     public static BreakIterator getSentenceInstance(Locale locale)
     {
-        return getBreakInstance(locale,
-                                SENTENCE_INDEX,
-                                "SentenceData",
-                                "SentenceDictionary");
+        return getBreakInstance(locale, SENTENCE_INDEX);
     }
 
-    private static BreakIterator getBreakInstance(Locale locale,
-                                                  int type,
-                                                  String dataName,
-                                                  String dictionaryName) {
+    private static BreakIterator getBreakInstance(Locale locale, int type) {
         if (iterCache[type] != null) {
             BreakIteratorCache cache = iterCache[type].get();
             if (cache != null) {
@@ -564,63 +541,40 @@
             }
         }
 
-        BreakIterator result = createBreakInstance(locale,
-                                                   type,
-                                                   dataName,
-                                                   dictionaryName);
+        BreakIterator result = createBreakInstance(locale, type);
         BreakIteratorCache cache = new BreakIteratorCache(locale, result);
         iterCache[type] = new SoftReference<>(cache);
         return result;
     }
 
-    private static ResourceBundle getBundle(final String baseName, final Locale locale) {
-         return AccessController.doPrivileged(new PrivilegedAction<ResourceBundle>() {
-            public ResourceBundle run() {
-                return ResourceBundle.getBundle(baseName, locale);
-            }
-        });
-    }
-
     private static BreakIterator createBreakInstance(Locale locale,
-                                                     int type,
-                                                     String dataName,
-                                                     String dictionaryName) {
-
-        // Check whether a provider can provide an implementation that's closer
-        // to the requested locale than what the Java runtime itself can provide.
-        LocaleServiceProviderPool pool =
-            LocaleServiceProviderPool.getPool(BreakIteratorProvider.class);
-        if (pool.hasProviders()) {
-            BreakIterator providersInstance = pool.getLocalizedObject(
-                                                    BreakIteratorGetter.INSTANCE,
-                                                    locale, type);
-            if (providersInstance != null) {
-                return providersInstance;
-            }
+                                                     int type) {
+        LocaleProviderAdapter adapter = LocaleProviderAdapter.getAdapter(BreakIteratorProvider.class, locale);
+        BreakIterator iterator = createBreakInstance(adapter, locale, type);
+        if (iterator == null) {
+            iterator = createBreakInstance(LocaleProviderAdapter.forJRE(), locale, type);
         }
+        return iterator;
+    }
 
-        ResourceBundle bundle = getBundle(
-                        "sun.text.resources.BreakIteratorInfo", locale);
-        String[] classNames = bundle.getStringArray("BreakIteratorClasses");
-
-        String dataFile = bundle.getString(dataName);
-
-        try {
-            if (classNames[type].equals("RuleBasedBreakIterator")) {
-                return new RuleBasedBreakIterator(dataFile);
-            }
-            else if (classNames[type].equals("DictionaryBasedBreakIterator")) {
-                String dictionaryFile = bundle.getString(dictionaryName);
-                return new DictionaryBasedBreakIterator(dataFile, dictionaryFile);
-            }
-            else {
-                throw new IllegalArgumentException("Invalid break iterator class \"" +
-                                classNames[type] + "\"");
-            }
+    private static BreakIterator createBreakInstance(LocaleProviderAdapter adapter, Locale locale, int type) {
+        BreakIteratorProvider breakIteratorProvider = adapter.getBreakIteratorProvider();
+        BreakIterator iterator = null;
+        switch (type) {
+        case CHARACTER_INDEX:
+            iterator = breakIteratorProvider.getCharacterInstance(locale);
+            break;
+        case WORD_INDEX:
+            iterator = breakIteratorProvider.getWordInstance(locale);
+            break;
+        case LINE_INDEX:
+            iterator = breakIteratorProvider.getLineInstance(locale);
+            break;
+        case SENTENCE_INDEX:
+            iterator = breakIteratorProvider.getSentenceInstance(locale);
+            break;
         }
-        catch (Exception e) {
-            throw new InternalError(e.toString(), e);
-        }
+        return iterator;
     }
 
     /**
@@ -661,57 +615,4 @@
             return (BreakIterator) iter.clone();
         }
     }
-
-    static long getLong(byte[] buf, int offset) {
-        long num = buf[offset]&0xFF;
-        for (int i = 1; i < 8; i++) {
-            num = num<<8 | (buf[offset+i]&0xFF);
-        }
-        return num;
-    }
-
-    static int getInt(byte[] buf, int offset) {
-        int num = buf[offset]&0xFF;
-        for (int i = 1; i < 4; i++) {
-            num = num<<8 | (buf[offset+i]&0xFF);
-        }
-        return num;
-    }
-
-    static short getShort(byte[] buf, int offset) {
-        short num = (short)(buf[offset]&0xFF);
-        num = (short)(num<<8 | (buf[offset+1]&0xFF));
-        return num;
-    }
-
-    /**
-     * Obtains a BreakIterator instance from a BreakIteratorProvider
-     * implementation.
-     */
-    private static class BreakIteratorGetter
-        implements LocaleServiceProviderPool.LocalizedObjectGetter<BreakIteratorProvider, BreakIterator> {
-        private static final BreakIteratorGetter INSTANCE =
-            new BreakIteratorGetter();
-
-        public BreakIterator getObject(BreakIteratorProvider breakIteratorProvider,
-                                Locale locale,
-                                String key,
-                                Object... params) {
-            assert params.length == 1;
-
-            switch ((Integer)params[0]) {
-            case CHARACTER_INDEX:
-                return breakIteratorProvider.getCharacterInstance(locale);
-            case WORD_INDEX:
-                return breakIteratorProvider.getWordInstance(locale);
-            case LINE_INDEX:
-                return breakIteratorProvider.getLineInstance(locale);
-            case SENTENCE_INDEX:
-                return breakIteratorProvider.getSentenceInstance(locale);
-            default:
-                assert false : "should not happen";
-            }
-            return null;
-        }
-    }
 }