FBTF: Move individual XXXMsg_Params structs to a new file.

chrome/common/common_param_traits.cc

 // Copyright (c) 2010 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.
 
 #include "chrome/common/common_param_traits.h"
 
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/content_settings.h"
+#include "chrome/common/geoposition.h"
 #include "chrome/common/thumbnail_score.h"
 #include "gfx/rect.h"
 #include "googleurl/src/gurl.h"
+#include "net/base/upload_data.h"
 #include "printing/native_metafile.h"
 #include "printing/page_range.h"
 
 #ifndef EXCLUDE_SKIA_DEPENDENCIES
 #include "third_party/skia/include/core/SkBitmap.h"
 #endif
 #include "webkit/glue/dom_operations.h"
 #include "webkit/glue/password_form.h"
 
 namespace IPC {
@@ skipping 286 matching lines @@
 
   LogParam(status, l);
 
   if (p.status() == URLRequestStatus::FAILED) {
     l->append(", ");
     LogParam(p.os_error(), l);
     l->append(")");
   }
 }
 
+// Only the net::UploadData ParamTraits<> definition needs this definition, so
+// keep this in the implementation file so we can forward declare UploadData in
+// the header.
+template <>
+struct ParamTraits<net::UploadData::Element> {
+  typedef net::UploadData::Element param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, static_cast<int>(p.type()));
+    if (p.type() == net::UploadData::TYPE_BYTES) {
+      m->WriteData(&p.bytes()[0], static_cast<int>(p.bytes().size()));
+    } else {
+      WriteParam(m, p.file_path());
+      WriteParam(m, p.file_range_offset());
+      WriteParam(m, p.file_range_length());
+      WriteParam(m, p.expected_file_modification_time());
+    }
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    int type;
+    if (!ReadParam(m, iter, &type))
+      return false;
+    if (type == net::UploadData::TYPE_BYTES) {
+      const char* data;
+      int len;
+      if (!m->ReadData(iter, &data, &len))
+        return false;
+      r->SetToBytes(data, len);
+    } else {
+      DCHECK(type == net::UploadData::TYPE_FILE);
+      FilePath file_path;
+      uint64 offset, length;
+      base::Time expected_modification_time;
+      if (!ReadParam(m, iter, &file_path))
+        return false;
+      if (!ReadParam(m, iter, &offset))
+        return false;
+      if (!ReadParam(m, iter, &length))
+        return false;
+      if (!ReadParam(m, iter, &expected_modification_time))
+        return false;
+      r->SetToFilePathRange(file_path, offset, length,
+                            expected_modification_time);
+    }
+    return true;
+  }
+  static void Log(const param_type& p, std::string* l) {
+    l->append("<net::UploadData::Element>");
+  }
+};
+
+void ParamTraits<scoped_refptr<net::UploadData> >::Write(Message* m,
+                                                         const param_type& p) {
+  WriteParam(m, p.get() != NULL);
+  if (p) {
+    WriteParam(m, *p->elements());
+    WriteParam(m, p->identifier());
+  }
+}
+
+bool ParamTraits<scoped_refptr<net::UploadData> >::Read(const Message* m,
+                                                        void** iter,
+                                                        param_type* r) {
+  bool has_object;
+  if (!ReadParam(m, iter, &has_object))
+    return false;
+  if (!has_object)
+    return true;
+  std::vector<net::UploadData::Element> elements;
+  if (!ReadParam(m, iter, &elements))
+    return false;
+  int64 identifier;
+  if (!ReadParam(m, iter, &identifier))
+    return false;
+  *r = new net::UploadData;
+  (*r)->swap_elements(&elements);
+  (*r)->set_identifier(identifier);
+  return true;
+}
+
+void ParamTraits<scoped_refptr<net::UploadData> >::Log(const param_type& p,
+                                                       std::string* l) {
+  l->append("<net::UploadData>");
+}
+
 void ParamTraits<ThumbnailScore>::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);
 }
 
 bool ParamTraits<ThumbnailScore>::Read(const Message* m, void** iter,
                                        param_type* r) {
   double boring_score;
@@ skipping 10 matching lines @@
   r->at_top = at_top;
   r->time_at_snapshot = time_at_snapshot;
   return true;
 }
 
 void ParamTraits<ThumbnailScore>::Log(const param_type& p, std::string* l) {
   l->append(StringPrintf("(%f, %d, %d)",
                          p.boring_score, p.good_clipping, p.at_top));
 }
 
-void ParamTraits<Geoposition::ErrorCode>::Write(
-    Message* m, const Geoposition::ErrorCode& p) {
-  int error_code = p;
-  WriteParam(m, error_code);
-}
-
-bool ParamTraits<Geoposition::ErrorCode>::Read(
-      const Message* m, void** iter, Geoposition::ErrorCode* p) {
-  int error_code_param = 0;
-  bool ret = ReadParam(m, iter, &error_code_param);
-  *p = static_cast<Geoposition::ErrorCode>(error_code_param);
-  return ret;
-}
-
-void ParamTraits<Geoposition::ErrorCode>::Log(
-    const Geoposition::ErrorCode& p, std::string* l) {
-  int error_code = p;
-  l->append(StringPrintf("<Geoposition::ErrorCode>%d", error_code));
-}
+template <>
+struct ParamTraits<Geoposition::ErrorCode> {
+  typedef Geoposition::ErrorCode param_type;
+  static void Write(Message* m, const param_type& p) {
+    int error_code = p;
+    WriteParam(m, error_code);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    int error_code_param = 0;
+    bool ret = ReadParam(m, iter, &error_code_param);
+    *p = static_cast<Geoposition::ErrorCode>(error_code_param);
+    return ret;
+  }
+  static void Log(const param_type& p, std::string* l)  {
+    int error_code = p;
+    l->append(StringPrintf("<Geoposition::ErrorCode>%d", error_code));
+  }
+};
 
 void ParamTraits<Geoposition>::Write(Message* m, const Geoposition& p) {
   WriteParam(m, p.latitude);
   WriteParam(m, p.longitude);
   WriteParam(m, p.accuracy);
   WriteParam(m, p.altitude);
   WriteParam(m, p.altitude_accuracy);
   WriteParam(m, p.speed);
   WriteParam(m, p.heading);
   WriteParam(m, p.timestamp);
@@ skipping 111 matching lines @@
          p->Init(&buffer.front(), static_cast<uint32>(buffer.size()));
 #endif  // defined(OS_WIN)
 }
 
 void ParamTraits<printing::NativeMetafile>::Log(
     const param_type& p, std::string* l) {
   l->append("<printing::NativeMetafile>");
 }
 
 }  // namespace IPC