Refactor Pickle Read methods to use higher performance PickleIterator.

content/public/common/common_param_traits.cc

 // Copyright (c) 2011 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 "net/base/host_port_pair.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
@@ skipping 37 matching lines @@
 }  // namespace
 
 namespace IPC {
 
 void ParamTraits<GURL>::Write(Message* m, const GURL& p) {
   DCHECK(p.possibly_invalid_spec().length() <= content::kMaxURLChars);
   m->WriteString(p.possibly_invalid_spec());
   // TODO(brettw) bug 684583: Add encoding for query params.
 }
 
-bool ParamTraits<GURL>::Read(const Message* m, void** iter, GURL* p) {
+bool ParamTraits<GURL>::Read(const Message* m, PickleReader* iter, GURL* p) {
   std::string s;
   if (!m->ReadString(iter, &s) || s.length() > content::kMaxURLChars) {
     *p = GURL();
     return false;
   }
   *p = GURL(s);
   return true;
 }
 
 void ParamTraits<GURL>::Log(const GURL& p, std::string* l) {
   l->append(p.spec());
 }
 
 void ParamTraits<ResourceType::Type>::Write(Message* m, const param_type& p) {
   m->WriteInt(p);
 }
 
 bool ParamTraits<ResourceType::Type>::Read(const Message* m,
-                                           void** iter,
+                                           PickleReader* iter,
                                            param_type* p) {
   int type;
   if (!m->ReadInt(iter, &type) || !ResourceType::ValidType(type))
     return false;
   *p = ResourceType::FromInt(type);
   return true;
 }
 
 void ParamTraits<ResourceType::Type>::Log(const param_type& p, std::string* l) {
   std::string type;
@@ skipping 50 matching lines @@
 
   LogParam(type, l);
 }
 
 void ParamTraits<net::URLRequestStatus>::Write(Message* m,
                                                const param_type& p) {
   WriteParam(m, static_cast<int>(p.status()));
   WriteParam(m, p.error());
 }
 
-bool ParamTraits<net::URLRequestStatus>::Read(const Message* m, void** iter,
+bool ParamTraits<net::URLRequestStatus>::Read(const Message* m, PickleReader* iter,
                                               param_type* r) {
   int status, error;
   if (!ReadParam(m, iter, &status) || !ReadParam(m, iter, &error))
     return false;
   r->set_status(static_cast<net::URLRequestStatus::Status>(status));
   r->set_error(error);
   return true;
 }
 
 void ParamTraits<net::URLRequestStatus>::Log(const param_type& p,
@@ skipping 71 matching lines @@
         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, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleReader* 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;
         if (!m->ReadData(iter, &data, &len))
           return false;
         r->SetToBytes(data, len);
@@ skipping 50 matching lines @@
                                                          const param_type& p) {
   WriteParam(m, p.get() != NULL);
   if (p) {
     WriteParam(m, *p->elements());
     WriteParam(m, p->identifier());
     WriteParam(m, p->is_chunked());
   }
 }
 
 bool ParamTraits<scoped_refptr<net::UploadData> >::Read(const Message* m,
-                                                        void** iter,
+                                                        PickleReader* 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;
@@ skipping 12 matching lines @@
 void ParamTraits<scoped_refptr<net::UploadData> >::Log(const param_type& p,
                                                        std::string* l) {
   l->append("<net::UploadData>");
 }
 
 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, void** iter,
+bool ParamTraits<net::HostPortPair>::Read(const Message* m, PickleReader* iter,
                                           param_type* r) {
   std::string host;
   uint16 port;
   if (!ReadParam(m, iter, &host) || !ReadParam(m, iter, &port))
     return false;
 
   r->set_host(host);
   r->set_port(port);
   return true;
 }
 
 void ParamTraits<net::HostPortPair>::Log(const param_type& p, std::string* l) {
   l->append(p.ToString());
 }
 
 void ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Write(
     Message* m, const param_type& p) {
   WriteParam(m, p.get() != NULL);
   if (p) {
     // Do not disclose Set-Cookie headers over IPC.
     p->Persist(m, net::HttpResponseHeaders::PERSIST_SANS_COOKIES);
   }
 }
 
 bool ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Read(
-    const Message* m, void** iter, param_type* r) {
+    const Message* m, PickleReader* iter, param_type* r) {
   bool has_object;
   if (!ReadParam(m, iter, &has_object))
     return false;
   if (has_object)
     *r = new net::HttpResponseHeaders(*m, iter);
   return true;
 }
 
 void ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Log(
     const param_type& p, std::string* l) {
   l->append("<HttpResponseHeaders>");
 }
 
 void ParamTraits<net::IPEndPoint>::Write(Message* m, const param_type& p) {
   WriteParam(m, p.address());
   WriteParam(m, p.port());
 }
 
-bool ParamTraits<net::IPEndPoint>::Read(const Message* m, void** iter,
+bool ParamTraits<net::IPEndPoint>::Read(const Message* m, PickleReader* iter,
                                         param_type* p) {
   net::IPAddressNumber address;
   int port;
   if (!ReadParam(m, iter, &address) || !ReadParam(m, iter, &port))
     return false;
   *p = net::IPEndPoint(address, port);
   return true;
 }
 
 void ParamTraits<net::IPEndPoint>::Log(const param_type& p, std::string* l) {
   LogParam("IPEndPoint:" + p.ToString(), l);
 }
 
 void ParamTraits<base::PlatformFileInfo>::Write(
     Message* m, const param_type& p) {
   WriteParam(m, p.size);
   WriteParam(m, p.is_directory);
   WriteParam(m, p.last_modified.ToDoubleT());
   WriteParam(m, p.last_accessed.ToDoubleT());
   WriteParam(m, p.creation_time.ToDoubleT());
 }
 
 bool ParamTraits<base::PlatformFileInfo>::Read(
-    const Message* m, void** iter, param_type* p) {
+    const Message* m, PickleReader* iter, param_type* p) {
   double last_modified;
   double last_accessed;
   double creation_time;
   bool result =
       ReadParam(m, iter, &p->size) &&
       ReadParam(m, iter, &p->is_directory) &&
       ReadParam(m, iter, &last_modified) &&
       ReadParam(m, iter, &last_accessed) &&
       ReadParam(m, iter, &creation_time);
   if (result) {
@@ skipping 17 matching lines @@
   l->append(",");
   LogParam(p.creation_time.ToDoubleT(), l);
   l->append(")");
 }
 
 void ParamTraits<gfx::Point>::Write(Message* m, const gfx::Point& p) {
   m->WriteInt(p.x());
   m->WriteInt(p.y());
 }
 
-bool ParamTraits<gfx::Point>::Read(const Message* m, void** iter,
+bool ParamTraits<gfx::Point>::Read(const Message* m, PickleReader* iter,
                                    gfx::Point* r) {
   int x, y;
   if (!m->ReadInt(iter, &x) ||
       !m->ReadInt(iter, &y))
     return false;
   r->set_x(x);
   r->set_y(y);
   return true;
 }
 
 void ParamTraits<gfx::Point>::Log(const gfx::Point& p, std::string* l) {
   l->append(base::StringPrintf("(%d, %d)", p.x(), p.y()));
 }
 
 void ParamTraits<gfx::Size>::Write(Message* m, const gfx::Size& p) {
   m->WriteInt(p.width());
   m->WriteInt(p.height());
 }
 
-bool ParamTraits<gfx::Size>::Read(const Message* m, void** iter, gfx::Size* r) {
+bool ParamTraits<gfx::Size>::Read(const Message* m, PickleReader* iter, gfx::Size* r) {
   int w, h;
   if (!m->ReadInt(iter, &w) ||
       !m->ReadInt(iter, &h))
     return false;
   r->set_width(w);
   r->set_height(h);
   return true;
 }
 
 void ParamTraits<gfx::Size>::Log(const gfx::Size& p, std::string* l) {
   l->append(base::StringPrintf("(%d, %d)", p.width(), p.height()));
 }
 
 void ParamTraits<gfx::Rect>::Write(Message* m, const gfx::Rect& p) {
   m->WriteInt(p.x());
   m->WriteInt(p.y());
   m->WriteInt(p.width());
   m->WriteInt(p.height());
 }
 
-bool ParamTraits<gfx::Rect>::Read(const Message* m, void** iter, gfx::Rect* r) {
+bool ParamTraits<gfx::Rect>::Read(const Message* m, PickleReader* iter, gfx::Rect* r) {
   int x, y, w, h;
   if (!m->ReadInt(iter, &x) ||
       !m->ReadInt(iter, &y) ||
       !m->ReadInt(iter, &w) ||
       !m->ReadInt(iter, &h))
     return false;
   r->set_x(x);
   r->set_y(y);
   r->set_width(w);
   r->set_height(h);
   return true;
 }
 
 void ParamTraits<gfx::Rect>::Log(const gfx::Rect& p, std::string* l) {
   l->append(base::StringPrintf("(%d, %d, %d, %d)", p.x(), p.y(),
                                p.width(), p.height()));
 }
 
 void ParamTraits<ui::Range>::Write(Message* m, const ui::Range& r) {
   m->WriteSize(r.start());
   m->WriteSize(r.end());
 }
 
-bool ParamTraits<ui::Range>::Read(const Message* m, void** iter, ui::Range* r) {
+bool ParamTraits<ui::Range>::Read(const Message* m, PickleReader* iter, ui::Range* r) {
   size_t start, end;
   if (!m->ReadSize(iter, &start) || !m->ReadSize(iter, &end))
     return false;
   r->set_start(start);
   r->set_end(end);
   return true;
 }
 
 void ParamTraits<ui::Range>::Log(const ui::Range& r, std::string* l) {
   l->append(base::StringPrintf("(%"PRIuS", %"PRIuS")", r.start(), r.end()));
 }
 
 void ParamTraits<SkBitmap>::Write(Message* m, const SkBitmap& p) {
   size_t fixed_size = sizeof(SkBitmap_Data);
   SkBitmap_Data bmp_data;
   bmp_data.InitSkBitmapDataForTransfer(p);
   m->WriteData(reinterpret_cast<const char*>(&bmp_data),
                static_cast<int>(fixed_size));
   size_t pixel_size = p.getSize();
   SkAutoLockPixels p_lock(p);
   m->WriteData(reinterpret_cast<const char*>(p.getPixels()),
                static_cast<int>(pixel_size));
 }
 
-bool ParamTraits<SkBitmap>::Read(const Message* m, void** iter, SkBitmap* r) {
+bool ParamTraits<SkBitmap>::Read(const Message* m, PickleReader* iter, SkBitmap* r) {
   const char* fixed_data;
   int fixed_data_size = 0;
   if (!m->ReadData(iter, &fixed_data, &fixed_data_size) ||
      (fixed_data_size <= 0)) {
     NOTREACHED();
     return false;
   }
   if (fixed_data_size != sizeof(SkBitmap_Data))
     return false;  // Message is malformed.
 
   const char* variable_data;
   int variable_data_size = 0;
   if (!m->ReadData(iter, &variable_data, &variable_data_size) ||
      (variable_data_size < 0)) {
     NOTREACHED();
     return false;
   }
   const SkBitmap_Data* bmp_data =
       reinterpret_cast<const SkBitmap_Data*>(fixed_data);
   return bmp_data->InitSkBitmapFromData(r, variable_data, variable_data_size);
 }
 
 void ParamTraits<SkBitmap>::Log(const SkBitmap& p, std::string* l) {
   l->append("<SkBitmap>");
 }
 
 }  // namespace IPC