Split net::UploadData into two: for IPC and for upload handling

content/public/common/common_param_traits.cc

 // 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.
 
 #include "content/public/common/common_param_traits.h"
 
 #include "content/public/common/content_constants.h"
 #include "content/public/common/referrer.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/range/range.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_f.h"
+#include "webkit/glue/resource_request_body.h"
 
 namespace {
 
 struct SkBitmap_Data {
   // The configuration for the bitmap (bits per pixel, etc).
   SkBitmap::Config fConfig;
 
   // The width of the bitmap in pixels.
   uint32 fWidth;
 
@@ skipping 94 matching lines @@
     l->append(", ");
     LogParam(p.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> {

[darin (slow to review), 2012/08/15 17:49:55]

Who still relies on UploadData serialization?

[kinuko, 2012/08/16 07:13:01]

Looks like AutomationURLRequest still sends this over IPC, which seems to be
used for ChromeFrame to intercept URLRequest. I was looking into if I could kill
the code but it's not obvious to me :(  This worries me since it may hinder our
long-term plan.

One uncomfortable option is maybe to have a specialized ctor which creates
ResourceRequestBody back from UploadData (or UploadDataStream in the future) for
serialization?

[kinuko, 2012/08/16 08:14:59]

...or if we could intercept before we create URLRequest (like in RDH) for
ChromeFrame.  I'm not sure how stupid this idea could be though.

   typedef net::UploadData::Element param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.type()));
     switch (p.type()) {
       case net::UploadData::TYPE_BYTES: {
-        m->WriteData(&p.bytes()[0], static_cast<int>(p.bytes().size()));
+        m->WriteData(p.bytes(), static_cast<int>(p.bytes_length()));
         break;
       }
       case net::UploadData::TYPE_CHUNK: {
         std::string chunk_length = StringPrintf(
-            "%X\r\n", static_cast<unsigned int>(p.bytes().size()));
+            "%X\r\n", static_cast<unsigned int>(p.bytes_length()));
         std::vector<char> bytes;
         bytes.insert(bytes.end(), chunk_length.data(),
                      chunk_length.data() + chunk_length.length());
-        const char* data = &p.bytes()[0];
-        bytes.insert(bytes.end(), data, data + p.bytes().size());
+        const char* data = p.bytes();
+        bytes.insert(bytes.end(), data, data + p.bytes_length());
         const char* crlf = "\r\n";
         bytes.insert(bytes.end(), crlf, crlf + strlen(crlf));
         if (p.is_last_chunk()) {
           const char* end_of_data = "0\r\n\r\n";
           bytes.insert(bytes.end(), end_of_data,
                        end_of_data + strlen(end_of_data));
         }
         m->WriteData(&bytes[0], static_cast<int>(bytes.size()));
         // If this element is part of a chunk upload then send over information
         // indicating if this is the last chunk.
         WriteParam(m, p.is_last_chunk());
         break;
       }
-      case net::UploadData::TYPE_FILE: {
+      default: {
+        DCHECK(p.type() == net::UploadData::TYPE_FILE);
         WriteParam(m, p.file_path());
         WriteParam(m, p.file_range_offset());
         WriteParam(m, p.file_range_length());
         WriteParam(m, p.expected_file_modification_time());
         break;
       }
-      default: {
-        WriteParam(m, p.blob_url());
-        break;
-      }
     }
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
     int type;
     if (!ReadParam(m, iter, &type))
       return false;
     switch (type) {
       case net::UploadData::TYPE_BYTES: {
         const char* data;
         int len;
@@ skipping 10 matching lines @@
         r->SetToBytes(data, len);
         // If this element is part of a chunk upload then we need to explicitly
         // set the type of the element and whether it is the last chunk.
         bool is_last_chunk = false;
         if (!ReadParam(m, iter, &is_last_chunk))
           return false;
         r->set_type(net::UploadData::TYPE_CHUNK);
         r->set_is_last_chunk(is_last_chunk);
         break;
       }
-      case net::UploadData::TYPE_FILE: {
+      default: {
+        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);
         break;
       }
-      default: {
-        DCHECK(type == net::UploadData::TYPE_BLOB);
-        GURL blob_url;
-        if (!ReadParam(m, iter, &blob_url))
-          return false;
-        r->SetToBlobUrl(blob_url);
-        break;
-      }
     }
     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) {
@@ skipping 27 matching lines @@
   (*r)->set_identifier(identifier);
   (*r)->set_is_chunked(is_chunked);
   return true;
 }
 
 void ParamTraits<scoped_refptr<net::UploadData> >::Log(const param_type& p,
                                                        std::string* l) {
   l->append("<net::UploadData>");
 }
 
+template <>
+struct ParamTraits<webkit_glue::ResourceRequestBody::Element> {
+  typedef webkit_glue::ResourceRequestBody::Element param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, static_cast<int>(p.type()));
+    switch (p.type()) {
+      case webkit_glue::ResourceRequestBody::TYPE_BYTES: {
+        m->WriteData(p.bytes(), static_cast<int>(p.bytes_length()));
+        break;
+      }
+      case webkit_glue::ResourceRequestBody::TYPE_FILE: {
+        WriteParam(m, p.file_path());
+        WriteParam(m, p.file_range_offset());
+        WriteParam(m, p.file_range_length());
+        WriteParam(m, p.expected_file_modification_time());
+        break;
+      }
+      default: {
+        WriteParam(m, p.blob_url());
+        break;
+      }
+    }
+  }
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
+    int type;
+    if (!ReadParam(m, iter, &type))
+      return false;
+    switch (type) {
+      case webkit_glue::ResourceRequestBody::TYPE_BYTES: {
+        const char* data;
+        int len;
+        if (!m->ReadData(iter, &data, &len))
+          return false;
+        r->SetToBytes(data, len);
+        break;
+      }
+      case webkit_glue::ResourceRequestBody::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);
+        break;
+      }
+      default: {
+        DCHECK(type == webkit_glue::ResourceRequestBody::TYPE_BLOB);
+        GURL blob_url;
+        if (!ReadParam(m, iter, &blob_url))
+          return false;
+        r->SetToBlobUrl(blob_url);
+        break;
+      }
+    }
+    return true;
+  }
+  static void Log(const param_type& p, std::string* l) {
+    l->append("<webkit_glue::ResourceRequestBody::Element>");
+  }
+};
+
+void ParamTraits<scoped_refptr<webkit_glue::ResourceRequestBody> >::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<webkit_glue::ResourceRequestBody> >::Read(
+    const Message* m,
+    PickleIterator* iter,
+    param_type* r) {
+  bool has_object;
+  if (!ReadParam(m, iter, &has_object))
+    return false;
+  if (!has_object)
+    return true;
+  std::vector<webkit_glue::ResourceRequestBody::Element> elements;
+  if (!ReadParam(m, iter, &elements))
+    return false;
+  int64 identifier;
+  if (!ReadParam(m, iter, &identifier))
+    return false;
+  *r = new webkit_glue::ResourceRequestBody;
+  (*r)->swap_elements(&elements);
+  (*r)->set_identifier(identifier);
+  return true;
+}
+
+void ParamTraits<scoped_refptr<webkit_glue::ResourceRequestBody> >::Log(
+    const param_type& p, std::string* l) {
+  l->append("<webkit_glue::ResourceRequestBody>");
+}
+
 void ParamTraits<net::HostPortPair>::Write(Message* m, const param_type& p) {
   WriteParam(m, p.host());
   WriteParam(m, p.port());
 }
 
 bool ParamTraits<net::HostPortPair>::Read(const Message* m,
                                           PickleIterator* iter,
                                           param_type* r) {
   std::string host;
   uint16 port;
@@ skipping 245 matching lines @@
 #undef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_MACROS_H_
 #include "content/public/common/common_param_traits_macros.h"
 }  // namespace IPC
 
 // Generate param traits log methods.
 #include "ipc/param_traits_log_macros.h"
 namespace IPC {
 #undef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_MACROS_H_
 #include "content/public/common/common_param_traits_macros.h"
 }  // namespace IPC