Initial implementation of ServiceWorkerCache.

net/base/io_buffer.h

Index: net/base/io_buffer.h
diff --git a/net/base/io_buffer.h b/net/base/io_buffer.h
index 0ce52e8d79c02473adabd6af98e2e9272d9b2fdb..df8eb5e37951e61f5f4881b2524512220492a477 100644
--- a/net/base/io_buffer.h
+++ b/net/base/io_buffer.h
@@ -123,6 +123,22 @@ class NET_EXPORT StringIOBuffer : public IOBuffer {
   std::string string_data_;
 };
 
+// This version allows a string to be used as the storage for a write-style
+// operation, avoiding an extra data copy.  The string passed to the constructor
+// is std::string::swap'd with an interal string.
+class NET_EXPORT ZeroCopyStringIOBuffer : public IOBuffer {

[gavinp, 2014/08/14 22:02:45]

Firstly, this is really cool. Well thought out and well done. However, our
current STL implementation on most platforms is C++98/C++03 compliant, which
means that it actually is, behind the scenes, doing refcounting. So in practice
this class won't have any advantage over the existing StringIOBuffer
constructor, since under the covers a refcount is being added.

However, in C++11 the iterator invalidation semantics make a refcounting
implementation of strings implausible. So this is more future proof. I like the
future.

However, and this is a big however, swap is a bit subtle, I'd like to see that
advertised a bit better to callers. The other thing is, since this is basically
the same as a StringIOBuffer, I'd like to see it unified.

There's already a lot of users of the StringIOBuffer, so let's leave that
constructor the same. However, why not add a static create method with a name
that really calls out the operation... Perhaps add another constructor:

   StringIOBuffer::StringIOBuffer(scoped_ptr<std::string> blah);

And document that constructor as being very low cost.

(Note: you might object that the string you want to use is on the heap so
dynamically allocating it is a waste; well, true, but the string object itself
is pretty small, most of its allocation is on the heap anyway, and the
scoped_ptr<> argument conveys the transfer of ownership better than any name we
could come up with)

[jkarlin, 2014/08/15 00:13:34]

Great suggestion.  Done.

+ public:
+  // The input |s| is swapped with string_.
+  ZeroCopyStringIOBuffer(std::string* s);
+
+  std::string* string() { return &string_; }
+
+ private:
+  virtual ~ZeroCopyStringIOBuffer();
+
+  std::string string_;
+};
+
 // This version wraps an existing IOBuffer and provides convenient functions
 // to progressively read all the data.
 //