diff --git a/spdy/core/hpack/hpack_decoder_adapter_test.cc b/spdy/core/hpack/hpack_decoder_adapter_test.cc
index 054e3e4..8aa588d 100644
--- a/spdy/core/hpack/hpack_decoder_adapter_test.cc
+++ b/spdy/core/hpack/hpack_decoder_adapter_test.cc
@@ -493,8 +493,8 @@
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(126);
 
-    output_stream.TakeString(&input);
-    EXPECT_TRUE(DecodeHeaderBlock(absl::string_view(input)));
+    input = output_stream.TakeString();
+    EXPECT_TRUE(DecodeHeaderBlock(input));
     EXPECT_EQ(126u, decoder_peer_.header_table_size_limit());
   }
   {
@@ -503,8 +503,8 @@
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(kDefaultHeaderTableSizeSetting);
 
-    output_stream.TakeString(&input);
-    EXPECT_TRUE(DecodeHeaderBlock(absl::string_view(input)));
+    input = output_stream.TakeString();
+    EXPECT_TRUE(DecodeHeaderBlock(input));
     EXPECT_EQ(kDefaultHeaderTableSizeSetting,
               decoder_peer_.header_table_size_limit());
   }
@@ -514,8 +514,8 @@
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(kDefaultHeaderTableSizeSetting + 1);
 
-    output_stream.TakeString(&input);
-    EXPECT_FALSE(DecodeHeaderBlock(absl::string_view(input)));
+    input = output_stream.TakeString();
+    EXPECT_FALSE(DecodeHeaderBlock(input));
     EXPECT_EQ(kDefaultHeaderTableSizeSetting,
               decoder_peer_.header_table_size_limit());
   }
@@ -532,8 +532,8 @@
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(122);
 
-    output_stream.TakeString(&input);
-    EXPECT_TRUE(DecodeHeaderBlock(absl::string_view(input)));
+    input = output_stream.TakeString();
+    EXPECT_TRUE(DecodeHeaderBlock(input));
     EXPECT_EQ(122u, decoder_peer_.header_table_size_limit());
   }
 }
@@ -551,9 +551,9 @@
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(15);
 
-    output_stream.TakeString(&input);
+    input = output_stream.TakeString();
 
-    EXPECT_FALSE(DecodeHeaderBlock(absl::string_view(input)));
+    EXPECT_FALSE(DecodeHeaderBlock(input));
     EXPECT_EQ(10u, decoder_peer_.header_table_size_limit());
   }
 }
@@ -570,9 +570,9 @@
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(123);
 
-    output_stream.TakeString(&input);
+    input = output_stream.TakeString();
 
-    EXPECT_FALSE(DecodeHeaderBlock(absl::string_view(input)));
+    EXPECT_FALSE(DecodeHeaderBlock(input));
     EXPECT_EQ(kDefaultHeaderTableSizeSetting,
               decoder_peer_.header_table_size_limit());
   }
@@ -593,9 +593,9 @@
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(125);
 
-    output_stream.TakeString(&input);
+    input = output_stream.TakeString();
 
-    EXPECT_FALSE(DecodeHeaderBlock(absl::string_view(input)));
+    EXPECT_FALSE(DecodeHeaderBlock(input));
     EXPECT_EQ(60u, decoder_peer_.header_table_size_limit());
   }
 }
diff --git a/spdy/core/hpack/hpack_encoder.cc b/spdy/core/hpack/hpack_encoder.cc
index ccf17da..4b87a0e 100644
--- a/spdy/core/hpack/hpack_encoder.cc
+++ b/spdy/core/hpack/hpack_encoder.cc
@@ -144,7 +144,7 @@
     }
   }
 
-  output_stream_.TakeString(output);
+  *output = output_stream_.TakeString();
 }
 
 void HpackEncoder::EmitIndex(size_t index) {
@@ -283,9 +283,8 @@
   // Returns true iff more remains to encode.
   bool HasNext() const override { return has_next_; }
 
-  // Encodes up to max_encoded_bytes of the current header block into the
-  // given output string.
-  void Next(size_t max_encoded_bytes, std::string* output) override;
+  // Encodes and returns up to max_encoded_bytes of the current header block.
+  std::string Next(size_t max_encoded_bytes) override;
 
  private:
   HpackEncoder* encoder_;
@@ -338,8 +337,7 @@
   encoder_->MaybeEmitTableSize();
 }
 
