Index: chrome/common/common_param_traits.h |
diff --git a/chrome/common/common_param_traits.h b/chrome/common/common_param_traits.h |
new file mode 100644 |
index 0000000000000000000000000000000000000000..c34d55f2b5048ebc04c6b0be4f33b68ea33185e2 |
--- /dev/null |
+++ b/chrome/common/common_param_traits.h |
@@ -0,0 +1,251 @@ |
+// Copyright (c) 2009 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 shared by more than one child process. |
+ |
+#ifndef CHROME_COMMON_COMMON_PARAM_TRAITS_H_ |
+#define CHROME_COMMON_COMMON_PARAM_TRAITS_H_ |
+ |
+#include "base/gfx/native_widget_types.h" |
+#include "chrome/common/thumbnail_score.h" |
+#include "chrome/common/transport_dib.h" |
+#include "ipc/ipc_message_utils.h" |
+#include "net/url_request/url_request_status.h" |
+#include "webkit/glue/webcursor.h" |
+#include "webkit/glue/window_open_disposition.h" |
+ |
+// Forward declarations. |
+class GURL; |
+class SkBitmap; |
+class DictionaryValue; |
+class ListValue; |
+ |
+namespace gfx { |
+class Point; |
+class Rect; |
+class Size; |
+} // namespace gfx |
+ |
+namespace webkit_glue { |
+struct WebApplicationInfo; |
+} // namespace webkit_glue |
+ |
+namespace IPC { |
+ |
+template <> |
+struct ParamTraits<SkBitmap> { |
+ typedef SkBitmap param_type; |
+ static void Write(Message* m, const param_type& p); |
+ |
+ // Note: This function expects parameter |r| to be of type &SkBitmap since |
+ // r->SetConfig() and r->SetPixels() are called. |
+ static bool Read(const Message* m, void** iter, param_type* r); |
+ |
+ static void Log(const param_type& p, std::wstring* l); |
+}; |
+ |
+ |
+template <> |
+struct ParamTraits<GURL> { |
+ typedef GURL param_type; |
+ static void Write(Message* m, const param_type& p); |
+ static bool Read(const Message* m, void** iter, param_type* p); |
+ static void Log(const param_type& p, std::wstring* l); |
+}; |
+ |
+ |
+template <> |
+struct ParamTraits<gfx::Point> { |
+ typedef gfx::Point param_type; |
+ static void Write(Message* m, const param_type& p); |
+ static bool Read(const Message* m, void** iter, param_type* r); |
+ static void Log(const param_type& p, std::wstring* l); |
+}; |
+ |
+template <> |
+struct ParamTraits<gfx::Rect> { |
+ typedef gfx::Rect param_type; |
+ static void Write(Message* m, const param_type& p); |
+ static bool Read(const Message* m, void** iter, param_type* r); |
+ static void Log(const param_type& p, std::wstring* l); |
+}; |
+ |
+template <> |
+struct ParamTraits<gfx::Size> { |
+ typedef gfx::Size param_type; |
+ static void Write(Message* m, const param_type& p); |
+ static bool Read(const Message* m, void** iter, param_type* r); |
+ static void Log(const param_type& p, std::wstring* l); |
+}; |
+ |
+template <> |
+struct ParamTraits<gfx::NativeWindow> { |
+ typedef gfx::NativeWindow param_type; |
+ static void Write(Message* m, const param_type& p) { |
+ m->WriteIntPtr(reinterpret_cast<intptr_t>(p)); |
+ } |
+ static bool Read(const Message* m, void** iter, param_type* r) { |
+ DCHECK_EQ(sizeof(param_type), sizeof(intptr_t)); |
+ return m->ReadIntPtr(iter, reinterpret_cast<intptr_t*>(r)); |
+ } |
+ static void Log(const param_type& p, std::wstring* l) { |
+ l->append(StringPrintf(L"0x%X", p)); |
+ } |
+}; |
+ |
+ |
+template <> |
+struct ParamTraits<WindowOpenDisposition> { |
+ typedef WindowOpenDisposition param_type; |
+ static void Write(Message* m, const param_type& p) { |
+ m->WriteInt(p); |
+ } |
+ static bool Read(const Message* m, void** iter, param_type* r) { |
+ int temp; |
+ bool res = m->ReadInt(iter, &temp); |
+ *r = static_cast<WindowOpenDisposition>(temp); |
+ return res; |
+ } |
+ static void Log(const param_type& p, std::wstring* l) { |
+ l->append(StringPrintf(L"%d", p)); |
+ } |
+}; |
+ |
+ |
+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, void** iter, param_type* r) { |
+ return r->Deserialize(m, iter); |
+ } |
+ static void Log(const param_type& p, std::wstring* l) { |
+ l->append(L"<WebCursor>"); |
+ } |
+}; |
+ |
+ |
+template <> |
+struct ParamTraits<webkit_glue::WebApplicationInfo> { |
+ typedef webkit_glue::WebApplicationInfo param_type; |
+ static void Write(Message* m, const param_type& p); |
+ static bool Read(const Message* m, void** iter, param_type* r); |
+ static void Log(const param_type& p, std::wstring* l); |
+}; |
+ |
+ |
+#if defined(OS_WIN) |
+template<> |
+struct ParamTraits<TransportDIB::Id> { |
+ typedef TransportDIB::Id param_type; |
+ static void Write(Message* m, const param_type& p) { |
+ WriteParam(m, p.handle); |
+ WriteParam(m, p.sequence_num); |
+ } |
+ static bool Read(const Message* m, void** iter, param_type* r) { |
+ return (ReadParam(m, iter, &r->handle) && |
+ ReadParam(m, iter, &r->sequence_num)); |
+ } |
+ static void Log(const param_type& p, std::wstring* l) { |
+ l->append(L"TransportDIB("); |
+ LogParam(p.handle, l); |
+ l->append(L", "); |
+ LogParam(p.sequence_num, l); |
+ l->append(L")"); |
+ } |
+}; |
+#endif |
+ |
+// Traits for URLRequestStatus |
+template <> |
+struct ParamTraits<URLRequestStatus> { |
+ typedef URLRequestStatus param_type; |
+ static void Write(Message* m, const param_type& p) { |
+ WriteParam(m, static_cast<int>(p.status())); |
+ WriteParam(m, p.os_error()); |
+ } |
+ static bool Read(const Message* m, void** iter, param_type* r) { |
+ int status, os_error; |
+ if (!ReadParam(m, iter, &status) || |
+ !ReadParam(m, iter, &os_error)) |
+ return false; |
+ r->set_status(static_cast<URLRequestStatus::Status>(status)); |
+ r->set_os_error(os_error); |
+ return true; |
+ } |
+ static void Log(const param_type& p, std::wstring* l) { |
+ std::wstring status; |
+ switch (p.status()) { |
+ case URLRequestStatus::SUCCESS: |
+ status = L"SUCCESS"; |
+ break; |
+ case URLRequestStatus::IO_PENDING: |
+ status = L"IO_PENDING "; |
+ break; |
+ case URLRequestStatus::HANDLED_EXTERNALLY: |
+ status = L"HANDLED_EXTERNALLY"; |
+ break; |
+ case URLRequestStatus::CANCELED: |
+ status = L"CANCELED"; |
+ break; |
+ case URLRequestStatus::FAILED: |
+ status = L"FAILED"; |
+ break; |
+ default: |
+ status = L"UNKNOWN"; |
+ break; |
+ } |
+ if (p.status() == URLRequestStatus::FAILED) |
+ l->append(L"("); |
+ |
+ LogParam(status, l); |
+ |
+ if (p.status() == URLRequestStatus::FAILED) { |
+ l->append(L", "); |
+ LogParam(p.os_error(), l); |
+ l->append(L")"); |
+ } |
+ } |
+}; |
+ |
+template<> |
+struct ParamTraits<ThumbnailScore> { |
+ typedef ThumbnailScore param_type; |
+ static void Write(Message* m, const param_type& p) { |
+ IPC::ParamTraits<double>::Write(m, p.boring_score); |
+ IPC::ParamTraits<bool>::Write(m, p.good_clipping); |
+ IPC::ParamTraits<bool>::Write(m, p.at_top); |
+ IPC::ParamTraits<base::Time>::Write(m, p.time_at_snapshot); |
+ } |
+ static bool Read(const Message* m, void** iter, param_type* r) { |
+ double boring_score; |
+ bool good_clipping, at_top; |
+ base::Time time_at_snapshot; |
+ if (!IPC::ParamTraits<double>::Read(m, iter, &boring_score) || |
+ !IPC::ParamTraits<bool>::Read(m, iter, &good_clipping) || |
+ !IPC::ParamTraits<bool>::Read(m, iter, &at_top) || |
+ !IPC::ParamTraits<base::Time>::Read(m, iter, &time_at_snapshot)) |
+ return false; |
+ |
+ r->boring_score = boring_score; |
+ r->good_clipping = good_clipping; |
+ r->at_top = at_top; |
+ r->time_at_snapshot = time_at_snapshot; |
+ return true; |
+ } |
+ static void Log(const param_type& p, std::wstring* l) { |
+ l->append(StringPrintf(L"(%f, %d, %d)", |
+ p.boring_score, p.good_clipping, p.at_top)); |
+ } |
+}; |
+ |
+} // namespace IPC |
+ |
+#endif // CHROME_COMMON_COMMON_PARAM_TRAITS_H_ |