Clean up spdy_framer_test.cc.

net/spdy/spdy_framer_test.cc

 // Copyright (c) 2012 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/spdy/spdy_framer.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 #include <cstdint>
 #include <limits>
 #include <memory>
 #include <tuple>
+#include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/spdy/array_output_buffer.h"
 #include "net/spdy/hpack/hpack_constants.h"
@@ skipping 58 matching lines @@
     DecompressionVisitor() : finished_(false) {}
 
     const SpdyFrameIR& GetFrame() const {
       CHECK(finished_);
       return *frame_;
     }
 
     SpdyHeadersHandlerInterface* OnHeaderFrameStart(
         SpdyStreamId stream_id) override {
       if (headers_handler_ == nullptr) {
-        headers_handler_.reset(new TestHeadersHandler);
+        headers_handler_ = base::MakeUnique<TestHeadersHandler>();
       }
       return headers_handler_.get();
     }
 
     void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) override {
       CHECK(!finished_);
       frame_->set_header_block(headers_handler_->decoded_block().Clone());
       finished_ = true;
       if (end_headers) {
         headers_handler_.reset();
       }
     }
 
     void OnHeaders(SpdyStreamId stream_id,
                    bool has_priority,
                    int weight,
                    SpdyStreamId parent_stream_id,
                    bool exclusive,
                    bool fin,
                    bool end) override {
-      SpdyHeadersIR* headers = new SpdyHeadersIR(stream_id);
+      auto headers = base::MakeUnique<SpdyHeadersIR>(stream_id);
       headers->set_has_priority(has_priority);
       headers->set_weight(weight);
       headers->set_parent_stream_id(parent_stream_id);
       headers->set_exclusive(exclusive);
       headers->set_fin(fin);
-      frame_.reset(headers);
+      frame_ = std::move(headers);
     }
 
     void OnPushPromise(SpdyStreamId stream_id,
                        SpdyStreamId promised_stream_id,
                        bool end) override {
-      SpdyPushPromiseIR* push_promise =
-          new SpdyPushPromiseIR(stream_id, promised_stream_id);
-      frame_.reset(push_promise);
+      frame_ =
+          base::MakeUnique<SpdyPushPromiseIR>(stream_id, promised_stream_id);
     }
 
     // TODO(birenroy): Add support for CONTINUATION.
     void OnContinuation(SpdyStreamId stream_id, bool end) override {
       LOG(FATAL);
     }
 
     // All other methods just LOG(FATAL).
     void OnError(SpdyFramer* framer) override { LOG(FATAL); }
     void OnDataFrameHeader(SpdyStreamId stream_id,
@@ skipping 50 matching lines @@
     DISALLOW_COPY_AND_ASSIGN(DecompressionVisitor);
   };
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFramerTestUtil);
 };
 
 MATCHER_P(IsFrameUnionOf, frame_list, "") {
   size_t size_verified = 0;
   for (const auto& frame : *frame_list) {
-    if (arg.size() >= size_verified + frame.size()) {
-      if (!memcmp(arg.data() + size_verified, frame.data(), frame.size())) {
-        size_verified += frame.size();
-      } else {
-        CompareCharArraysWithHexError(
-            "Header serialization methods should be equivalent: ",
-            reinterpret_cast<unsigned char*>(arg.data() + size_verified),
-            frame.size(), reinterpret_cast<unsigned char*>(frame.data()),
-            frame.size());
-        return false;
-      }
-    } else {
+    if (arg.size() < size_verified + frame.size()) {
       LOG(FATAL) << "Incremental header serialization should not lead to a "
                  << "higher total frame length than non-incremental method.";
       return false;
     }
+    if (memcmp(arg.data() + size_verified, frame.data(), frame.size())) {
+      CompareCharArraysWithHexError(
+          "Header serialization methods should be equivalent: ",
+          reinterpret_cast<unsigned char*>(arg.data() + size_verified),
+          frame.size(), reinterpret_cast<unsigned char*>(frame.data()),
+          frame.size());
+      return false;
+    }
+    size_verified += frame.size();
   }
   return size_verified == arg.size();
 }
 
 class SpdyFramerPeer {
  public:
   static size_t ControlFrameBufferSize() {
     return SpdyFramer::kControlFrameBufferSize;
   }
   static size_t GetNumberRequiredContinuationFrames(SpdyFramer* framer,
@@ skipping 94 matching lines @@
         last_push_promise_promised_stream_(0),
         data_bytes_(0),
         fin_frame_count_(0),
         fin_flag_count_(0),
         end_of_stream_count_(0),
         control_frame_header_data_count_(0),
         zero_length_control_frame_header_data_count_(0),
         data_frame_count_(0),
         last_payload_len_(0),
         last_frame_len_(0),
-        header_buffer_(new char[kDefaultHeaderBufferSize]),
+        header_buffer_(kDefaultHeaderBufferSize),
         header_buffer_length_(0),
-        header_buffer_size_(kDefaultHeaderBufferSize),
         header_stream_id_(static_cast<SpdyStreamId>(-1)),
         header_control_type_(SpdyFrameType::DATA),
         header_buffer_valid_(false) {}
 
   void OnError(SpdyFramer* f) override {
     VLOG(1) << "SpdyFramer Error: "
             << SpdyFramer::SpdyFramerErrorToString(f->spdy_framer_error());
     ++error_count_;
   }
 
@@ skipping 24 matching lines @@
 
   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {
     VLOG(1) << "OnStreamPadding(" << stream_id << ", " << len << ")\n";
     EXPECT_EQ(header_stream_id_, stream_id);
     data_bytes_ += len;
   }
 
   SpdyHeadersHandlerInterface* OnHeaderFrameStart(
       SpdyStreamId stream_id) override {
     if (headers_handler_ == nullptr) {
-      headers_handler_.reset(new TestHeadersHandler);
+      headers_handler_ = base::MakeUnique<TestHeadersHandler>();
     }
     return headers_handler_.get();
   }
 
   void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) override {
     CHECK(headers_handler_ != nullptr);
     headers_ = headers_handler_->decoded_block().Clone();
     header_bytes_received_ = headers_handler_->header_bytes_parsed();
     if (end_headers) {
       headers_handler_.reset();
@@ skipping 77 matching lines @@
   void OnAltSvc(SpdyStreamId stream_id,
                 SpdyStringPiece origin,
                 const SpdyAltSvcWireFormat::AlternativeServiceVector&
                     altsvc_vector) override {
     VLOG(1) << "OnAltSvc(" << stream_id << ", \"" << origin
             << "\", altsvc_vector)";
     test_altsvc_ir_.set_stream_id(stream_id);
     if (origin.length() > 0) {
       test_altsvc_ir_.set_origin(SpdyString(origin));
     }
-    for (const SpdyAltSvcWireFormat::AlternativeService& altsvc :
-         altsvc_vector) {
+    for (const auto& altsvc : altsvc_vector) {
       test_altsvc_ir_.add_altsvc(altsvc);
     }
     ++altsvc_count_;
   }
 
   void OnPriority(SpdyStreamId stream_id,
                   SpdyStreamId parent_stream_id,
                   int weight,
                   bool exclusive) override {
     VLOG(1) << "OnPriority(" << stream_id << ", " << parent_stream_id << ", "
@@ skipping 42 matching lines @@
       input_ptr += bytes_processed;
     }
   }
 
   void InitHeaderStreaming(SpdyFrameType header_control_type,
                            SpdyStreamId stream_id) {
     if (!IsDefinedFrameType(SerializeFrameType(header_control_type))) {
       DLOG(FATAL) << "Attempted to init header streaming with "
                   << "invalid control frame type: " << header_control_type;
     }
-    memset(header_buffer_.get(), 0, header_buffer_size_);
+    std::fill(header_buffer_.begin(), header_buffer_.end(), 0);
     header_buffer_length_ = 0;
     header_stream_id_ = stream_id;
     header_control_type_ = header_control_type;
     header_buffer_valid_ = true;
     DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
   }
 
   void set_extension_visitor(ExtensionVisitorInterface* extension) {
     framer_.set_extension_visitor(extension);
   }
 
   // Override the default buffer size (16K). Call before using the framer!
   void set_header_buffer_size(size_t header_buffer_size) {
-    header_buffer_size_ = header_buffer_size;
-    header_buffer_.reset(new char[header_buffer_size]);
+    header_buffer_.resize(header_buffer_size);
   }
 
   // Largest control frame that the SPDY implementation sends, including the
   // size of the header.
   static size_t sent_control_frame_max_size() {
     return SpdyFramer::kMaxControlFrameSize;
   }
 
   // Largest control frame that the SPDY implementation is willing to receive,
   // excluding the size of the header.
@@ skipping 29 matching lines @@
   int fin_flag_count_;       // The count of frames with the FIN flag set.
   int end_of_stream_count_;  // The count of zero-length data frames.
   int control_frame_header_data_count_;  // The count of chunks received.
   // The count of zero-length control frame header data chunks received.
   int zero_length_control_frame_header_data_count_;
   int data_frame_count_;
   size_t last_payload_len_;
   size_t last_frame_len_;
 
   // Header block streaming state:
-  std::unique_ptr<char[]> header_buffer_;
+  std::vector<char> header_buffer_;
   size_t header_buffer_length_;
-  size_t header_buffer_size_;
   size_t header_bytes_received_;
   SpdyStreamId header_stream_id_;
   SpdyFrameType header_control_type_;
   bool header_buffer_valid_;
   std::unique_ptr<TestHeadersHandler> headers_handler_;
   SpdyHeaderBlock headers_;
   bool header_has_priority_;
   SpdyStreamId header_parent_stream_id_;
   bool header_exclusive_;
 };
@@ skipping 2247 matching lines @@
   headers.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(SpdyFramerPeer::SerializeHeaders(
       &framer, headers, use_output_ ? &output_ : nullptr));
   TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION);
   visitor.set_header_buffer_size(kHeaderBufferSize);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   // It's up to the visitor to ignore extraneous header data; the framer
   // won't throw an error.
-  EXPECT_GT(visitor.header_bytes_received_, visitor.header_buffer_size_);
+  EXPECT_GT(visitor.header_bytes_received_, visitor.header_buffer_.size());
   EXPECT_EQ(1, visitor.end_of_stream_count_);
 }
 
 TEST_P(SpdyFramerTest, ControlFrameSizesAreValidated) {
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   // Create a GoAway frame that has a few extra bytes at the end.
   // We create enough overhead to overflow the framer's control frame buffer.
   ASSERT_LE(SpdyFramerPeer::ControlFrameBufferSize(), 250u);
   const size_t length = SpdyFramerPeer::ControlFrameBufferSize() + 1;
 
@@ skipping 1143 matching lines @@
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
 
     SpdySerializedFrame frame(framer.SerializePing(SpdyPingIR(42)));
     SetFrameFlags(&frame, flags);
 
-    if (flags & PING_FLAG_ACK) {
-      EXPECT_CALL(visitor, OnPing(42, true));
-    } else {
-      EXPECT_CALL(visitor, OnPing(42, false));
-    }
+    EXPECT_CALL(visitor, OnPing(42, flags & PING_FLAG_ACK));
 
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error())
         << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, WindowUpdateFrameFlags) {
   uint8_t flags = 0;
@@ skipping 332 matching lines @@
   EXPECT_EQ(1, visitor.altsvc_count_);
   ASSERT_EQ(2u, visitor.test_altsvc_ir_.altsvc_vector().size());
   EXPECT_TRUE(visitor.test_altsvc_ir_.altsvc_vector()[0] == altsvc1);
   EXPECT_TRUE(visitor.test_altsvc_ir_.altsvc_vector()[1] == altsvc2);
 }
 
 // While RFC7838 Section 4 says that an ALTSVC frame on stream 0 with empty
 // origin MUST be ignored, it is not implemented at the framer level: instead,
 // such frames are passed on to the consumer.
 TEST_P(SpdyFramerTest, ReadAltSvcFrame) {
-  struct {
+  constexpr struct {
     uint32_t stream_id;
     const char* origin;
   } test_cases[] = {{0, ""},
                     {1, ""},
                     {0, "https://www.example.com"},
                     {1, "https://www.example.com"}};
-  for (auto test_case : test_cases) {
+  for (const auto& test_case : test_cases) {
     SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     SpdyAltSvcIR altsvc_ir(test_case.stream_id);
     SpdyAltSvcWireFormat::AlternativeService altsvc(
         "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector());
     altsvc_ir.add_altsvc(altsvc);
     altsvc_ir.set_origin(test_case.origin);
     SpdySerializedFrame frame(framer.SerializeAltSvc(altsvc_ir));
 
     TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
@@ skipping 159 matching lines @@
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(
              visitor.framer_.spdy_framer_error());
 }
 
 // Test that SpdyFramer processes, by default, all passed input in one call
 // to ProcessInput (i.e. will not be calling set_process_single_input_frame()).
 TEST_P(SpdyFramerTest, ProcessAllInput) {
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
-  std::unique_ptr<TestSpdyVisitor> visitor(
-      new TestSpdyVisitor(SpdyFramer::DISABLE_COMPRESSION));
+  auto visitor =
+      base::MakeUnique<TestSpdyVisitor>(SpdyFramer::DISABLE_COMPRESSION);
   framer.set_visitor(visitor.get());
 
   // Create two input frames.
   SpdyHeadersIR headers(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   headers.SetHeader("cookie", "key1=value1; key2=value2");
   SpdySerializedFrame headers_frame(SpdyFramerPeer::SerializeHeaders(
       &framer, headers, use_output_ ? &output_ : nullptr));
 
@@ skipping 29 matching lines @@
   EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
 }
 
 // Test that SpdyFramer stops after processing a full frame if
 // process_single_input_frame is set. Input to ProcessInput has two frames, but
 // only processes the first when we give it the first frame split at any point,
 // or give it more than one frame in the input buffer.
 TEST_P(SpdyFramerTest, ProcessAtMostOneFrame) {
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_process_single_input_frame(true);
-  std::unique_ptr<TestSpdyVisitor> visitor;
 
   // Create two input frames.
   const char four_score[] = "Four score and ...";
   SpdyDataIR four_score_ir(1, four_score);
   SpdySerializedFrame four_score_frame(framer.SerializeData(four_score_ir));
 
   SpdyHeadersIR headers(2);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   headers.SetHeader("cookie", "key1=value1; key2=value2");
@@ skipping 15 matching lines @@
   input_buffer.append(frame1.data(), frame1_size);
   input_buffer.append(frame2.data(), frame2_size);
 
   const char* buf = input_buffer.data();
   const size_t buf_size = input_buffer.size();
 
   VLOG(1) << "buf_size = " << buf_size;
 
   for (size_t first_size = 0; first_size <= buf_size; ++first_size) {
     VLOG(1) << "first_size = " << first_size;
-    visitor.reset(new TestSpdyVisitor(SpdyFramer::DISABLE_COMPRESSION));
+    auto visitor =
+        base::MakeUnique<TestSpdyVisitor>(SpdyFramer::DISABLE_COMPRESSION);
     framer.set_visitor(visitor.get());
 
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
 
     size_t processed_first = framer.ProcessInput(buf, first_size);
     if (first_size < frame1_size) {
       EXPECT_EQ(first_size, processed_first);
 
       if (first_size == 0) {
         EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
@@ skipping 22 matching lines @@
 
     EXPECT_EQ(1, visitor->data_frame_count_);
     EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
     EXPECT_EQ(0, visitor->headers_frame_count_);
   }
 }
 
 }  // namespace test
 
 }  // namespace net