diff --git a/quic/core/http/quic_receive_control_stream.cc b/quic/core/http/quic_receive_control_stream.cc
index b53d4e9..87476e6 100644
--- a/quic/core/http/quic_receive_control_stream.cc
+++ b/quic/core/http/quic_receive_control_stream.cc
@@ -111,8 +111,8 @@
   sequencer()->set_level_triggered(true);
 }
 
-QuicReceiveControlStream::QuicReceiveControlStream(PendingStream pending)
-    : QuicStream(std::move(pending), READ_UNIDIRECTIONAL, /*is_static=*/true),
+QuicReceiveControlStream::QuicReceiveControlStream(PendingStream* pending)
+    : QuicStream(pending, READ_UNIDIRECTIONAL, /*is_static=*/true),
       received_settings_length_(0),
       http_decoder_visitor_(new HttpDecoderVisitor(this)) {
   decoder_.set_visitor(http_decoder_visitor_.get());
diff --git a/quic/core/http/quic_receive_control_stream.h b/quic/core/http/quic_receive_control_stream.h
index 61e4299..818a1e8 100644
--- a/quic/core/http/quic_receive_control_stream.h
+++ b/quic/core/http/quic_receive_control_stream.h
@@ -22,7 +22,7 @@
   explicit QuicReceiveControlStream(QuicStreamId id, QuicSpdySession* session);
   // Construct control stream from pending stream, the |pending| object will no
   // longer exist after the construction.
-  explicit QuicReceiveControlStream(PendingStream pending);
+  explicit QuicReceiveControlStream(PendingStream* pending);
   QuicReceiveControlStream(const QuicReceiveControlStream&) = delete;
   QuicReceiveControlStream& operator=(const QuicReceiveControlStream&) = delete;
   ~QuicReceiveControlStream() override;
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index 94ebb67..7631aa2 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -78,9 +78,9 @@
     return stream;
   }
 
-  QuicSpdyStream* CreateIncomingStream(PendingStream pending) override {
+  QuicSpdyStream* CreateIncomingStream(PendingStream* pending) override {
     QuicSpdyStream* stream = new QuicSimpleServerStream(
-        std::move(pending), this, BIDIRECTIONAL, quic_simple_server_backend_);
+        pending, this, BIDIRECTIONAL, quic_simple_server_backend_);
     ActivateStream(QuicWrapUnique(stream));
     return stream;
   }
diff --git a/quic/core/http/quic_spdy_client_session.cc b/quic/core/http/quic_spdy_client_session.cc
index 458b8a0..9be0936 100644
--- a/quic/core/http/quic_spdy_client_session.cc
+++ b/quic/core/http/quic_spdy_client_session.cc
@@ -151,9 +151,9 @@
 }
 
 QuicSpdyStream* QuicSpdyClientSession::CreateIncomingStream(
-    PendingStream pending) {
+    PendingStream* pending) {
   QuicSpdyStream* stream =
-      new QuicSpdyClientStream(std::move(pending), this, READ_UNIDIRECTIONAL);
+      new QuicSpdyClientStream(pending, this, READ_UNIDIRECTIONAL);
   ActivateStream(QuicWrapUnique(stream));
   return stream;
 }
diff --git a/quic/core/http/quic_spdy_client_session.h b/quic/core/http/quic_spdy_client_session.h
index 747033a..3611c69 100644
--- a/quic/core/http/quic_spdy_client_session.h
+++ b/quic/core/http/quic_spdy_client_session.h
@@ -66,7 +66,7 @@
  protected:
   // QuicSession methods:
   QuicSpdyStream* CreateIncomingStream(QuicStreamId id) override;
-  QuicSpdyStream* CreateIncomingStream(PendingStream pending) override;
+  QuicSpdyStream* CreateIncomingStream(PendingStream* pending) override;
   // If an outgoing stream can be created, return true.
   bool ShouldCreateOutgoingBidirectionalStream() override;
   bool ShouldCreateOutgoingUnidirectionalStream() override;
diff --git a/quic/core/http/quic_spdy_client_stream.cc b/quic/core/http/quic_spdy_client_stream.cc
index d4e8a69..2903b30 100644
--- a/quic/core/http/quic_spdy_client_stream.cc
+++ b/quic/core/http/quic_spdy_client_stream.cc
@@ -28,10 +28,10 @@
       session_(session),
       has_preliminary_headers_(false) {}
 
