Add a platform implementation of QuicTest and QuicTestWithParam

net/quic/core/quic_flow_controller_test.cc

 // Copyright 2014 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 "net/quic/core/quic_flow_controller.h"
 
 #include <memory>
 
 #include "net/quic/platform/api/quic_str_cat.h"
+#include "net/quic/platform/api/quic_test.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_flow_controller_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
-#include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 
 namespace net {
 namespace test {
 
 // Receive window auto-tuning uses RTT in its logic.
 const int64_t kRtt = 100;
 
 class MockFlowController : public QuicFlowControllerInterface {
  public:
   MockFlowController() {}
   ~MockFlowController() override {}
 
   MOCK_METHOD1(EnsureWindowAtLeast, void(QuicByteCount));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockFlowController);
 };
 
-class QuicFlowControllerTest : public ::testing::Test {
+class QuicFlowControllerTest : public QuicTest {
  public:
   QuicFlowControllerTest()
       : stream_id_(1234),
         send_window_(kInitialSessionFlowControlWindowForTest),
         receive_window_(kInitialSessionFlowControlWindowForTest),
         connection_(&helper_, &alarm_factory_, Perspective::IS_CLIENT) {
     FLAGS_quic_reloadable_flag_quic_flow_control_faster_autotune = true;
   }
 
   void Initialize() {
     flow_controller_.reset(new QuicFlowController(
         &connection_, stream_id_, Perspective::IS_CLIENT, send_window_,
         receive_window_, false, &session_flow_controller_));
   }
 
  protected:
   QuicStreamId stream_id_;
   QuicByteCount send_window_;
   QuicByteCount receive_window_;
   std::unique_ptr<QuicFlowController> flow_controller_;
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   MockQuicConnection connection_;
   MockFlowController session_flow_controller_;
-  QuicFlagSaver flag_saver_;
 };
 
 TEST_F(QuicFlowControllerTest, SendingBytes) {
   Initialize();
 
   EXPECT_FALSE(flow_controller_->IsBlocked());
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
   EXPECT_EQ(send_window_, flow_controller_->SendWindowSize());
 
   // Send some bytes, but not enough to block.
@@ skipping 348 matching lines @@
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
 
   QuicByteCount new_threshold =
       QuicFlowControllerPeer::WindowUpdateThreshold(flow_controller_.get());
 
   EXPECT_EQ(new_threshold, threshold);
 }
 
 }  // namespace test
 }  // namespace net