-void HpackEncoder::Encoderator::Next(size_t max_encoded_bytes,
-                                     std::string* output) {
+std::string HpackEncoder::Encoderator::Next(size_t max_encoded_bytes) {
   QUICHE_BUG_IF(spdy_bug_61_1, !has_next_)
       << "Encoderator::Next called with nothing left to encode.";
   const bool enable_compression = encoder_->enable_compression_;
@@ -365,7 +363,7 @@
   }
 
   has_next_ = encoder_->output_stream_.size() > max_encoded_bytes;
-  encoder_->output_stream_.BoundedTakeString(max_encoded_bytes, output);
+  return encoder_->output_stream_.BoundedTakeString(max_encoded_bytes);
 }
 
 std::unique_ptr<HpackEncoder::ProgressiveEncoder> HpackEncoder::EncodeHeaderSet(
diff --git a/spdy/core/hpack/hpack_encoder.h b/spdy/core/hpack/hpack_encoder.h
index 5e2ea03..bed59f7 100644
--- a/spdy/core/hpack/hpack_encoder.h
+++ b/spdy/core/hpack/hpack_encoder.h
@@ -60,9 +60,8 @@
     // Returns true iff more remains to encode.
     virtual bool HasNext() const = 0;
 
-    // Encodes up to max_encoded_bytes of the current header block into the
-    // given output string.
-    virtual void Next(size_t max_encoded_bytes, std::string* output) = 0;
+    // Encodes and returns up to max_encoded_bytes of the current header block.
+    virtual std::string Next(size_t max_encoded_bytes) = 0;
   };
 
   // Returns a ProgressiveEncoder which must be outlived by both the given
