Remember zoom on a per-host basis....

chrome/common/common_param_traits.h

 // 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 <vector>
 
 #include "app/gfx/native_widget_types.h"
+#include "chrome/common/page_zoom.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/common/transport_dib.h"
 #include "ipc/ipc_message_utils.h"
 #include "net/base/upload_data.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;
@@ skipping 56 matching lines @@
   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));
+    WriteParam(m, 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));
+    intptr_t value;
+    if (!ReadParam(m, iter, &value))
+      return false;
+    *r = reinterpret_cast<param_type>(value);
+    return true;
   }
   static void Log(const param_type& p, std::wstring* l) {
-    l->append(StringPrintf(L"0x%X", p));
+    LogParam(reinterpret_cast<intptr_t>(p), l);
+  }
+};
+
+
+template <>
+struct ParamTraits<PageZoom::Function> {
+  typedef PageZoom::Function param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, static_cast<int>(p));
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    int value;
+    if (!ReadParam(m, iter, &value))
+      return false;
+    *r = static_cast<param_type>(value);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    LogParam(static_cast<int>(p), l);
   }
 };
 
 
 template <>
 struct ParamTraits<WindowOpenDisposition> {
   typedef WindowOpenDisposition param_type;
   static void Write(Message* m, const param_type& p) {
-    m->WriteInt(p);
+    WriteParam(m, static_cast<int>(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;
+    int value;
+    if (!ReadParam(m, iter, &value))
+      return false;
+    *r = static_cast<param_type>(value);
+    return true;
   }
   static void Log(const param_type& p, std::wstring* l) {
-    l->append(StringPrintf(L"%d", p));
+    LogParam(static_cast<int>(p), l);
   }
 };
 
 
 template <>
 struct ParamTraits<WebCursor> {
   typedef WebCursor param_type;
   static void Write(Message* m, const param_type& p) {
     p.Serialize(m);
   }
@@ skipping 193 matching lines @@
   }
   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_