Implement SpdyMakeUnique and SpdyWrapUnique.

net/spdy/core/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/core/spdy_framer.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 11 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/platform/api/quic_flags.h"
 #include "net/spdy/chromium/spdy_flags.h"
 #include "net/spdy/core/array_output_buffer.h"
 #include "net/spdy/core/hpack/hpack_constants.h"
 #include "net/spdy/core/mock_spdy_framer_visitor.h"
 #include "net/spdy/core/spdy_frame_builder.h"
 #include "net/spdy/core/spdy_frame_reader.h"
 #include "net/spdy/core/spdy_protocol.h"
 #include "net/spdy/core/spdy_test_utils.h"
+#include "net/spdy/platform/api/spdy_ptr_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using testing::_;
 
 namespace net {
 
 namespace test {
 
@@ skipping 46 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_ = base::MakeUnique<TestHeadersHandler>();
+        headers_handler_ = SpdyMakeUnique<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 {
-      auto headers = base::MakeUnique<SpdyHeadersIR>(stream_id);
+      auto headers = SpdyMakeUnique<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_ = std::move(headers);
     }
 
     void OnPushPromise(SpdyStreamId stream_id,
                        SpdyStreamId promised_stream_id,
                        bool end) override {
-      frame_ =
-          base::MakeUnique<SpdyPushPromiseIR>(stream_id, promised_stream_id);
+      frame_ = SpdyMakeUnique<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 85 matching lines @@
     return framer->GetNumberRequiredContinuationFrames(size);
   }
   static void SetError(SpdyFramer* framer, SpdyFramer::SpdyFramerError error) {
     framer->set_error(error);
   }
 
   // TODO(dahollings): Remove these methods when deprecating non-incremental
   // header serialization path.
   static std::unique_ptr<SpdyHeadersIR> CloneSpdyHeadersIR(
       const SpdyHeadersIR& headers) {
-    auto newHeaders = base::MakeUnique<SpdyHeadersIR>(
+    auto newHeaders = SpdyMakeUnique<SpdyHeadersIR>(
         headers.stream_id(), headers.header_block().Clone());
     newHeaders->set_fin(headers.fin());
     newHeaders->set_has_priority(headers.has_priority());
     newHeaders->set_weight(headers.weight());
     newHeaders->set_parent_stream_id(headers.parent_stream_id());
     newHeaders->set_exclusive(headers.exclusive());
     if (headers.padded()) {
       newHeaders->set_padding_len(headers.padding_payload_len() + 1);
     }
     newHeaders->set_end_headers(headers.end_headers());
@@ skipping 49 matching lines @@
                               frame_list_buffer.Size() - size_before, false));
     }
     framer->debug_visitor_ = saved_debug_visitor;
 
     EXPECT_THAT(serialized_headers_old_version, IsFrameUnionOf(&frame_list));
     return serialized_headers_old_version;
   }
 
   static std::unique_ptr<SpdyPushPromiseIR> CloneSpdyPushPromiseIR(
       const SpdyPushPromiseIR& push_promise) {
-    auto new_push_promise = base::MakeUnique<SpdyPushPromiseIR>(
+    auto new_push_promise = SpdyMakeUnique<SpdyPushPromiseIR>(
         push_promise.stream_id(), push_promise.promised_stream_id(),
         push_promise.header_block().Clone());
     new_push_promise->set_fin(push_promise.fin());
     if (push_promise.padded()) {
       new_push_promise->set_padding_len(push_promise.padding_payload_len() + 1);
     }
     new_push_promise->set_end_headers(push_promise.end_headers());
     return new_push_promise;
   }
 
@@ skipping 131 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_ = base::MakeUnique<TestHeadersHandler>();
+      headers_handler_ = SpdyMakeUnique<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 775 matching lines @@
 
 // Test that if we receive a CONTINUATION with stream ID zero, we signal an
 // SPDY_INVALID_STREAM_ID.
 TEST_P(SpdyFramerTest, ContinuationWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyContinuationIR continuation(0);
   auto some_nonsense_encoding =
-      base::MakeUnique<SpdyString>("some nonsense encoding");
+      SpdyMakeUnique<SpdyString>("some nonsense encoding");
   continuation.take_encoding(std::move(some_nonsense_encoding));
   continuation.set_end_headers(true);
   SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
   if (use_output_) {
     ASSERT_TRUE(framer.SerializeContinuation(continuation, &output_));
     frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false);
   }
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
@@ skipping 1252 matching lines @@
       0x03,              // Name Len: 3
       0x66, 0x6f, 0x6f,  // foo
       0x03,              // Value Len: 3
       0x62, 0x61, 0x72,  // bar
   };
   // frame-format on
 
   SpdyHeaderBlock header_block;
   header_block["bar"] = "foo";
   header_block["foo"] = "bar";
-  auto buffer = base::MakeUnique<SpdyString>();
+  auto buffer = SpdyMakeUnique<SpdyString>();
   HpackEncoder encoder(ObtainHpackHuffmanTable());
   encoder.DisableCompression();
   encoder.EncodeHeaderSet(header_block, buffer.get());
 
   SpdyContinuationIR continuation(42);
   continuation.take_encoding(std::move(buffer));
   continuation.set_end_headers(true);
 
   SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
   if (use_output_) {
@@ skipping 261 matching lines @@
       control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(1, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 }
 
 TEST_P(SpdyFramerTest, MultipleContinuationFramesWithIterator) {
   SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
-  auto headers = base::MakeUnique<SpdyHeadersIR>(1);
+  auto headers = SpdyMakeUnique<SpdyHeadersIR>(/* stream_id = */ 1);
   headers->set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
   SpdyString big_valuex(kBigValueSize, 'x');
   headers->SetHeader("aa", big_valuex);
   SpdyString big_valuez(kBigValueSize, 'z');
   headers->SetHeader("bb", big_valuez);
 
@@ skipping 45 matching lines @@
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 
   EXPECT_FALSE(frame_it.HasNextFrame());
 }
 
 TEST_P(SpdyFramerTest, PushPromiseFramesWithIterator) {
   SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
-  auto push_promise = base::MakeUnique<SpdyPushPromiseIR>(1, 2);
+  auto push_promise =
+      SpdyMakeUnique<SpdyPushPromiseIR>(/* stream_id = */ 1,
+                                        /* promised_stream_id = */ 2);
   push_promise->set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
   SpdyString big_valuex(kBigValueSize, 'x');
   push_promise->SetHeader("aa", big_valuex);
   SpdyString big_valuez(kBigValueSize, 'z');
   push_promise->SetHeader("bb", big_valuez);
 
@@ skipping 1805 matching lines @@
             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);
   auto visitor =
-      base::MakeUnique<TestSpdyVisitor>(SpdyFramer::DISABLE_COMPRESSION);
+      SpdyMakeUnique<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 65 matching lines @@
   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;
     auto visitor =
-        base::MakeUnique<TestSpdyVisitor>(SpdyFramer::DISABLE_COMPRESSION);
+        SpdyMakeUnique<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