content/common/mac/attributed_string_coder.mm

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/common/mac/attributed_string_coder.h"
   6
   7 #include <AppKit/AppKit.h>
   8
   9 #include "base/logging.h"
  10 #include "base/mac/scoped_nsobject.h"
  11 #include "base/strings/sys_string_conversions.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "content/common/view_messages.h"
  14 #include "content/public/common/common_param_traits.h"
  15 #include "ipc/ipc_message_utils.h"
  16
  17 namespace mac {
  18
  19 // static
  20 const AttributedStringCoder::EncodedString* AttributedStringCoder::Encode(
  21     NSAttributedString* str) {
  22   // Create the return value.
  23   EncodedString* encoded_string =
  24       new EncodedString(base::SysNSStringToUTF16([str string]));
  25   // Iterate over all the attributes in the string.
  26   NSUInteger length = [str length];
  27   for (NSUInteger i = 0; i < length; ) {
  28     NSRange effective_range;
  29     NSDictionary* ns_attributes = [str attributesAtIndex:i
  30                                           effectiveRange:&effective_range];
  31     // Convert the attributes to IPC-friendly types.
  32     FontAttribute attrs(ns_attributes, gfx::Range(effective_range));
  33     // Only encode the attributes if the filtered set contains font information.
  34     if (attrs.ShouldEncode()) {
  35       encoded_string->attributes()->push_back(attrs);
  36     }
  37     // Advance the iterator to the position outside of the effective range.
  38     i = NSMaxRange(effective_range);
  39   }
  40   return encoded_string;
  41 }
  42
  43 // static
  44 NSAttributedString* AttributedStringCoder::Decode(
  45     const AttributedStringCoder::EncodedString* str) {
  46   // Create the return value.
  47   NSString* plain_text = base::SysUTF16ToNSString(str->string());
  48   base::scoped_nsobject<NSMutableAttributedString> decoded_string(
  49       [[NSMutableAttributedString alloc] initWithString:plain_text]);
  50   // Iterate over all the encoded attributes, attaching each to the string.
  51   const std::vector<FontAttribute> attributes = str->attributes();
  52   for (std::vector<FontAttribute>::const_iterator it = attributes.begin();
  53        it != attributes.end(); ++it) {
  54     // Protect against ranges that are outside the range of the string.
  55     const gfx::Range& range = it->effective_range();
  56     if (range.GetMin() > [plain_text length] ||
  57         range.GetMax() > [plain_text length]) {
  58       continue;
  59     }
  60     [decoded_string addAttributes:it->ToAttributesDictionary()
  61                             range:range.ToNSRange()];
  62   }
  63   return [decoded_string.release() autorelease];
  64 }
  65
  66 // Data Types //////////////////////////////////////////////////////////////////
  67
  68 AttributedStringCoder::EncodedString::EncodedString(base::string16 string)
  69     : string_(string) {
  70 }
  71
  72 AttributedStringCoder::EncodedString::EncodedString()
  73     : string_() {
  74 }
  75
  76 AttributedStringCoder::EncodedString::~EncodedString() {
  77 }
  78
  79 AttributedStringCoder::FontAttribute::FontAttribute(NSDictionary* dict,
  80                                                     gfx::Range effective_range)
  81     : font_descriptor_(),
  82       effective_range_(effective_range) {
  83   NSFont* font = [dict objectForKey:NSFontAttributeName];
  84   if (font) {
  85     font_descriptor_ = FontDescriptor(font);
  86   }
  87 }
  88
  89 AttributedStringCoder::FontAttribute::FontAttribute(FontDescriptor font,
  90                                                     gfx::Range range)
  91     : font_descriptor_(font),
  92       effective_range_(range) {
  93 }
  94
  95 AttributedStringCoder::FontAttribute::FontAttribute()
  96     : font_descriptor_(),
  97       effective_range_() {
  98 }
  99
 100 AttributedStringCoder::FontAttribute::~FontAttribute() {
 101 }
 102
 103 NSDictionary*
 104 AttributedStringCoder::FontAttribute::ToAttributesDictionary() const {
 105   DCHECK(ShouldEncode());
 106   NSFont* font = font_descriptor_.ToNSFont();
 107   if (!font)
 108     return [NSDictionary dictionary];
 109   return [NSDictionary dictionaryWithObject:font forKey:NSFontAttributeName];
 110 }
 111
 112 bool AttributedStringCoder::FontAttribute::ShouldEncode() const {
 113   return !font_descriptor_.font_name.empty();
 114 }
 115
 116 }  // namespace mac
 117
 118 // IPC ParamTraits specialization //////////////////////////////////////////////
 119
 120 namespace IPC {
 121
 122 using mac::AttributedStringCoder;
 123
 124 void ParamTraits<AttributedStringCoder::EncodedString>::Write(
 125     Message* m, const param_type& p) {
 126   WriteParam(m, p.string());
 127   WriteParam(m, p.attributes());
 128 }
 129
 130 bool ParamTraits<AttributedStringCoder::EncodedString>::Read(
 131     const Message* m,
 132     base::PickleIterator* iter,
 133     param_type* p) {
 134   bool success = true;
 135
 136   base::string16 result;
 137   success &= ReadParam(m, iter, &result);
 138   *p = AttributedStringCoder::EncodedString(result);
 139
 140   success &= ReadParam(m, iter, p->attributes());
 141   return success;
 142 }
 143
 144 void ParamTraits<AttributedStringCoder::EncodedString>::Log(
 145     const param_type& p, std::string* l) {
 146   l->append(base::UTF16ToUTF8(p.string()));
 147 }
 148
 149 void ParamTraits<AttributedStringCoder::FontAttribute>::Write(
 150     Message* m, const param_type& p) {
 151   WriteParam(m, p.font_descriptor());
 152   WriteParam(m, p.effective_range());
 153 }
 154
 155 bool ParamTraits<AttributedStringCoder::FontAttribute>::Read(
 156     const Message* m,
 157     base::PickleIterator* iter,
 158     param_type* p) {
 159   bool success = true;
 160
 161   FontDescriptor font;
 162   success &= ReadParam(m, iter, &font);
 163
 164   gfx::Range range;
 165   success &= ReadParam(m, iter, &range);
 166
 167   if (success) {
 168     *p = AttributedStringCoder::FontAttribute(font, range);
 169   }
 170   return success;
 171 }
 172
 173 void ParamTraits<AttributedStringCoder::FontAttribute>::Log(
 174     const param_type& p, std::string* l) {
 175 }
 176
 177 }  // namespace IPC