Revert "[Arguments] Merge (7442,7496] from bleeding_edge."

src/extensions/experimental/break-iterator.cc

 // Copyright 2011 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 28 matching lines @@
 icu::BreakIterator* BreakIterator::UnpackBreakIterator(
     v8::Handle<v8::Object> obj) {
   if (break_iterator_template_->HasInstance(obj)) {
     return static_cast<icu::BreakIterator*>(
         obj->GetPointerFromInternalField(0));
   }
 
   return NULL;
 }
 
-icu::UnicodeString* BreakIterator::ResetAdoptedText(
+UnicodeString* BreakIterator::ResetAdoptedText(
     v8::Handle<v8::Object> obj, v8::Handle<v8::Value> value) {
   // Get the previous value from the internal field.
-  icu::UnicodeString* text = static_cast<icu::UnicodeString*>(
+  UnicodeString* text = static_cast<UnicodeString*>(
       obj->GetPointerFromInternalField(1));
   delete text;
 
   // Assign new value to the internal pointer.
   v8::String::Value text_value(value);
-  text = new icu::UnicodeString(
+  text = new UnicodeString(
       reinterpret_cast<const UChar*>(*text_value), text_value.length());
   obj->SetPointerInInternalField(1, text);
 
   // Return new unicode string pointer.
   return text;
 }
 
 void BreakIterator::DeleteBreakIterator(v8::Persistent<v8::Value> object,
                                         void* param) {
   v8::Persistent<v8::Object> persistent_object =
       v8::Persistent<v8::Object>::Cast(object);
 
   // First delete the hidden C++ object.
   // Unpacking should never return NULL here. That would only happen if
   // this method is used as the weak callback for persistent handles not
   // pointing to a break iterator.
   delete UnpackBreakIterator(persistent_object);
 
-  delete static_cast<icu::UnicodeString*>(
+  delete static_cast<UnicodeString*>(
       persistent_object->GetPointerFromInternalField(1));
 
   // Then dispose of the persistent handle to JS object.
   persistent_object.Dispose();
 }
 
 // Throws a JavaScript exception.
 static v8::Handle<v8::Value> ThrowUnexpectedObjectError() {
   // Returns undefined, and schedules an exception to be thrown.
   return v8::ThrowException(v8::Exception::Error(
@@ skipping 49 matching lines @@
 }
 
 v8::Handle<v8::Value> BreakIterator::BreakIteratorBreakType(
     const v8::Arguments& args) {
   icu::BreakIterator* break_iterator = UnpackBreakIterator(args.Holder());
   if (!break_iterator) {
     return ThrowUnexpectedObjectError();
   }
 
   // TODO(cira): Remove cast once ICU fixes base BreakIterator class.
-  icu::RuleBasedBreakIterator* rule_based_iterator =
-      static_cast<icu::RuleBasedBreakIterator*>(break_iterator);
-  int32_t status = rule_based_iterator->getRuleStatus();
+  int32_t status =
+      static_cast<RuleBasedBreakIterator*>(break_iterator)->getRuleStatus();
   // Keep return values in sync with JavaScript BreakType enum.
   if (status >= UBRK_WORD_NONE && status < UBRK_WORD_NONE_LIMIT) {
     return v8::Int32::New(UBRK_WORD_NONE);
   } else if (status >= UBRK_WORD_NUMBER && status < UBRK_WORD_NUMBER_LIMIT) {
     return v8::Int32::New(UBRK_WORD_NUMBER);
   } else if (status >= UBRK_WORD_LETTER && status < UBRK_WORD_LETTER_LIMIT) {
     return v8::Int32::New(UBRK_WORD_LETTER);
   } else if (status >= UBRK_WORD_KANA && status < UBRK_WORD_KANA_LIMIT) {
     return v8::Int32::New(UBRK_WORD_KANA);
   } else if (status >= UBRK_WORD_IDEO && status < UBRK_WORD_IDEO_LIMIT) {
@@ skipping 81 matching lines @@
   // Make sure that the pointer to adopted text is NULL.
   wrapper->SetPointerInInternalField(1, NULL);
 
   // Make object handle weak so we can delete iterator once GC kicks in.
   wrapper.MakeWeak(NULL, DeleteBreakIterator);
 
   return wrapper;
 }
 
 } }  // namespace v8::internal