Move i18n break iterator C++ code to runtime

src/extensions/i18n/break-iterator.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 17 matching lines @@
 
 // ECMAScript 402 API implementation is broken into separate files for
 // each service. The build system combines them together into one
 // Intl namespace.
 
 /**
  * Initializes the given object so it's a valid BreakIterator instance.
  * Useful for subclassing.
  */
 function initializeBreakIterator(iterator, locales, options) {
-  native function NativeJSCreateBreakIterator();
-
   if (iterator.hasOwnProperty('__initializedIntlObject')) {
     throw new TypeError('Trying to re-initialize v8BreakIterator object.');
   }
 
   if (options === undefined) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'breakiterator');
 
   var internalOptions = {};
 
   defineWEProperty(internalOptions, 'type', getOption(
     'type', 'string', ['character', 'word', 'sentence', 'line'], 'word'));
 
   var locale = resolveLocale('breakiterator', locales, options);
   var resolved = Object.defineProperties({}, {
     requestedLocale: {value: locale.locale, writable: true},
     type: {value: internalOptions.type, writable: true},
     locale: {writable: true}
   });
 
-  var internalIterator = NativeJSCreateBreakIterator(locale.locale,
-                                                     internalOptions,
-                                                     resolved);
+  var internalIterator = %CreateBreakIterator(locale.locale,
+                                              internalOptions,
+                                              resolved);
 
   Object.defineProperty(iterator, 'iterator', {value: internalIterator});
   Object.defineProperty(iterator, 'resolved', {value: resolved});
   Object.defineProperty(iterator, '__initializedIntlObject',
                         {value: 'breakiterator'});
 
   return iterator;
 }
 
 
@@ skipping 67 matching lines @@
 %FunctionSetName(Intl.v8BreakIterator.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.v8BreakIterator.supportedLocalesOf);
 %SetNativeFlag(Intl.v8BreakIterator.supportedLocalesOf);
 
 
 /**
  * Adopts text to segment using the iterator. Old text, if present,
  * gets discarded.
  */
 function adoptText(iterator, text) {
-  native function NativeJSBreakIteratorAdoptText();
-  NativeJSBreakIteratorAdoptText(iterator.iterator, String(text));
+  %BreakIteratorAdoptText(iterator.iterator, String(text));
 }
 
 
 /**
  * Returns index of the first break in the string and moves current pointer.
  */
 function first(iterator) {
-  native function NativeJSBreakIteratorFirst();
-  return NativeJSBreakIteratorFirst(iterator.iterator);
+  return %BreakIteratorFirst(iterator.iterator);
 }
 
 
 /**
  * Returns the index of the next break and moves the pointer.
  */
 function next(iterator) {
-  native function NativeJSBreakIteratorNext();
-  return NativeJSBreakIteratorNext(iterator.iterator);
+  return %BreakIteratorNext(iterator.iterator);
 }
 
 
 /**
  * Returns index of the current break.
  */
 function current(iterator) {
-  native function NativeJSBreakIteratorCurrent();
-  return NativeJSBreakIteratorCurrent(iterator.iterator);
+  return %BreakIteratorCurrent(iterator.iterator);
 }
 
 
 /**
  * Returns type of the current break.
  */
 function breakType(iterator) {
-  native function NativeJSBreakIteratorBreakType();
-  return NativeJSBreakIteratorBreakType(iterator.iterator);
+  return %BreakIteratorBreakType(iterator.iterator);
 }
 
 
 addBoundMethod(Intl.v8BreakIterator, 'adoptText', adoptText, 1);
 addBoundMethod(Intl.v8BreakIterator, 'first', first, 0);
 addBoundMethod(Intl.v8BreakIterator, 'next', next, 0);
 addBoundMethod(Intl.v8BreakIterator, 'current', current, 0);
 addBoundMethod(Intl.v8BreakIterator, 'breakType', breakType, 0);