diff --git a/spdy/core/hpack/hpack_encoder_test.cc b/spdy/core/hpack/hpack_encoder_test.cc
index dfd8d8f..af73889 100644
--- a/spdy/core/hpack/hpack_encoder_test.cc
+++ b/spdy/core/hpack/hpack_encoder_test.cc
@@ -45,7 +45,7 @@
   HpackHeaderTablePeer table_peer() { return HpackHeaderTablePeer(table()); }
   void EmitString(absl::string_view str) { encoder_->EmitString(str); }
   void TakeString(std::string* out) {
-    encoder_->output_stream_.TakeString(out);
+    *out = encoder_->output_stream_.TakeString();
   }
   static void CookieToCrumbs(absl::string_view cookie,
                              std::vector<absl::string_view>* out) {
@@ -82,12 +82,11 @@
                                 std::string* output) {
     std::unique_ptr<HpackEncoder::ProgressiveEncoder> encoderator =
         encoder->EncodeHeaderSet(header_set);
-    std::string output_buffer;
     http2::test::Http2Random random;
-    encoderator->Next(random.UniformInRange(0, 16), &output_buffer);
+    std::string output_buffer = encoderator->Next(random.UniformInRange(0, 16));
     while (encoderator->HasNext()) {
-      std::string second_buffer;
-      encoderator->Next(random.UniformInRange(0, 16), &second_buffer);
+      std::string second_buffer =
+          encoderator->Next(random.UniformInRange(0, 16));
       output_buffer.append(second_buffer);
     }
     *output = std::move(output_buffer);
@@ -99,12 +98,11 @@
                                     std::string* output) {
     std::unique_ptr<HpackEncoder::ProgressiveEncoder> encoderator =
         encoder->EncodeRepresentations(representations);
-    std::string output_buffer;
     http2::test::Http2Random random;
-    encoderator->Next(random.UniformInRange(0, 16), &output_buffer);
+    std::string output_buffer = encoderator->Next(random.UniformInRange(0, 16));
     while (encoderator->HasNext()) {
-      std::string second_buffer;
-      encoderator->Next(random.UniformInRange(0, 16), &second_buffer);
+      std::string second_buffer =
+          encoderator->Next(random.UniformInRange(0, 16));
       output_buffer.append(second_buffer);
     }
     *output = std::move(output_buffer);
@@ -219,8 +217,8 @@
     return r;
   }
   void CompareWithExpectedEncoding(const SpdyHeaderBlock& header_set) {
-    std::string expected_out, actual_out;
-    expected_.TakeString(&expected_out);
+    std::string actual_out;
+    std::string expected_out = expected_.TakeString();
     switch (strategy_) {
       case kDefault:
         EXPECT_TRUE(test::HpackEncoderPeer::EncodeHeaderSet(
@@ -238,8 +236,8 @@
     EXPECT_EQ(expected_out, actual_out);
   }
   void CompareWithExpectedEncoding(const Representations& representations) {
-    std::string expected_out, actual_out;
-    expected_.TakeString(&expected_out);
+    std::string actual_out;
+    std::string expected_out = expected_.TakeString();
     EXPECT_TRUE(test::HpackEncoderPeer::EncodeRepresentations(
         &encoder_, representations, &actual_out));
     EXPECT_EQ(expected_out, actual_out);
@@ -460,8 +458,8 @@
   expected_.AppendUint32(6);
   expected_.AppendBytes("@@@@@@");
 
-  std::string expected_out, actual_out;
-  expected_.TakeString(&expected_out);
+  std::string actual_out;
+  std::string expected_out = expected_.TakeString();
   peer_.TakeString(&actual_out);
   EXPECT_EQ(expected_out, actual_out);
 }
diff --git a/spdy/core/hpack/hpack_output_stream.cc b/spdy/core/hpack/hpack_output_stream.cc
index bce24fa..291ad3d 100644
--- a/spdy/core/hpack/hpack_output_stream.cc
+++ b/spdy/core/hpack/hpack_output_stream.cc
@@ -68,31 +68,32 @@
   return &buffer_;
 }
 
-void HpackOutputStream::TakeString(std::string* output) {
+std::string HpackOutputStream::TakeString() {
   // This must hold, since all public functions cause the buffer to
   // end on a byte boundary.
   QUICHE_DCHECK_EQ(bit_offset_, 0u);
-  buffer_.swap(*output);
-  buffer_.clear();
+  std::string out = std::move(buffer_);
+  buffer_ = {};
   bit_offset_ = 0;
+  return out;
 }
 
-void HpackOutputStream::BoundedTakeString(size_t max_size,
-                                          std::string* output) {
+std::string HpackOutputStream::BoundedTakeString(size_t max_size) {
   if (buffer_.size() > max_size) {
     // Save off overflow bytes to temporary string (causes a copy).
-    std::string overflow(buffer_.data() + max_size, buffer_.size() - max_size);
+    std::string overflow = buffer_.substr(max_size);
 
     // Resize buffer down to the given limit.
     buffer_.resize(max_size);
 
     // Give buffer to output string.
-    *output = std::move(buffer_);
+    std::string out = std::move(buffer_);
 
     // Reset to contain overflow.
     buffer_ = std::move(overflow);
+    return out;
   } else {
-    TakeString(output);
+    return TakeString();
   }
 }
 
diff --git a/spdy/core/hpack/hpack_output_stream.h b/spdy/core/hpack/hpack_output_stream.h
index ec657b5..ade1cd1 100644
--- a/spdy/core/hpack/hpack_output_stream.h
+++ b/spdy/core/hpack/hpack_output_stream.h
@@ -51,12 +51,12 @@
   // Return pointer to internal buffer.  |bit_offset_| needs to be zero.
   std::string* MutableString();
 
-  // Swaps the internal buffer with |output|, then resets state.
-  void TakeString(std::string* output);
+  // Returns the internal buffer as a string, then resets state.
+  std::string TakeString();
 
-  // Gives up to |max_size| bytes of the internal buffer to |output|. Resets
+  // Returns up to |max_size| bytes of the internal buffer. Resets
   // internal state with the overflow.
-  void BoundedTakeString(size_t max_size, std::string* output);
+  std::string BoundedTakeString(size_t max_size);
 
   // Size in bytes of stream's internal buffer.
   size_t size() const { return buffer_.size(); }
diff --git a/spdy/core/hpack/hpack_output_stream_test.cc b/spdy/core/hpack/hpack_output_stream_test.cc
index ea05ece..3d8c35d 100644
--- a/spdy/core/hpack/hpack_output_stream_test.cc
+++ b/spdy/core/hpack/hpack_output_stream_test.cc
@@ -37,8 +37,7 @@
 
   output_stream.AppendBits(0x0, 7);
 
-  std::string str;
-  output_stream.TakeString(&str);
+  std::string str = output_stream.TakeString();
   EXPECT_EQ(expected_str, str);
 }
 
@@ -50,8 +49,7 @@
     output_stream.AppendBits(0x00, 8 - N);
   }
   output_stream.AppendUint32(I);
-  std::string str;
-  output_stream.TakeString(&str);
+  std::string str = output_stream.TakeString();
   return str;
 }
 
@@ -236,8 +234,7 @@
   HpackOutputStream output_stream;
   output_stream.AppendBits(0x7f, 7);
   output_stream.AppendUint32(0x01);
-  std::string str;
-  output_stream.TakeString(&str);
+  std::string str = output_stream.TakeString();
   EXPECT_EQ(std::string("\xff\x00", 2), str);
 }
 
