Replace std::vector with WTF::Vector in P2PQuicStream

Bug: 874296
Change-Id: I233cda30e59b696bc6960f1e7366cbee62849bed
Reviewed-on: https://chromium-review.googlesource.com/c/1325011
Commit-Queue: Steve Anton <steveanton@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#606675}

third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_stream.h

@@ -6,7 +6,8 @@
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_P2P_QUIC_STREAM_H_
 
 #include <stdint.h>
-#include <vector>
+
+#include "third_party/blink/renderer/platform/wtf/vector.h"
 
 namespace blink {
 
@@ -39,7 +40,7 @@ class P2PQuicStream {
     // If the stream has already finished writing, then upon receiving the FIN
     // bit the stream can no longer read or write and is deleted by the
     // quic::QuicSession.
-    virtual void OnDataReceived(std::vector<uint8_t> data, bool fin) {}
+    virtual void OnDataReceived(Vector<uint8_t> data, bool fin) {}
 
     // Called when data written with WriteData() has been consumed by QUIC.
     //
@@ -74,7 +75,7 @@ class P2PQuicStream {
   // writing. After sending the FIN bit, the P2PQuicStream can no longer write.
   // Once the P2PQuicStream has sent AND received the FIN bit it will be closed
   // for reading and writing and deleted by the quic::QuicSession.
-  virtual void WriteData(std::vector<uint8_t> data, bool fin) = 0;
+  virtual void WriteData(Vector<uint8_t> data, bool fin) = 0;
 
   // Sets the delegate object, which must outlive the P2PQuicStream.
   virtual void SetDelegate(Delegate* delegate) = 0;

third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_stream_impl.cc

@@ -27,7 +27,7 @@ void P2PQuicStreamImpl::OnDataAvailable() {
     // We have consumed all data from the sequencer up to the FIN bit. This can
     // only occur by receiving an empty STREAM frame with the FIN bit set.
     quic::QuicStream::OnFinRead();
-    delegate_->OnDataReceived(std::vector<uint8_t>(), /*fin=*/true);
+    delegate_->OnDataReceived({}, /*fin=*/true);
     consumed_fin_ = true;
   }
 
@@ -41,7 +41,7 @@ void P2PQuicStreamImpl::OnDataAvailable() {
   if (total_read_amount == 0 || consumed_fin_) {
     return;
   }
-  std::vector<uint8_t> data(total_read_amount);
+  Vector<uint8_t> data(total_read_amount);
   uint32_t current_data_offset = 0;
   struct iovec iov;
 
@@ -106,7 +106,7 @@ void P2PQuicStreamImpl::MarkReceivedDataConsumed(uint32_t amount) {
   }
 }
 
-void P2PQuicStreamImpl::WriteData(std::vector<uint8_t> data, bool fin) {
+void P2PQuicStreamImpl::WriteData(Vector<uint8_t> data, bool fin) {
   // It is up to the delegate to not write more data than the
   // |write_buffer_size_|.
   DCHECK_GE(write_buffer_size_, data.size() + write_buffered_amount_);

third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_stream_impl.h

@@ -24,7 +24,7 @@ class MODULES_EXPORT P2PQuicStreamImpl final : public P2PQuicStream,
 
   void Reset() override;
 
-  void WriteData(std::vector<uint8_t> data, bool fin) override;
+  void WriteData(Vector<uint8_t> data, bool fin) override;
 
   void MarkReceivedDataConsumed(uint32_t amount) override;
 

third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_test.cc

@@ -21,12 +21,14 @@ namespace blink {
 namespace {
 
 using testing::_;
+using testing::ElementsAreArray;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using ::testing::MakePolymorphicAction;
 using ::testing::PolymorphicAction;
 
-const std::string kTriggerRemoteStreamPhrase = "open sesame";
+const uint8_t kTriggerRemoteStreamPhrase[] = {'o', 'p', 'e', 'n', ' ', 's',
+                                              'e', 's', 'a', 'm', 'e'};
 const uint32_t kTransportWriteBufferSize = 100 * 1024;
 const uint32_t kTransportDelegateReadBufferSize = 100 * 1024;
 
@@ -528,8 +530,7 @@ class P2PQuicTransportTest : public testing::Test {
         }));
 
     client_peer_->stream()->WriteData(
-        std::vector<uint8_t>(kTriggerRemoteStreamPhrase.begin(),
-                             kTriggerRemoteStreamPhrase.end()),
+        VectorFromArray(kTriggerRemoteStreamPhrase),
         /*fin=*/false);
     run_loop.RunUntilCallbacksFired();
     // Set the stream and delegate to the |server_peer_|, so that it can be
@@ -583,6 +584,13 @@ class P2PQuicTransportTest : public testing::Test {
 
   scoped_refptr<net::test::TestTaskRunner> runner() { return runner_; }
 
+  template <wtf_size_t Size>
+  static Vector<uint8_t> VectorFromArray(const uint8_t (&array)[Size]) {
+    Vector<uint8_t> vector;
+    vector.Append(array, Size);
+    return vector;
+  }
+
  private:
   quic::MockClock clock_;
   // The TestTaskRunner is used by the QUIC library for setting/firing alarms.
@@ -869,8 +877,7 @@ TEST_F(P2PQuicTransportTest, ClientCreatesStream) {
           }));
 
   client_peer()->stream()->WriteData(
-      std::vector<uint8_t>(kTriggerRemoteStreamPhrase.begin(),
-                           kTriggerRemoteStreamPhrase.end()),
+      VectorFromArray(kTriggerRemoteStreamPhrase),
       /*fin=*/false);
   run_loop.RunUntilCallbacksFired();
 
@@ -906,8 +913,7 @@ TEST_F(P2PQuicTransportTest, ServerCreatesStream) {
           }));
 
   server_peer()->stream()->WriteData(
-      std::vector<uint8_t>(kTriggerRemoteStreamPhrase.begin(),
-                           kTriggerRemoteStreamPhrase.end()),
+      VectorFromArray(kTriggerRemoteStreamPhrase),
       /*fin=*/false);
   run_loop.RunUntilCallbacksFired();
 
@@ -1079,18 +1085,17 @@ TEST_F(P2PQuicTransportTest, StreamDataSentThenReceivedOnRemoteSide) {
   Connect();
   SetupConnectedStreams();
   CallbackRunLoop run_loop(runner());
-  std::string message = "howdy partner";
+  const uint8_t kMessage[] = {'h', 'o', 'w', 'd', 'y'};
 
   EXPECT_CALL(*server_peer()->stream_delegate(),
-              OnDataReceived(
-                  std::vector<uint8_t>(message.begin(), message.end()), false))
+              OnDataReceived(ElementsAreArray(kMessage), false))
       .WillOnce(FireCallback(run_loop.CreateCallback()));
   EXPECT_CALL(*client_peer()->stream_delegate(),
-              OnWriteDataConsumed(message.size()))
+              OnWriteDataConsumed(base::size(kMessage)))
       .WillOnce(FireCallback(run_loop.CreateCallback()));
 
-  client_peer()->stream()->WriteData(
-      std::vector<uint8_t>(message.begin(), message.end()), /* fin= */ false);
+  client_peer()->stream()->WriteData(VectorFromArray(kMessage),
+                                     /* fin= */ false);
   run_loop.RunUntilCallbacksFired();
 }
 
