Stop serializing WebString over IPC. The new rule is that only POD (plain ol...

chrome/common/webkit_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 contains ParamTraits templates to support serialization of WebKit
 // data types over IPC.
+//
+// NOTE: IT IS IMPORTANT THAT ONLY POD (plain old data) TYPES ARE SERIALIZED.
+//
+// There are several reasons for this restrictions:
+//
+//   o  We don't want inclusion of this file to imply linking to WebKit code.
+//
+//   o  Many WebKit structures are not thread-safe.  WebString, for example,
+//      contains a reference counted buffer, which does not use thread-safe
+//      reference counting.  If we allowed serializing WebString, then we may run
+//      the risk of introducing subtle thread-safety bugs if people passed a
+//      WebString across threads via PostTask(NewRunnableMethod(...)).
+//
+//   o  The WebKit API has redundant types for strings, and we should avoid using
+//      those beyond code that interfaces with the WebKit API.
 
 #ifndef CHROME_COMMON_WEBKIT_PARAM_TRAITS_H_
 #define CHROME_COMMON_WEBKIT_PARAM_TRAITS_H_
 
 #include "chrome/common/ipc_message_utils.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebCache.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebConsoleMessage.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebFindInPageRequest.h"
+#include "third_party/WebKit/WebKit/chromium/public/WebFindOptions.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebScreenInfo.h"
 
 namespace IPC {
 
 template <>
 struct ParamTraits<WebKit::WebRect> {
   typedef WebKit::WebRect param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.x);
@@ skipping 48 matching lines @@
     LogParam(p.isMonochrome, l);
     l->append(L", ");
     LogParam(p.rect, l);
     l->append(L", ");
     LogParam(p.availableRect, l);
     l->append(L")");
   }
 };
 
 template <>
-struct ParamTraits<WebKit::WebString> {
-  typedef WebKit::WebString param_type;
-  static void Write(Message* m, const param_type& p) {
-    m->WriteData(reinterpret_cast<const char*>(p.data()),
-                 static_cast<int>(p.length() * sizeof(WebKit::WebUChar)));
-  }
-  static bool Read(const Message* m, void** iter, param_type* p) {
-    const char* data;
-    int data_len;
-    if (!m->ReadData(iter, &data, &data_len))
-      return false;
-    p->assign(reinterpret_cast<const WebKit::WebUChar*>(data),
-              static_cast<size_t>(data_len / sizeof(WebKit::WebUChar)));
-    return true;
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(UTF16ToWideHack(p));
-  }
-};
-
-template <>
 struct ParamTraits<WebKit::WebConsoleMessage::Level> {
   typedef WebKit::WebConsoleMessage::Level 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<WebKit::WebConsoleMessage> {
-  typedef WebKit::WebConsoleMessage param_type;
+struct ParamTraits<WebKit::WebFindOptions> {
+  typedef WebKit::WebFindOptions param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.level);
-    WriteParam(m, p.text);
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    return
-      ReadParam(m, iter, &r->level) &&
-      ReadParam(m, iter, &r->text);
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(L"(");
-    LogParam(p.level, l);
-    l->append(L", ");
-    LogParam(p.text, l);
-    l->append(L")");
-  }
-};
-
-template <>
-struct ParamTraits<WebKit::WebFindInPageRequest> {
-  typedef WebKit::WebFindInPageRequest param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.identifier);
-    WriteParam(m, p.text);
     WriteParam(m, p.forward);
     WriteParam(m, p.matchCase);
     WriteParam(m, p.findNext);
   }
   static bool Read(const Message* m, void** iter, param_type* p) {
     return
-      ReadParam(m, iter, &p->identifier) &&
-      ReadParam(m, iter, &p->text) &&
       ReadParam(m, iter, &p->forward) &&
       ReadParam(m, iter, &p->matchCase) &&
       ReadParam(m, iter, &p->findNext);
   }
   static void Log(const param_type& p, std::wstring* l) {
-    l->append(L"<FindInPageRequest>");
+    l->append(L"(");
+    LogParam(p.forward, l);
+    l->append(L", ");
+    LogParam(p.matchCase, l);
+    l->append(L", ");
+    LogParam(p.findNext, l);
+    l->append(L")");
   }
 };
 
 template <>
 struct ParamTraits<WebKit::WebInputEvent::Type> {
   typedef WebKit::WebInputEvent::Type param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteInt(p);
   }
   static bool Read(const Message* m, void** iter, param_type* p) {
     int type;
     if (!m->ReadInt(iter, &type))
       return false;
     *p = static_cast<WebKit::WebInputEvent::Type>(type);
     return true;
   }
   static void Log(const param_type& p, std::wstring* l) {
-    std::wstring type;
+    const wchar_t* type;
     switch (p) {
      case WebKit::WebInputEvent::MouseDown:
       type = L"MouseDown";
       break;
      case WebKit::WebInputEvent::MouseUp:
       type = L"MouseUp";
       break;
      case WebKit::WebInputEvent::MouseMove:
       type = L"MouseMove";
       break;
@@ skipping 12 matching lines @@
      case WebKit::WebInputEvent::KeyDown:
       type = L"KeyDown";
       break;
      case WebKit::WebInputEvent::KeyUp:
       type = L"KeyUp";
       break;
      default:
       type = L"None";
       break;
     }
-    LogParam(type, l);
+    LogParam(std::wstring(type), l);
   }
 };
 
-// Traits for WebKit::WebCache::UsageStats
 template <>
 struct ParamTraits<WebKit::WebCache::UsageStats> {
   typedef WebKit::WebCache::UsageStats param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.minDeadCapacity);
     WriteParam(m, p.maxDeadCapacity);
     WriteParam(m, p.capacity);
     WriteParam(m, p.liveSize);
     WriteParam(m, p.deadSize);
   }
@@ skipping 59 matching lines @@
     LogParam(p.scripts, l);
     LogParam(p.xslStyleSheets, l);
     LogParam(p.fonts, l);
     l->append(L"</WebCoreStats>");
   }
 };
 
 }  // namespace IPC
 
 #endif  // CHROME_COMMON_WEBKIT_PARAM_TRAITS_H_