@@ -247,8 +244,7 @@
   output_stream.AppendBytes("buffer1");
   output_stream.AppendBytes("buffer2");
 
-  std::string str;
-  output_stream.TakeString(&str);
+  std::string str = output_stream.TakeString();
   EXPECT_EQ("buffer1buffer2", str);
 }
 
@@ -258,16 +254,15 @@
   output_stream.AppendBytes("buffer12");
   output_stream.AppendBytes("buffer456");
 
-  std::string str;
-  output_stream.BoundedTakeString(9, &str);
+  std::string str = output_stream.BoundedTakeString(9);
   EXPECT_EQ("buffer12b", str);
 
   output_stream.AppendBits(0x7f, 7);
   output_stream.AppendUint32(0x11);
-  output_stream.BoundedTakeString(9, &str);
+  str = output_stream.BoundedTakeString(9);
   EXPECT_EQ("uffer456\xff", str);
 
-  output_stream.BoundedTakeString(9, &str);
+  str = output_stream.BoundedTakeString(9);
   EXPECT_EQ("\x10", str);
 }
 
@@ -280,8 +275,7 @@
   output_stream.AppendBytes("foo");
   output_stream.MutableString()->append("bar");
 
-  std::string str;
-  output_stream.TakeString(&str);
+  std::string str = output_stream.TakeString();
   EXPECT_EQ("12foobar", str);
 }
 
diff --git a/spdy/core/metadata_extension.cc b/spdy/core/metadata_extension.cc
index 12f6af1..1683dcc 100644
--- a/spdy/core/metadata_extension.cc
+++ b/spdy/core/metadata_extension.cc
@@ -55,9 +55,9 @@
   if (!progressive_encoder_->HasNext()) {
     return nullptr;
   }
-  std::string payload;
   // METADATA frames obey the HTTP/2 maximum frame size.
-  progressive_encoder_->Next(spdy::kHttp2DefaultFramePayloadLimit, &payload);
+  std::string payload =
+      progressive_encoder_->Next(spdy::kHttp2DefaultFramePayloadLimit);
   const bool end_metadata = (!progressive_encoder_->HasNext());
   const uint8_t flags = end_metadata ? MetadataVisitor::kEndMetadataFlag : 0;
   return absl::make_unique<spdy::SpdyUnknownIR>(
diff --git a/spdy/core/spdy_framer.cc b/spdy/core/spdy_framer.cc
index 1b6eb8a..580d1e2 100644
--- a/spdy/core/spdy_framer.cc
+++ b/spdy/core/spdy_framer.cc
@@ -301,8 +301,8 @@
 
   const size_t size_without_block =
       is_first_frame_ ? GetFrameSizeSansBlock() : kContinuationFrameMinimumSize;
-  std::string encoding;
-  encoder_->Next(kHttp2MaxControlFrameSendSize - size_without_block, &encoding);
+  std::string encoding =
+      encoder_->Next(kHttp2MaxControlFrameSendSize - size_without_block);
   has_next_frame_ = encoder_->HasNext();
 
   if (framer_->debug_visitor_ != nullptr) {