@@ -1101,33 +1106,27 @@ TEST_F(P2PQuicTransportTest, StreamDataSentWithFinClosesStreams) {
   Connect();
   SetupConnectedStreams();
   CallbackRunLoop run_loop(runner());
-  std::string server_message = "some server data";
-  std::string client_message = "client data";
+  const uint8_t kServerMessage[] = {'s', 'e', 'r', 'v', 'e', 'r'};
+  const uint8_t kClientMessage[] = {'c', 'l', 'i', 'e', 'n', 't'};
 
   EXPECT_CALL(*server_peer()->stream_delegate(),
-              OnDataReceived(std::vector<uint8_t>(client_message.begin(),
-                                                  client_message.end()),
-                             true))
+              OnDataReceived(VectorFromArray(kClientMessage), true))
       .WillOnce(FireCallback(run_loop.CreateCallback()));
   EXPECT_CALL(*server_peer()->stream_delegate(),
-              OnWriteDataConsumed(server_message.size()))
+              OnWriteDataConsumed(base::size(kServerMessage)))
       .WillOnce(FireCallback(run_loop.CreateCallback()));
 
   EXPECT_CALL(*client_peer()->stream_delegate(),
-              OnDataReceived(std::vector<uint8_t>(server_message.begin(),
-                                                  server_message.end()),
-                             true))
+              OnDataReceived(ElementsAreArray(kServerMessage), true))
       .WillOnce(FireCallback(run_loop.CreateCallback()));
   EXPECT_CALL(*client_peer()->stream_delegate(),
-              OnWriteDataConsumed(client_message.size()))
+              OnWriteDataConsumed(base::size(kClientMessage)))
       .WillOnce(FireCallback(run_loop.CreateCallback()));
 
