Move Range code to gfx.

content/common/mac/attributed_string_coder.mm

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/common/mac/attributed_string_coder.h"
 
 #include <AppKit/AppKit.h>
 
 #include "base/logging.h"
 #include "base/mac/scoped_nsobject.h"
@@ skipping 11 matching lines @@
   // Create the return value.
   EncodedString* encoded_string =
       new EncodedString(base::SysNSStringToUTF16([str string]));
   // Iterate over all the attributes in the string.
   NSUInteger length = [str length];
   for (NSUInteger i = 0; i < length; ) {
     NSRange effective_range;
     NSDictionary* ns_attributes = [str attributesAtIndex:i
                                           effectiveRange:&effective_range];
     // Convert the attributes to IPC-friendly types.
-    FontAttribute attrs(ns_attributes, ui::Range(effective_range));
+    FontAttribute attrs(ns_attributes, gfx::Range(effective_range));
     // Only encode the attributes if the filtered set contains font information.
     if (attrs.ShouldEncode()) {
       encoded_string->attributes()->push_back(attrs);
     }
     // Advance the iterator to the position outside of the effective range.
     i = NSMaxRange(effective_range);
   }
   return encoded_string;
 }
 
 // static
 NSAttributedString* AttributedStringCoder::Decode(
     const AttributedStringCoder::EncodedString* str) {
   // Create the return value.
   NSString* plain_text = base::SysUTF16ToNSString(str->string());
   base::scoped_nsobject<NSMutableAttributedString> decoded_string(
       [[NSMutableAttributedString alloc] initWithString:plain_text]);
   // Iterate over all the encoded attributes, attaching each to the string.
   const std::vector<FontAttribute> attributes = str->attributes();
   for (std::vector<FontAttribute>::const_iterator it = attributes.begin();
        it != attributes.end(); ++it) {
     // Protect against ranges that are outside the range of the string.
-    const ui::Range& range = it->effective_range();
+    const gfx::Range& range = it->effective_range();
     if (range.GetMin() > [plain_text length] ||
         range.GetMax() > [plain_text length]) {
       continue;
     }
     [decoded_string addAttributes:it->ToAttributesDictionary()
                             range:range.ToNSRange()];
   }
   return [decoded_string.release() autorelease];
 }
 
 // Data Types //////////////////////////////////////////////////////////////////
 
 AttributedStringCoder::EncodedString::EncodedString(string16 string)
     : string_(string) {
 }
 
 AttributedStringCoder::EncodedString::EncodedString()
     : string_() {
 }
 
 AttributedStringCoder::EncodedString::~EncodedString() {
 }
 
 AttributedStringCoder::FontAttribute::FontAttribute(NSDictionary* dict,
-                                                    ui::Range effective_range)
+                                                    gfx::Range effective_range)
     : font_descriptor_(),
       effective_range_(effective_range) {
   NSFont* font = [dict objectForKey:NSFontAttributeName];
   if (font) {
     font_descriptor_ = FontDescriptor(font);
   }
 }
 
 AttributedStringCoder::FontAttribute::FontAttribute(FontDescriptor font,
-                                                    ui::Range range)
+                                                    gfx::Range range)
     : font_descriptor_(font),
       effective_range_(range) {
 }
 
 AttributedStringCoder::FontAttribute::FontAttribute()
     : font_descriptor_(),
       effective_range_() {
 }
 
 AttributedStringCoder::FontAttribute::~FontAttribute() {
@@ skipping 47 matching lines @@
   WriteParam(m, p.effective_range());
 }
 
 bool ParamTraits<AttributedStringCoder::FontAttribute>::Read(
     const Message* m, PickleIterator* iter, param_type* p) {
   bool success = true;
 
   FontDescriptor font;
   success &= ReadParam(m, iter, &font);
 
-  ui::Range range;
+  gfx::Range range;
   success &= ReadParam(m, iter, &range);
 
   if (success) {
     *p = AttributedStringCoder::FontAttribute(font, range);
   }
   return success;
 }
 
 void ParamTraits<AttributedStringCoder::FontAttribute>::Log(
     const param_type& p, std::string* l) {
 }
 
 }  // namespace IPC