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 namespace content {
  29 class PageState;
  30 }
  31
  32 namespace net {
  33 class HostPortPair;
  34 class IPEndPoint;
  35 }
  36
  37 namespace IPC {
  38
  39 template <>
  40 struct CONTENT_EXPORT ParamTraits<GURL> {
  41   typedef GURL param_type;
  42   static void Write(Message* m, const param_type& p);
  43   static bool Read(const Message* m, base::PickleIterator* iter, param_type* p);
  44   static void Log(const param_type& p, std::string* l);
  45 };
  46
  47 template <>
  48 struct CONTENT_EXPORT ParamTraits<url::Origin> {
  49   typedef url::Origin param_type;
  50   static void Write(Message* m, const param_type& p);
  51   static bool Read(const Message* m, base::PickleIterator* iter, param_type* p);
  52   static void Log(const param_type& p, std::string* l);
  53 };
  54
  55 template<>
  56 struct CONTENT_EXPORT ParamTraits<net::HostPortPair> {
  57   typedef net::HostPortPair param_type;
  58   static void Write(Message* m, const param_type& p);
  59   static bool Read(const Message* m, base::PickleIterator* iter, param_type* r);
  60   static void Log(const param_type& p, std::string* l);
  61 };
  62
  63 template <>
  64 struct CONTENT_EXPORT ParamTraits<net::IPEndPoint> {
  65   typedef net::IPEndPoint param_type;
  66   static void Write(Message* m, const param_type& p);
  67   static bool Read(const Message* m, base::PickleIterator* iter, param_type* p);
  68   static void Log(const param_type& p, std::string* l);
  69 };
  70
  71 template <>
  72 struct CONTENT_EXPORT ParamTraits<content::PageState> {
  73   typedef content::PageState param_type;
  74   static void Write(Message* m, const param_type& p);
  75   static bool Read(const Message* m, base::PickleIterator* iter, param_type* p);
  76   static void Log(const param_type& p, std::string* l);
  77 };
  78
  79 template <>
  80 struct ParamTraits<gfx::NativeWindow> {
  81   typedef gfx::NativeWindow param_type;
  82   static void Write(Message* m, const param_type& p) {
  83 #if defined(OS_WIN)
  84     // HWNDs are always 32 bits on Windows, even on 64 bit systems.
  85     m->WriteUInt32(reinterpret_cast<uint32>(p));
  86 #else
  87     m->WriteData(reinterpret_cast<const char*>(&p), sizeof(p));
  88 #endif
  89   }
  90   static bool Read(const Message* m, base::PickleIterator* iter,
  91                    param_type* r) {
  92 #if defined(OS_WIN)
  93     return iter->ReadUInt32(reinterpret_cast<uint32*>(r));
  94 #else
  95     const char *data;
  96     int data_size = 0;
  97     bool result = iter->ReadData(&data, &data_size);
  98     if (result && data_size == sizeof(gfx::NativeWindow)) {
  99       memcpy(r, data, sizeof(gfx::NativeWindow));
 100     } else {
 101       result = false;
 102       NOTREACHED();
 103     }
 104     return result;
 105 #endif
 106   }
 107   static void Log(const param_type& p, std::string* l) {
 108     l->append("<gfx::NativeWindow>");
 109   }
 110 };
 111
 112 }  // namespace IPC
 113
 114 #endif  // CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_H_