net: Change type of UploadData::elements from std::vector to ScopedVector

chrome/common/automation_messages.cc

Index: chrome/common/automation_messages.cc
diff --git a/chrome/common/automation_messages.cc b/chrome/common/automation_messages.cc
index 8aadecef7a58d0ed8ec85d4a68739a95297c95fe..061e7b4552debab89fd269863425c092c15a343f 100644
--- a/chrome/common/automation_messages.cc
+++ b/chrome/common/automation_messages.cc
@@ -221,11 +221,41 @@ struct ParamTraits<net::UploadElement> {
   }
 };
 
+template<>
+struct ParamTraits<ScopedVector<net::UploadElement> > {

[jam, 2012/11/09 17:38:48]

can you add a param traits for ScopedVector that's templatized for the type,
i.e. similar to what we do for std::vector:
http://code.google.com/searchframe#OAMlx_jo-ck/src/ipc/ipc_message_utils.h&ex...

that way if anyone else wants to send a ScopedVector, they don't have to write
their own traits

[hashimoto, 2012/11/10 09:34:52]

Moved this to ipc_messge_utils.h.

I've switched from resize() to push_back() because it's safer when |size| is
broken.
It does not cost much because ScopedVector is holding pointers of elements so
that push_back() may not result in copying already pushed elements.

[jam, 2012/11/12 20:58:54]

I'm not sure what you mean. you mean when it comes in as very large?

the logic here should be the same as std::vector. if resize is not right to use,
then the other one isn't right either. but if it's so far been fine, then I'm
doubtful it needs to change for this one.

[hashimoto, 2012/11/13 05:03:51]

I thought this size check was to avoid copying heavy structs again and again as
the vector getting bigger.
Since ScopedVector<P> is virtually a std::vector<P*> (i.e. it just copies
pointers when expanding, no possibility of copying heavy structs), I thought
this size check was not needed for ScopedVector. (Provided std::vector is
implemented correctly, calling push_back() n times is O(n), the same order as
calling resize() beforehand.)

Anyways, I don't have strong opinion about this and having this size check seems
good if we prefer consistency regarding this code is placed in
ipc_message_utils.h.

+  typedef ScopedVector<net::UploadElement> param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, static_cast<int>(p.size()));
+    for (size_t i = 0; i < p.size(); i++)
+      WriteParam(m, *p[i]);
+  }
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
+    int size = 0;
+    // ReadLength() checks for < 0 itself.
+    if (!m->ReadLength(iter, &size))
+      return false;
+    r->resize(size);
+    for (int i = 0; i < size; i++) {
+      (*r)[i] = new net::UploadElement();
+      if (!ReadParam(m, iter, (*r)[i]))
+        return false;
+    }
+    return true;
+  }
+  static void Log(const param_type& p, std::string* l) {
+    for (size_t i = 0; i < p.size(); ++i) {
+      if (i != 0)
+        l->append(" ");
+      LogParam(*p[i], l);
+    }
+  }
+};
+
 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->elements());
     WriteParam(m, p->identifier());
     WriteParam(m, p->is_chunked());
     WriteParam(m, p->last_chunk_appended());
@@ -240,7 +270,7 @@ bool ParamTraits<scoped_refptr<net::UploadData> >::Read(const Message* m,
     return false;
   if (!has_object)
     return true;
-  std::vector<net::UploadElement> elements;
+  ScopedVector<net::UploadElement> elements;
   if (!ReadParam(m, iter, &elements))
     return false;
   int64 identifier;