-QuicSpdyClientStream::QuicSpdyClientStream(PendingStream pending,
+QuicSpdyClientStream::QuicSpdyClientStream(PendingStream* pending,
                                            QuicSpdyClientSession* session,
                                            StreamType type)
-    : QuicSpdyStream(std::move(pending), session, type),
+    : QuicSpdyStream(pending, session, type),
       content_length_(-1),
       response_code_(0),
       header_bytes_read_(0),
diff --git a/quic/core/http/quic_spdy_client_stream.h b/quic/core/http/quic_spdy_client_stream.h
index ba59ca6..9c94b70 100644
--- a/quic/core/http/quic_spdy_client_stream.h
+++ b/quic/core/http/quic_spdy_client_stream.h
@@ -24,7 +24,7 @@
   QuicSpdyClientStream(QuicStreamId id,
                        QuicSpdyClientSession* session,
                        StreamType type);
-  QuicSpdyClientStream(PendingStream pending,
+  QuicSpdyClientStream(PendingStream* pending,
                        QuicSpdyClientSession* spdy_session,
                        StreamType type);
   QuicSpdyClientStream(const QuicSpdyClientStream&) = delete;
diff --git a/quic/core/http/quic_spdy_server_stream_base.cc b/quic/core/http/quic_spdy_server_stream_base.cc
index cbe479e..2e2e2ec 100644
--- a/quic/core/http/quic_spdy_server_stream_base.cc
+++ b/quic/core/http/quic_spdy_server_stream_base.cc
@@ -15,10 +15,10 @@
                                                    StreamType type)
     : QuicSpdyStream(id, session, type) {}
 
-QuicSpdyServerStreamBase::QuicSpdyServerStreamBase(PendingStream pending,
+QuicSpdyServerStreamBase::QuicSpdyServerStreamBase(PendingStream* pending,
                                                    QuicSpdySession* session,
                                                    StreamType type)
-    : QuicSpdyStream(std::move(pending), session, type) {}
+    : QuicSpdyStream(pending, session, type) {}
 
 void QuicSpdyServerStreamBase::CloseWriteSide() {
   if (!fin_received() && !rst_received() && sequencer()->ignore_read_data() &&
diff --git a/quic/core/http/quic_spdy_server_stream_base.h b/quic/core/http/quic_spdy_server_stream_base.h
index 438d152..ad0d326 100644
--- a/quic/core/http/quic_spdy_server_stream_base.h
+++ b/quic/core/http/quic_spdy_server_stream_base.h
@@ -14,7 +14,7 @@
   QuicSpdyServerStreamBase(QuicStreamId id,
                            QuicSpdySession* session,
                            StreamType type);
-  QuicSpdyServerStreamBase(PendingStream pending,
+  QuicSpdyServerStreamBase(PendingStream* pending,
                            QuicSpdySession* session,
                            StreamType type);
   QuicSpdyServerStreamBase(const QuicSpdyServerStreamBase&) = delete;
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 35b2d5e..13a9fa2 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -754,7 +754,7 @@
       // TODO(renjietang): Create incoming control stream.
       break;
     case kServerPushStream: {  // Push Stream.
-      QuicSpdyStream* stream = CreateIncomingStream(std::move(*pending));
+      QuicSpdyStream* stream = CreateIncomingStream(pending);
       stream->SetUnblocked();
       return true;
     }
diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index d0978c1..5af73f1 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -184,7 +184,7 @@
   // CreateOutgoingUnidirectionalStream() with QuicSpdyStream return type to
   // make sure that all data streams are QuicSpdyStreams.
   QuicSpdyStream* CreateIncomingStream(QuicStreamId id) override = 0;
-  QuicSpdyStream* CreateIncomingStream(PendingStream pending) override = 0;
+  QuicSpdyStream* CreateIncomingStream(PendingStream* pending) override = 0;
   virtual QuicSpdyStream* CreateOutgoingBidirectionalStream() = 0;
   virtual QuicSpdyStream* CreateOutgoingUnidirectionalStream() = 0;
 
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 942688a..5b9a6af 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -119,8 +119,8 @@
   TestStream(QuicStreamId id, QuicSpdySession* session, StreamType type)
       : QuicSpdyStream(id, session, type) {}
 
-  TestStream(PendingStream pending, QuicSpdySession* session, StreamType type)
-      : QuicSpdyStream(std::move(pending), session, type) {}
+  TestStream(PendingStream* pending, QuicSpdySession* session, StreamType type)
+      : QuicSpdyStream(pending, session, type) {}
 
   using QuicStream::CloseWriteSide;
 
@@ -192,10 +192,10 @@
     }
   }
 
-  TestStream* CreateIncomingStream(PendingStream pending) override {
-    QuicStreamId id = pending.id();
+  TestStream* CreateIncomingStream(PendingStream* pending) override {
+    QuicStreamId id = pending->id();
     TestStream* stream =
-        new TestStream(std::move(pending), this,
+        new TestStream(pending, this,
                        DetermineStreamType(
                            id, connection()->transport_version(), perspective(),
                            /*is_incoming=*/true, BIDIRECTIONAL));
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index d424cc0..4796c78 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -170,10 +170,10 @@
   decoder_.set_visitor(http_decoder_visitor_.get());
 }
 
-QuicSpdyStream::QuicSpdyStream(PendingStream pending,
+QuicSpdyStream::QuicSpdyStream(PendingStream* pending,
                                QuicSpdySession* spdy_session,
                                StreamType type)
-    : QuicStream(std::move(pending), type, /*is_static=*/false),
+    : QuicStream(pending, type, /*is_static=*/false),
       spdy_session_(spdy_session),
       on_body_available_called_because_sequencer_is_closed_(false),
       visitor_(nullptr),
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index dc0d6f5..8136d20 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -61,7 +61,7 @@
   QuicSpdyStream(QuicStreamId id,
                  QuicSpdySession* spdy_session,
                  StreamType type);
-  QuicSpdyStream(PendingStream pending,
+  QuicSpdyStream(PendingStream* pending,
                  QuicSpdySession* spdy_session,
                  StreamType type);
   QuicSpdyStream(const QuicSpdyStream&) = delete;
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 105bd00..2477e50 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -78,7 +78,7 @@
                     const std::string& error_details,
                     ConnectionCloseSource source));
   MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream pending));
+  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* pending));
   MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
   MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
 
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 513ed9b..5988369 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -441,7 +441,7 @@
   // Caller does not own the returned stream.
   // Returns nullptr and does error handling if the stream can not be created.
   virtual QuicStream* CreateIncomingStream(QuicStreamId id) = 0;
-  virtual QuicStream* CreateIncomingStream(PendingStream pending) = 0;
+  virtual QuicStream* CreateIncomingStream(PendingStream* pending) = 0;
 
   // Return the reserved crypto stream.
   virtual QuicCryptoStream* GetMutableCryptoStream() = 0;
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index e2996db..7d7350c 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -117,8 +117,8 @@
              StreamType type)
       : QuicStream(id, session, is_static, type) {}
 
