content/common/mac/attributed_string_coder.h

   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 #ifndef CONTENT_COMMON_MAC_ATTRIBUTED_STRING_CODER_H_
   6 #define CONTENT_COMMON_MAC_ATTRIBUTED_STRING_CODER_H_
   7
   8 #include <set>
   9
  10 #include "base/strings/string16.h"
  11 #include "content/common/content_export.h"
  12 #include "content/common/mac/font_descriptor.h"
  13 #include "ipc/ipc_message_utils.h"
  14 #include "ui/gfx/range/range.h"
  15
  16 #if __OBJC__
  17 @class NSAttributedString;
  18 @class NSDictionary;
  19 #else
  20 class NSAttributedString;
  21 class NSDictionary;
  22 #endif
  23
  24 namespace mac {
  25
  26 // This class will serialize the font information of an NSAttributedString so
  27 // that it can be sent over IPC. This class only stores the information of the
  28 // NSFontAttributeName. The motive is that of security: using NSArchiver and
  29 // friends to send objects from the renderer to the browser could lead to
  30 // deserialization of arbitrary objects. This class restricts serialization to
  31 // a specific object class and specific attributes of that object.
  32 class CONTENT_EXPORT AttributedStringCoder {
  33  public:
  34   // A C++ IPC-friendly representation of the NSFontAttributeName attribute
  35   // set.
  36   class FontAttribute {
  37    public:
  38     FontAttribute(NSDictionary* ns_attributes, gfx::Range effective_range);
  39     FontAttribute(FontDescriptor font, gfx::Range range);
  40     FontAttribute();
  41     ~FontAttribute();
  42
  43     // Creates an autoreleased NSDictionary that can be attached to an
  44     // NSAttributedString.
  45     NSDictionary* ToAttributesDictionary() const;
  46
  47     // Whether or not the attribute should be placed in the EncodedString. This
  48     // can return false, e.g. if the Cocoa-based constructor can't find any
  49     // information to encode.
  50     bool ShouldEncode() const;
  51
  52     // Accessors:
  53     FontDescriptor font_descriptor() const { return font_descriptor_; }
  54     gfx::Range effective_range() const { return effective_range_; }
  55
  56    private:
  57     FontDescriptor font_descriptor_;
  58     gfx::Range effective_range_;
  59   };
  60
  61   // A class that contains the pertinent information from an NSAttributedString,
  62   // which can be serialized over IPC.
  63   class EncodedString {
  64    public:
  65     explicit EncodedString(base::string16 string);
  66     EncodedString();
  67     ~EncodedString();
  68
  69     // Accessors:
  70     base::string16 string() const { return string_; }
  71     const std::vector<FontAttribute>& attributes() const {
  72       return attributes_;
  73     }
  74     std::vector<FontAttribute>* attributes() { return &attributes_; }
  75
  76    private:
  77     // The plain-text string.
  78     base::string16 string_;
  79     // The set of attributes that style |string_|.
  80     std::vector<FontAttribute> attributes_;
  81   };
  82
  83   // Takes an NSAttributedString, extracts the pertinent attributes, and returns
  84   // an object that represents it. Caller owns the result.
  85   static const EncodedString* Encode(NSAttributedString* str);
  86
  87   // Returns an autoreleased NSAttributedString from an encoded representation.
  88   static NSAttributedString* Decode(const EncodedString* str);
  89
  90  private:
  91   AttributedStringCoder();
  92 };
  93
  94 }  // namespace mac
  95
  96 // IPC ParamTraits specialization //////////////////////////////////////////////
  97
  98 namespace IPC {
  99
 100 template <>
 101 struct ParamTraits<mac::AttributedStringCoder::EncodedString> {
 102   typedef mac::AttributedStringCoder::EncodedString param_type;
 103   static void Write(Message* m, const param_type& p);
 104   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 105   static void Log(const param_type& p, std::string* l);
 106 };
 107
 108 template <>
 109 struct ParamTraits<mac::AttributedStringCoder::FontAttribute> {
 110   typedef mac::AttributedStringCoder::FontAttribute param_type;
 111   static void Write(Message* m, const param_type& p);
 112   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 113   static void Log(const param_type& p, std::string* l);
 114 };
 115
 116 }  // namespace IPC
 117
 118 #endif  // CONTENT_COMMON_MAC_ATTRIBUTED_STRING_CODER_H_