diff options
author | jam@chromium.org <jam@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2012-09-25 15:04:22 +0000 |
---|---|---|
committer | jam@chromium.org <jam@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2012-09-25 15:04:22 +0000 |
commit | 9d8ea308b93fdd1b78cded9e604268e9752e2909 (patch) | |
tree | 5a4e49524786f0fb259726e0f92bb1fd64ed01ac /content/common/content_param_traits.h | |
parent | 20cd74f9317b37e8faee699dfdf7dcf2a7eea12c (diff) | |
download | chromium_src-9d8ea308b93fdd1b78cded9e604268e9752e2909.zip chromium_src-9d8ea308b93fdd1b78cded9e604268e9752e2909.tar.gz chromium_src-9d8ea308b93fdd1b78cded9e604268e9752e2909.tar.bz2 |
Cleanup the IPC param traits structure:
-traits that are only used by chrome should be in chrome
-traits that aren't used by chrome shouldn't be in content/public
-use macros for serialization where possible
-traits that are only used by one message file should just be listed in it
-get rid of webkit_param_traits since it's not needed anymore. It was added as a hack to keep npchrome_frame.dll's size small by giving a hint to the MSVS linker, but now that there's more split between the message files because of the content split it's not necessary anymore. I've verified that npchrome_frame.dll's size (Release, non-component) size doesn't change.
Review URL: https://codereview.chromium.org/10980010
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@158570 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat (limited to 'content/common/content_param_traits.h')
-rw-r--r-- | content/common/content_param_traits.h | 157 |
1 files changed, 157 insertions, 0 deletions
diff --git a/content/common/content_param_traits.h b/content/common/content_param_traits.h new file mode 100644 index 0000000..9e7bd44 --- /dev/null +++ b/content/common/content_param_traits.h @@ -0,0 +1,157 @@ +// 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. + +// This file is used to define IPC::ParamTraits<> specializations for a number +// of types so that they can be serialized over IPC. IPC::ParamTraits<> +// specializations for basic types (like int and std::string) and types in the +// 'base' project can be found in ipc/ipc_message_utils.h. This file contains +// specializations for types that are used by the content code, and which need +// manual serialization code. This is usually because they're not structs with +// public members, or because the same type is being used in multiple +// *_messages.h headers. + +#ifndef CONTENT_COMMON_CONTENT_PARAM_TRAITS_H_ +#define CONTENT_COMMON_CONTENT_PARAM_TRAITS_H_ + +#include "content/common/content_param_traits_macros.h" +#include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h" +#include "webkit/glue/npruntime_util.h" +#include "webkit/glue/webcursor.h" + +namespace net { +class IPEndPoint; +} + +namespace ui { +class Range; +} + +// Define the NPVariant_Param struct and its enum here since it needs manual +// serialization code. +enum NPVariant_ParamEnum { + NPVARIANT_PARAM_VOID, + NPVARIANT_PARAM_NULL, + NPVARIANT_PARAM_BOOL, + NPVARIANT_PARAM_INT, + NPVARIANT_PARAM_DOUBLE, + NPVARIANT_PARAM_STRING, + // Used when when the NPObject is running in the caller's process, so we + // create an NPObjectProxy in the other process. + NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID, + // Used when the NPObject we're sending is running in the callee's process + // (i.e. we have an NPObjectProxy for it). In that case we want the callee + // to just use the raw pointer. + NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID, +}; + +struct NPVariant_Param { + NPVariant_Param(); + ~NPVariant_Param(); + + NPVariant_ParamEnum type; + bool bool_value; + int int_value; + double double_value; + std::string string_value; + int npobject_routing_id; +}; + +struct NPIdentifier_Param { + NPIdentifier_Param(); + ~NPIdentifier_Param(); + + NPIdentifier identifier; +}; + +namespace IPC { + +template <> +struct ParamTraits<net::IPEndPoint> { + typedef net::IPEndPoint param_type; + static void Write(Message* m, const param_type& p); + static bool Read(const Message* m, PickleIterator* iter, param_type* p); + static void Log(const param_type& p, std::string* l); +}; + +template <> +struct ParamTraits<NPVariant_Param> { + typedef NPVariant_Param param_type; + static void Write(Message* m, const param_type& p); + static bool Read(const Message* m, PickleIterator* iter, param_type* r); + static void Log(const param_type& p, std::string* l); +}; + +template <> +struct ParamTraits<NPIdentifier_Param> { + typedef NPIdentifier_Param param_type; + static void Write(Message* m, const param_type& p); + static bool Read(const Message* m, PickleIterator* iter, param_type* r); + static void Log(const param_type& p, std::string* l); +}; + +template <> +struct ParamTraits<ui::Range> { + typedef ui::Range param_type; + static void Write(Message* m, const param_type& p); + static bool Read(const Message* m, PickleIterator* iter, param_type* r); + static void Log(const param_type& p, std::string* l); +}; + +template <> +struct ParamTraits<WebCursor> { + typedef WebCursor param_type; + static void Write(Message* m, const param_type& p) { + p.Serialize(m); + } + static bool Read(const Message* m, PickleIterator* iter, param_type* r) { + return r->Deserialize(iter); + } + static void Log(const param_type& p, std::string* l) { + l->append("<WebCursor>"); + } +}; + +typedef const WebKit::WebInputEvent* WebInputEventPointer; +template <> +struct ParamTraits<WebInputEventPointer> { + typedef WebInputEventPointer param_type; + static void Write(Message* m, const param_type& p) { + m->WriteData(reinterpret_cast<const char*>(p), p->size); + } + // Note: upon read, the event has the lifetime of the message. + static bool Read(const Message* m, PickleIterator* iter, param_type* r) { + const char* data; + int data_length; + if (!m->ReadData(iter, &data, &data_length)) { + NOTREACHED(); + return false; + } + if (data_length < static_cast<int>(sizeof(WebKit::WebInputEvent))) { + NOTREACHED(); + return false; + } + param_type event = reinterpret_cast<param_type>(data); + // Check that the data size matches that of the event (we check the latter + // in the delegate). + if (data_length != static_cast<int>(event->size)) { + NOTREACHED(); + return false; + } + *r = event; + return true; + } + static void Log(const param_type& p, std::string* l) { + l->append("("); + LogParam(p->size, l); + l->append(", "); + LogParam(p->type, l); + l->append(", "); + LogParam(p->timeStampSeconds, l); + l->append(")"); + } +}; + +} // namespace IPC + +#endif // CONTENT_COMMON_CONTENT_PARAM_TRAITS_H_ |