-  TestStream(PendingStream pending, StreamType type)
-      : QuicStream(std::move(pending), type, /*is_static=*/false) {}
+  TestStream(PendingStream* pending, StreamType type)
+      : QuicStream(pending, type, /*is_static=*/false) {}
 
   using QuicStream::CloseReadSide;
   using QuicStream::CloseWriteSide;
@@ -204,13 +204,12 @@
     return stream;
   }
 
-  TestStream* CreateIncomingStream(PendingStream pending) override {
-    QuicStreamId id = pending.id();
-    TestStream* stream =
-        new TestStream(std::move(pending),
-                       DetermineStreamType(
-                           id, connection()->transport_version(), perspective(),
-                           /*is_incoming=*/true, BIDIRECTIONAL));
+  TestStream* CreateIncomingStream(PendingStream* pending) override {
+    QuicStreamId id = pending->id();
+    TestStream* stream = new TestStream(
+        pending, DetermineStreamType(id, connection()->transport_version(),
+                                     perspective(),
+                                     /*is_incoming=*/true, BIDIRECTIONAL));
     ActivateStream(QuicWrapUnique(stream));
     ++num_incoming_streams_created_;
     return stream;
@@ -223,7 +222,7 @@
     struct iovec iov;
     if (pending->sequencer()->GetReadableRegion(&iov)) {
       // Create TestStream once the first byte is received.
-      CreateIncomingStream(std::move(*pending));
+      CreateIncomingStream(pending);
       return true;
     }
     return false;
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 94cffd4..cf19e31 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -173,16 +173,16 @@
   sequencer_.MarkConsumed(num_bytes);
 }
 
-QuicStream::QuicStream(PendingStream pending, StreamType type, bool is_static)
-    : QuicStream(pending.id_,
-                 pending.session_,
-                 std::move(pending.sequencer_),
+QuicStream::QuicStream(PendingStream* pending, StreamType type, bool is_static)
+    : QuicStream(pending->id_,
+                 pending->session_,
+                 std::move(pending->sequencer_),
                  is_static,
                  type,
-                 pending.stream_bytes_read_,
-                 pending.fin_received_,
-                 std::move(pending.flow_controller_),
-                 pending.connection_flow_controller_) {
+                 pending->stream_bytes_read_,
+                 pending->fin_received_,
+                 std::move(pending->flow_controller_),
+                 pending->connection_flow_controller_) {
   sequencer_.set_stream(this);
 }
 
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index 80ee4e4..a9d7703 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -126,7 +126,7 @@
              QuicSession* session,
              bool is_static,
              StreamType type);
-  QuicStream(PendingStream pending, StreamType type, bool is_static);
+  QuicStream(PendingStream* pending, StreamType type, bool is_static);
   QuicStream(const QuicStream&) = delete;
   QuicStream& operator=(const QuicStream&) = delete;
 
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index 9b32012..094ca79 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -49,8 +49,8 @@
   TestStream(QuicStreamId id, QuicSession* session, StreamType type)
       : QuicStream(id, session, /*is_static=*/false, type) {}
 
-  TestStream(PendingStream pending, StreamType type, bool is_static)
-      : QuicStream(std::move(pending), type, is_static) {}
+  TestStream(PendingStream* pending, StreamType type, bool is_static)
+      : QuicStream(pending, type, is_static) {}
 
   void OnDataAvailable() override {}
 
@@ -175,11 +175,11 @@
   Initialize();
 
   PendingStream pending(kTestStreamId + 2, session_.get());
-  TestStream stream(std::move(pending), StreamType::BIDIRECTIONAL, false);
+  TestStream stream(&pending, StreamType::BIDIRECTIONAL, false);
   EXPECT_FALSE(stream.is_static());
 
   PendingStream pending2(kTestStreamId + 3, session_.get());
-  TestStream stream2(std::move(pending2), StreamType::BIDIRECTIONAL, true);
+  TestStream stream2(&pending2, StreamType::BIDIRECTIONAL, true);
   EXPECT_TRUE(stream2.is_static());
 }
 