-  client_peer()->stream()->WriteData(
-      std::vector<uint8_t>(client_message.begin(), client_message.end()),
-      /*fin=*/true);
-  server_peer()->stream()->WriteData(
-      std::vector<uint8_t>(server_message.begin(), server_message.end()),
-      /*fin=*/true);
+  client_peer()->stream()->WriteData(VectorFromArray(kClientMessage),
+                                     /*fin=*/true);
+  server_peer()->stream()->WriteData(VectorFromArray(kServerMessage),
+                                     /*fin=*/true);
   run_loop.RunUntilCallbacksFired();
 
   ExpectStreamsClosed();

third_party/blink/renderer/modules/peerconnection/adapters/quic_stream_host.cc

@@ -55,7 +55,7 @@ void QuicStreamHost::MarkReceivedDataConsumed(uint32_t amount) {
   p2p_stream_->MarkReceivedDataConsumed(amount);
 }
 
-void QuicStreamHost::WriteData(std::vector<uint8_t> data, bool fin) {
+void QuicStreamHost::WriteData(Vector<uint8_t> data, bool fin) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(p2p_stream_);
   p2p_stream_->WriteData(data, fin);
@@ -76,7 +76,7 @@ void QuicStreamHost::OnRemoteReset() {
   Delete();
 }
 
-void QuicStreamHost::OnDataReceived(std::vector<uint8_t> data, bool fin) {
+void QuicStreamHost::OnDataReceived(Vector<uint8_t> data, bool fin) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   PostCrossThreadTask(*proxy_thread(), FROM_HERE,
                       CrossThreadBind(&QuicStreamProxy::OnDataReceived,

third_party/blink/renderer/modules/peerconnection/adapters/quic_stream_host.h

@@ -57,7 +57,7 @@ class QuicStreamHost final : public base::SupportsWeakPtr<QuicStreamHost>,
 
   void Reset();
   void MarkReceivedDataConsumed(uint32_t amount);
-  void WriteData(std::vector<uint8_t> data, bool fin);
+  void WriteData(Vector<uint8_t> data, bool fin);
 
  private:
   // Instruct the QuicTransportHost to remove and delete this stream host.
@@ -65,7 +65,7 @@ class QuicStreamHost final : public base::SupportsWeakPtr<QuicStreamHost>,
 
   // P2PQuicStream::Delegate overrides.
   void OnRemoteReset() override;
-  void OnDataReceived(std::vector<uint8_t> data, bool fin) override;
+  void OnDataReceived(Vector<uint8_t> data, bool fin) override;
   void OnWriteDataConsumed(uint32_t amount) override;
 
   // Up reference. Owned by QuicTransportProxy.

third_party/blink/renderer/modules/peerconnection/adapters/quic_stream_proxy.cc

@@ -58,7 +58,7 @@ void QuicStreamProxy::MarkReceivedDataConsumed(uint32_t amount) {
                                       stream_host_, amount));
 }
 
-void QuicStreamProxy::WriteData(std::vector<uint8_t> data, bool fin) {
+void QuicStreamProxy::WriteData(Vector<uint8_t> data, bool fin) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   PostCrossThreadTask(*host_thread(), FROM_HERE,
                       CrossThreadBind(&QuicStreamHost::WriteData, stream_host_,
@@ -80,7 +80,7 @@ void QuicStreamProxy::OnRemoteReset() {
   delegate_copy->OnRemoteReset();
 }
 
-void QuicStreamProxy::OnDataReceived(std::vector<uint8_t> data, bool fin) {
+void QuicStreamProxy::OnDataReceived(Vector<uint8_t> data, bool fin) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(delegate_);
   // Need to copy the |delegate_| member since Delete() will destroy |this|.

third_party/blink/renderer/modules/peerconnection/adapters/quic_stream_proxy.h

@@ -9,6 +9,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_checker.h"
+#include "third_party/blink/renderer/platform/wtf/vector.h"
 
 namespace blink {
 
@@ -44,7 +45,7 @@ class QuicStreamProxy final : public base::SupportsWeakPtr<QuicStreamProxy> {
     // Called when the remote side resets the stream.
     virtual void OnRemoteReset() {}
     // Called when the remote side receives data and/or the finish bit.
-    virtual void OnDataReceived(std::vector<uint8_t> data, bool fin) {}
+    virtual void OnDataReceived(Vector<uint8_t> data, bool fin) {}
     // Called when data written with WriteData() has been consumed by QUIC.
     virtual void OnWriteDataConsumed(uint32_t amount) {}
   };
@@ -70,7 +71,7 @@ class QuicStreamProxy final : public base::SupportsWeakPtr<QuicStreamProxy> {
 
   void Reset();
   void MarkReceivedDataConsumed(uint32_t amount);
-  void WriteData(std::vector<uint8_t> data, bool fin);
+  void WriteData(Vector<uint8_t> data, bool fin);
 
  private:
   // Instruct the QuicTransportProxy to remove and delete this stream proxy.
@@ -79,7 +80,7 @@ class QuicStreamProxy final : public base::SupportsWeakPtr<QuicStreamProxy> {
   // Callbacks from QuicStreamHost.
   friend class QuicStreamHost;
   void OnRemoteReset();
-  void OnDataReceived(std::vector<uint8_t> data, bool fin);
+  void OnDataReceived(Vector<uint8_t> data, bool fin);
   void OnWriteDataConsumed(uint32_t amount);
 
   // Up reference. Owned by the QuicTransportProxy client.

third_party/blink/renderer/modules/peerconnection/adapters/test/mock_p2p_quic_stream.h

@@ -15,7 +15,7 @@ class MockP2PQuicStream : public testing::NiceMock<P2PQuicStream> {
   // P2PQuicStream overrides.
   MOCK_METHOD0(Reset, void());
   MOCK_METHOD1(SetDelegate, void(Delegate*));
-  MOCK_METHOD2(WriteData, void(std::vector<uint8_t>, bool));
+  MOCK_METHOD2(WriteData, void(Vector<uint8_t>, bool));
   MOCK_METHOD1(MarkReceivedDataConsumed, void(uint32_t));
 };
 

third_party/blink/renderer/modules/peerconnection/adapters/test/mock_p2p_quic_stream_delegate.h

@@ -16,7 +16,7 @@ class MockP2PQuicStreamDelegate
   // P2PQuicStream::Delegate overrides.
   MOCK_METHOD1(OnWriteDataConsumed, void(uint32_t));
   MOCK_METHOD0(OnRemoteReset, void());
-  MOCK_METHOD2(OnDataReceived, void(std::vector<uint8_t>, bool));
+  MOCK_METHOD2(OnDataReceived, void(Vector<uint8_t>, bool));
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/peerconnection/adapters/web_rtc_cross_thread_copier.h

@@ -86,12 +86,6 @@ struct CrossThreadCopier<std::pair<cricket::Candidate, cricket::Candidate>>
   STATIC_ONLY(CrossThreadCopier);
 };
 
-template <>
-struct CrossThreadCopier<std::vector<uint8_t>>
-    : public CrossThreadCopierPassThrough<std::vector<uint8_t>> {
-  STATIC_ONLY(CrossThreadCopier);
-};
-
 }  // namespace blink
 
 #endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_WEB_RTC_CROSS_THREAD_COPIER_H_

third_party/blink/renderer/modules/peerconnection/rtc_quic_stream.cc

@@ -92,7 +92,7 @@ void RTCQuicStream::OnRemoteReset() {
   DispatchEvent(*Event::Create(event_type_names::kStatechange));
 }
 
-void RTCQuicStream::OnDataReceived(std::vector<uint8_t> data, bool fin) {
+void RTCQuicStream::OnDataReceived(Vector<uint8_t> data, bool fin) {
   if (!fin) {
     return;
   }

third_party/blink/renderer/modules/peerconnection/rtc_quic_stream.h

@@ -55,7 +55,7 @@ class MODULES_EXPORT RTCQuicStream final : public EventTargetWithInlineData,
 
   // QuicStreamProxy::Delegate overrides.
   void OnRemoteReset() override;
-  void OnDataReceived(std::vector<uint8_t> data, bool fin) override;
+  void OnDataReceived(Vector<uint8_t> data, bool fin) override;
   void OnWriteDataConsumed(uint32_t amount) override;
 
   Member<RTCQuicTransport> transport_;

third_party/blink/renderer/platform/cross_thread_copier.h

@@ -182,6 +182,13 @@ struct CrossThreadCopier<
   }
 };
 
+template <wtf_size_t inlineCapacity, typename Allocator>
+struct CrossThreadCopier<Vector<uint8_t, inlineCapacity, Allocator>> {
+  STATIC_ONLY(CrossThreadCopier);
+  using Type = Vector<uint8_t, inlineCapacity, Allocator>;
+  static Type Copy(Type value) { return value; }
+};
+
 template <wtf_size_t inlineCapacity, typename Allocator>
 struct CrossThreadCopier<Vector<uint64_t, inlineCapacity, Allocator>> {
   STATIC_ONLY(CrossThreadCopier);