content/public/common/common_param_traits.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 // This file is used to define IPC::ParamTraits<> specializations for a number
   6 // of types so that they can be serialized over IPC.  IPC::ParamTraits<>
   7 // specializations for basic types (like int and std::string) and types in the
   8 // 'base' project can be found in ipc/ipc_message_utils.h.  This file contains
   9 // specializations for types that are used by the content code, and which need
  10 // manual serialization code.  This is usually because they're not structs with
  11 // public members, or because the same type is being used in multiple
  12 // *_messages.h headers.
  13
  14 #ifndef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_H_
  15 #define CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_H_
  16
  17 #include <string>
  18
  19 #include "base/memory/ref_counted.h"
  20 #include "content/common/content_export.h"
  21 #include "content/public/common/common_param_traits_macros.h"
  22 #include "ipc/ipc_message_utils.h"
  23 #include "ui/gfx/native_widget_types.h"
  24 #include "ui/surface/transport_dib.h"
  25 #include "url/gurl.h"
  26 #include "url/origin.h"
  27
  28 class SkBitmap;
  29
  30 namespace content {
  31 class PageState;
  32 }
  33
  34 namespace gfx {
  35 class Point;
  36 class Rect;
  37 class RectF;
  38 class Size;
  39 class Vector2d;
  40 }  // namespace gfx
  41
  42 namespace net {
  43 class HostPortPair;
  44 class IPEndPoint;
  45 }
  46
  47 namespace IPC {
  48
  49 template <>
  50 struct CONTENT_EXPORT ParamTraits<GURL> {
  51   typedef GURL param_type;
  52   static void Write(Message* m, const param_type& p);
  53   static bool Read(const Message* m, PickleIterator* iter, param_type* p);
  54   static void Log(const param_type& p, std::string* l);
  55 };
  56
  57 template <>
  58 struct CONTENT_EXPORT ParamTraits<url::Origin> {
  59   typedef url::Origin param_type;
  60   static void Write(Message* m, const param_type& p);
  61   static bool Read(const Message* m, PickleIterator* iter, param_type* p);
  62   static void Log(const param_type& p, std::string* l);
  63 };
  64
  65 template<>
  66 struct CONTENT_EXPORT ParamTraits<net::HostPortPair> {
  67   typedef net::HostPortPair param_type;
  68   static void Write(Message* m, const param_type& p);
  69   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
  70   static void Log(const param_type& p, std::string* l);
  71 };
  72
  73 template <>
  74 struct CONTENT_EXPORT ParamTraits<net::IPEndPoint> {
  75   typedef net::IPEndPoint param_type;
  76   static void Write(Message* m, const param_type& p);
  77   static bool Read(const Message* m, PickleIterator* iter, param_type* p);
  78   static void Log(const param_type& p, std::string* l);
  79 };
  80
  81 template <>
  82 struct CONTENT_EXPORT ParamTraits<content::PageState> {
  83   typedef content::PageState param_type;
  84   static void Write(Message* m, const param_type& p);
  85   static bool Read(const Message* m, PickleIterator* iter, param_type* p);
  86   static void Log(const param_type& p, std::string* l);
  87 };
  88
  89 template <>
  90 struct CONTENT_EXPORT ParamTraits<gfx::Point> {
  91   typedef gfx::Point param_type;
  92   static void Write(Message* m, const param_type& p);
  93   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
  94   static void Log(const param_type& p, std::string* l);
  95 };
  96
  97 template <>
  98 struct CONTENT_EXPORT ParamTraits<gfx::PointF> {
  99   typedef gfx::PointF param_type;
 100   static void Write(Message* m, const param_type& p);
 101   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 102   static void Log(const param_type& p, std::string* l);
 103 };
 104
 105 template <>
 106 struct CONTENT_EXPORT ParamTraits<gfx::Size> {
 107   typedef gfx::Size param_type;
 108   static void Write(Message* m, const param_type& p);
 109   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 110   static void Log(const param_type& p, std::string* l);
 111 };
 112
 113 template <>
 114 struct CONTENT_EXPORT ParamTraits<gfx::SizeF> {
 115   typedef gfx::SizeF param_type;
 116   static void Write(Message* m, const param_type& p);
 117   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 118   static void Log(const param_type& p, std::string* l);
 119 };
 120
 121 template <>
 122 struct CONTENT_EXPORT ParamTraits<gfx::Vector2d> {
 123   typedef gfx::Vector2d param_type;
 124   static void Write(Message* m, const param_type& p);
 125   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 126   static void Log(const param_type& p, std::string* l);
 127 };
 128
 129 template <>
 130 struct CONTENT_EXPORT ParamTraits<gfx::Vector2dF> {
 131   typedef gfx::Vector2dF param_type;
 132   static void Write(Message* m, const param_type& p);
 133   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 134   static void Log(const param_type& p, std::string* l);
 135 };
 136
 137 template <>
 138 struct CONTENT_EXPORT ParamTraits<gfx::Rect> {
 139   typedef gfx::Rect param_type;
 140   static void Write(Message* m, const param_type& p);
 141   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 142   static void Log(const param_type& p, std::string* l);
 143 };
 144
 145 template <>
 146 struct CONTENT_EXPORT ParamTraits<gfx::RectF> {
 147   typedef gfx::RectF param_type;
 148   static void Write(Message* m, const param_type& p);
 149   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 150   static void Log(const param_type& p, std::string* l);
 151 };
 152
 153 template <>
 154 struct ParamTraits<gfx::NativeWindow> {
 155   typedef gfx::NativeWindow param_type;
 156   static void Write(Message* m, const param_type& p) {
 157 #if defined(OS_WIN)
 158     // HWNDs are always 32 bits on Windows, even on 64 bit systems.
 159     m->WriteUInt32(reinterpret_cast<uint32>(p));
 160 #else
 161     m->WriteData(reinterpret_cast<const char*>(&p), sizeof(p));
 162 #endif
 163   }
 164   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
 165 #if defined(OS_WIN)
 166     return m->ReadUInt32(iter, reinterpret_cast<uint32*>(r));
 167 #else
 168     const char *data;
 169     int data_size = 0;
 170     bool result = m->ReadData(iter, &data, &data_size);
 171     if (result && data_size == sizeof(gfx::NativeWindow)) {
 172       memcpy(r, data, sizeof(gfx::NativeWindow));
 173     } else {
 174       result = false;
 175       NOTREACHED();
 176     }
 177     return result;
 178 #endif
 179   }
 180   static void Log(const param_type& p, std::string* l) {
 181     l->append("<gfx::NativeWindow>");
 182   }
 183 };
 184
 185 #if defined(OS_WIN)
 186 template<>
 187 struct ParamTraits<TransportDIB::Id> {
 188   typedef TransportDIB::Id param_type;
 189   static void Write(Message* m, const param_type& p) {
 190     WriteParam(m, p.handle);
 191     WriteParam(m, p.sequence_num);
 192   }
 193   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
 194     return (ReadParam(m, iter, &r->handle) &&
 195             ReadParam(m, iter, &r->sequence_num));
 196   }
 197   static void Log(const param_type& p, std::string* l) {
 198     l->append("TransportDIB(");
 199     LogParam(p.handle, l);
 200     l->append(", ");
 201     LogParam(p.sequence_num, l);
 202     l->append(")");
 203   }
 204 };
 205 #endif
 206
 207 template <>
 208 struct CONTENT_EXPORT ParamTraits<SkBitmap> {
 209   typedef SkBitmap param_type;
 210   static void Write(Message* m, const param_type& p);
 211
 212   // Note: This function expects parameter |r| to be of type &SkBitmap since
 213   // r->SetConfig() and r->SetPixels() are called.
 214   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 215
 216   static void Log(const param_type& p, std::string* l);
 217 };
 218
 219 }  // namespace IPC
 220
 221 #endif  // CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_H_