@@ -240,7 +240,7 @@
   QuicStreamFrame frame2(kTestStreamId + 2, true, 3, QuicStringPiece("."));
   pending.OnStreamFrame(frame2);
 
-  TestStream stream(std::move(pending), StreamType::READ_UNIDIRECTIONAL, false);
+  TestStream stream(&pending, StreamType::READ_UNIDIRECTIONAL, false);
   EXPECT_EQ(3, stream.num_frames_received());
   EXPECT_EQ(3u, stream.stream_bytes_read());
   EXPECT_EQ(1, stream.num_duplicate_frames_received());
@@ -259,8 +259,8 @@
   QuicStreamFrame frame(kTestStreamId + 2, false, 2, QuicStringPiece("."));
   pending.OnStreamFrame(frame);
 
-  auto stream = new TestStream(std::move(pending),
-                               StreamType::READ_UNIDIRECTIONAL, false);
+  auto stream =
+      new TestStream(&pending, StreamType::READ_UNIDIRECTIONAL, false);
   session_->ActivateStream(QuicWrapUnique(stream));
 
   QuicStreamFrame frame2(kTestStreamId + 2, true, 3, QuicStringPiece("."));
diff --git a/quic/quartc/quartc_session.cc b/quic/quartc/quartc_session.cc
index 9615689..8b285d0 100644
--- a/quic/quartc/quartc_session.cc
+++ b/quic/quartc/quartc_session.cc
@@ -243,9 +243,9 @@
   return ActivateDataStream(CreateDataStream(id, QuicStream::kDefaultPriority));
 }
 
