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

chrome/common/automation_messages.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 "ui/base/models/menu_model.h"
 
 // Get basic type definitions.
 #define IPC_MESSAGE_IMPL
 #include "chrome/common/automation_messages.h"
 
@@ skipping 203 matching lines @@
         break;
       }
     }
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("<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());
   }
 }
 
 bool ParamTraits<scoped_refptr<net::UploadData> >::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<net::UploadElement> elements;
+  ScopedVector<net::UploadElement> elements;
   if (!ReadParam(m, iter, &elements))
     return false;
   int64 identifier;
   if (!ReadParam(m, iter, &identifier))
     return false;
   bool is_chunked = false;
   if (!ReadParam(m, iter, &is_chunked))
     return false;
   bool last_chunk_appended = false;
   if (!ReadParam(m, iter, &last_chunk_appended))
@@ skipping 54 matching lines @@
   LogParam(status, l);
 
   if (p.status() == net::URLRequestStatus::FAILED) {
     l->append(", ");
     LogParam(p.error(), l);
     l->append(")");
   }
 }
 
 }  // namespace IPC