-QuicStream* QuartcSession::CreateIncomingStream(PendingStream pending) {
+QuicStream* QuartcSession::CreateIncomingStream(PendingStream* pending) {
   return ActivateDataStream(
-      CreateDataStream(std::move(pending), QuicStream::kDefaultPriority));
+      CreateDataStream(pending, QuicStream::kDefaultPriority));
 }
 
 std::unique_ptr<QuartcStream> QuartcSession::CreateDataStream(
@@ -260,10 +260,9 @@
 }
 
 std::unique_ptr<QuartcStream> QuartcSession::CreateDataStream(
-    PendingStream pending,
+    PendingStream* pending,
     spdy::SpdyPriority priority) {
-  return InitializeDataStream(QuicMakeUnique<QuartcStream>(std::move(pending)),
-                              priority);
+  return InitializeDataStream(QuicMakeUnique<QuartcStream>(pending), priority);
 }
 
 std::unique_ptr<QuartcStream> QuartcSession::InitializeDataStream(
diff --git a/quic/quartc/quartc_session.h b/quic/quartc/quartc_session.h
index 840f69d..fd1743b 100644
--- a/quic/quartc/quartc_session.h
+++ b/quic/quartc/quartc_session.h
@@ -179,11 +179,11 @@
  protected:
   // QuicSession override.
   QuicStream* CreateIncomingStream(QuicStreamId id) override;
-  QuicStream* CreateIncomingStream(PendingStream pending) override;
+  QuicStream* CreateIncomingStream(PendingStream* pending) override;
 
   std::unique_ptr<QuartcStream> CreateDataStream(QuicStreamId id,
                                                  spdy::SpdyPriority priority);
-  std::unique_ptr<QuartcStream> CreateDataStream(PendingStream pending,
+  std::unique_ptr<QuartcStream> CreateDataStream(PendingStream* pending,
                                                  spdy::SpdyPriority priority);
   // Activates a QuartcStream.  The session takes ownership of the stream, but
   // returns an unowned pointer to the stream for convenience.
diff --git a/quic/quartc/quartc_stream.cc b/quic/quartc/quartc_stream.cc
index 5fc1074..80bc3fc 100644
--- a/quic/quartc/quartc_stream.cc
+++ b/quic/quartc/quartc_stream.cc
@@ -24,8 +24,8 @@
   sequencer()->set_level_triggered(true);
 }
 
-QuartcStream::QuartcStream(PendingStream pending)
-    : QuicStream(std::move(pending), BIDIRECTIONAL, /*is_static=*/false) {
+QuartcStream::QuartcStream(PendingStream* pending)
+    : QuicStream(pending, BIDIRECTIONAL, /*is_static=*/false) {
   sequencer()->set_level_triggered(true);
 }
 
diff --git a/quic/quartc/quartc_stream.h b/quic/quartc/quartc_stream.h
index bf15a68..9c4450d 100644
--- a/quic/quartc/quartc_stream.h
+++ b/quic/quartc/quartc_stream.h
@@ -26,7 +26,7 @@
 class QuartcStream : public QuicStream {
  public:
   QuartcStream(QuicStreamId id, QuicSession* session);
-  explicit QuartcStream(PendingStream pending);
+  explicit QuartcStream(PendingStream* pending);
 
   ~QuartcStream() override;
 
diff --git a/quic/quartc/quartc_stream_test.cc b/quic/quartc/quartc_stream_test.cc
index d7599e8..5ee2d6f 100644
--- a/quic/quartc/quartc_stream_test.cc
+++ b/quic/quartc/quartc_stream_test.cc
@@ -86,7 +86,7 @@
     return nullptr;
   }
 
-  QuartcStream* CreateIncomingStream(PendingStream pending) override {
+  QuartcStream* CreateIncomingStream(PendingStream* pending) override {
     return nullptr;
   }
 
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 4f6a30a..bf8edcf 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -601,7 +601,7 @@
                     const std::string& error_details,
                     ConnectionCloseSource source));
   MOCK_METHOD1(CreateIncomingStream, QuicStream*(QuicStreamId id));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream stream));
+  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* stream));
   MOCK_METHOD1(ShouldCreateIncomingStream2, bool(QuicStreamId id));
   MOCK_METHOD0(ShouldCreateOutgoingBidirectionalStream, bool());
   MOCK_METHOD0(ShouldCreateOutgoingUnidirectionalStream, bool());
@@ -685,7 +685,7 @@
                     const std::string& error_details,
                     ConnectionCloseSource source));
   MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream stream));
+  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* stream));
   MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
   MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
   MOCK_METHOD1(ShouldCreateIncomingStream, bool(QuicStreamId id));
@@ -754,7 +754,7 @@
   ~TestQuicSpdyServerSession() override;
 
   MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream stream));
+  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* stream));
   MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
   MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
   QuicCryptoServerStreamBase* CreateQuicCryptoServerStream(
@@ -819,7 +819,7 @@
 
   // TestQuicSpdyClientSession
   MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream stream));
+  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* stream));
   MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
   MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
   MOCK_METHOD1(ShouldCreateIncomingStream, bool(QuicStreamId id));
diff --git a/quic/tools/quic_simple_server_session.cc b/quic/tools/quic_simple_server_session.cc
index 2b4cae7..93a8490 100644
--- a/quic/tools/quic_simple_server_session.cc
+++ b/quic/tools/quic_simple_server_session.cc
@@ -96,9 +96,9 @@
 }
 
 QuicSpdyStream* QuicSimpleServerSession::CreateIncomingStream(
-    PendingStream pending) {
+    PendingStream* pending) {
   QuicSpdyStream* stream = new QuicSimpleServerStream(
-      std::move(pending), this, BIDIRECTIONAL, quic_simple_server_backend_);
+      pending, this, BIDIRECTIONAL, quic_simple_server_backend_);
   ActivateStream(QuicWrapUnique(stream));
   return stream;
 }
diff --git a/quic/tools/quic_simple_server_session.h b/quic/tools/quic_simple_server_session.h
index c370534..0ca0e6f 100644
--- a/quic/tools/quic_simple_server_session.h
+++ b/quic/tools/quic_simple_server_session.h
@@ -83,7 +83,7 @@
  protected:
   // QuicSession methods:
   QuicSpdyStream* CreateIncomingStream(QuicStreamId id) override;
-  QuicSpdyStream* CreateIncomingStream(PendingStream pending) override;
+  QuicSpdyStream* CreateIncomingStream(PendingStream* pending) override;
   QuicSimpleServerStream* CreateOutgoingBidirectionalStream() override;
   QuicSimpleServerStream* CreateOutgoingUnidirectionalStream() override;
   // Override to return true for locally preserved server push stream.
diff --git a/quic/tools/quic_simple_server_stream.cc b/quic/tools/quic_simple_server_stream.cc
index 55d93dc..e24c110 100644
--- a/quic/tools/quic_simple_server_stream.cc
+++ b/quic/tools/quic_simple_server_stream.cc
@@ -34,11 +34,11 @@
 }
 
 QuicSimpleServerStream::QuicSimpleServerStream(
-    PendingStream pending,
+    PendingStream* pending,
     QuicSpdySession* session,
     StreamType type,
     QuicSimpleServerBackend* quic_simple_server_backend)
-    : QuicSpdyServerStreamBase(std::move(pending), session, type),
+    : QuicSpdyServerStreamBase(pending, session, type),
       content_length_(-1),
       quic_simple_server_backend_(quic_simple_server_backend) {
   DCHECK(quic_simple_server_backend_);
diff --git a/quic/tools/quic_simple_server_stream.h b/quic/tools/quic_simple_server_stream.h
index e3eaa12..ace1571 100644
--- a/quic/tools/quic_simple_server_stream.h
+++ b/quic/tools/quic_simple_server_stream.h
@@ -23,7 +23,7 @@
                          QuicSpdySession* session,
                          StreamType type,
                          QuicSimpleServerBackend* quic_simple_server_backend);
-  QuicSimpleServerStream(PendingStream pending,
+  QuicSimpleServerStream(PendingStream* pending,
                          QuicSpdySession* session,
                          StreamType type,
                          QuicSimpleServerBackend* quic_simple_server_backend);