Implement SpdyMakeUnique and SpdyWrapUnique.

net/spdy/core/spdy_deframer_visitor.cc

 // Copyright 2016 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_deframer_visitor.h"
 
 #include <stdlib.h>
 
 #include <algorithm>
 #include <cstdint>
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.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 "net/spdy/platform/api/spdy_string_piece.h"
 
-using ::base::MakeUnique;
 using ::testing::AssertionFailure;
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
 
 namespace net {
 namespace test {
 
 // Specify whether to process headers as request or response in visitor-related
 // params.
 enum class HeaderDirection { REQUEST, RESPONSE };
@@ skipping 198 matching lines @@
 
  private:
   std::unique_ptr<SpdyDeframerVisitorInterface> listener_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyTestDeframerImpl);
 };
 
 // static
 std::unique_ptr<SpdyTestDeframer> SpdyTestDeframer::CreateConverter(
     std::unique_ptr<SpdyDeframerVisitorInterface> listener) {
-  return MakeUnique<SpdyTestDeframerImpl>(std::move(listener));
+  return SpdyMakeUnique<SpdyTestDeframerImpl>(std::move(listener));
 }
 
 void SpdyTestDeframerImpl::AtDataEnd() {
   DVLOG(1) << "AtDataEnd";
   CHECK_EQ(data_len_, padding_len_ + data_->size());
-  auto ptr = MakeUnique<SpdyDataIR>(stream_id_, std::move(*data_));
+  auto ptr = SpdyMakeUnique<SpdyDataIR>(stream_id_, std::move(*data_));
   CHECK_EQ(0u, data_->size());
   data_.reset();
 
   CHECK_LE(0u, padding_len_);
   CHECK_LE(padding_len_, 256u);
   if (padding_len_ > 0) {
     ptr->set_padding_len(padding_len_);
   }
   padding_len_ = 0;
 
   ptr->set_fin(fin_);
   listener_->OnData(std::move(ptr));
   frame_type_ = UNSET;
   fin_ = false;
   data_len_ = 0;
 }
 
 void SpdyTestDeframerImpl::AtGoAwayEnd() {
   DVLOG(1) << "AtDataEnd";
   CHECK_EQ(frame_type_, GOAWAY);
   CHECK(goaway_description_);
   if (goaway_description_->empty()) {
     listener_->OnGoAway(std::move(goaway_ir_));
   } else {
-    listener_->OnGoAway(MakeUnique<SpdyGoAwayIR>(
+    listener_->OnGoAway(SpdyMakeUnique<SpdyGoAwayIR>(
         goaway_ir_->last_good_stream_id(), goaway_ir_->error_code(),
         std::move(*goaway_description_)));
     CHECK_EQ(0u, goaway_description_->size());
   }
   goaway_description_.reset();
   goaway_ir_.reset();
   frame_type_ = UNSET;
 }
 
 void SpdyTestDeframerImpl::AtHeadersEnd() {
@@ skipping 125 matching lines @@
 // Overridden methods from SpdyFramerVisitorInterface in alpha order...
 
 void SpdyTestDeframerImpl::OnAltSvc(
     SpdyStreamId stream_id,
     SpdyStringPiece origin,
     const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) {
   DVLOG(1) << "OnAltSvc stream_id: " << stream_id;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   CHECK_GT(stream_id, 0u);
-  auto ptr = MakeUnique<SpdyAltSvcIR>(stream_id);
+  auto ptr = SpdyMakeUnique<SpdyAltSvcIR>(stream_id);
   ptr->set_origin(SpdyString(origin));
   for (auto& altsvc : altsvc_vector) {
     ptr->add_altsvc(altsvc);
   }
   listener_->OnAltSvc(std::move(ptr));
 }
 
 // A CONTINUATION frame contains a Header Block Fragment, and immediately
 // follows another frame that contains a Header Block Fragment (HEADERS,
 // PUSH_PROMISE or CONTINUATION). The last such frame has the END flag set.
@@ skipping 19 matching lines @@
   DVLOG(1) << "OnDataFrameHeader stream_id: " << stream_id;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   CHECK_GT(stream_id, 0u);
   CHECK_EQ(data_.get(), nullptr);
   frame_type_ = DATA;
 
   stream_id_ = stream_id;
   fin_ = fin;
   data_len_ = length;
-  data_.reset(new SpdyString());
+  data_ = SpdyMakeUnique<SpdyString>();
 }
 
 // The SpdyFramer will not process any more data at this point.
 void SpdyTestDeframerImpl::OnError(SpdyFramer* framer) {
   DVLOG(1) << "SpdyFramer detected an error in the stream: "
            << SpdyFramer::SpdyFramerErrorToString(framer->spdy_framer_error())
            << "     frame_type_: " << Http2FrameTypeToString(frame_type_);
   listener_->OnError(framer, this);
 }
 
 // Received a GOAWAY frame from the peer. The last stream id it accepted from us
 // is |last_accepted_stream_id|. |status| is a protocol defined error code.
 // The frame may also contain data. After this OnGoAwayFrameData will be called
 // for any non-zero amount of data, and after that it will be called with len==0
 // to indicate the end of the GOAWAY frame.
 void SpdyTestDeframerImpl::OnGoAway(SpdyStreamId last_good_stream_id,
                                     SpdyErrorCode error_code) {
   DVLOG(1) << "OnGoAway last_good_stream_id: " << last_good_stream_id
            << "     error code: " << error_code;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   frame_type_ = GOAWAY;
-  goaway_ir_ = MakeUnique<SpdyGoAwayIR>(last_good_stream_id, error_code, "");
-  goaway_description_.reset(new SpdyString());
+  goaway_ir_ =
+      SpdyMakeUnique<SpdyGoAwayIR>(last_good_stream_id, error_code, "");
+  goaway_description_ = SpdyMakeUnique<SpdyString>();
 }
 
 // If len==0 then we've reached the end of the GOAWAY frame.
 bool SpdyTestDeframerImpl::OnGoAwayFrameData(const char* goaway_data,
                                              size_t len) {
   DVLOG(1) << "OnGoAwayFrameData";
   CHECK_EQ(frame_type_, GOAWAY) << "   frame_type_="
                                 << Http2FrameTypeToString(frame_type_);
   CHECK(goaway_description_);
   goaway_description_->append(goaway_data, len);
@@ skipping 28 matching lines @@
   DVLOG(1) << "OnHeaders stream_id: " << stream_id;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   CHECK_GT(stream_id, 0u);
   frame_type_ = HEADERS;
 
   stream_id_ = stream_id;
   fin_ = fin;
   end_ = end;
 
-  headers_.reset(new StringPairVector());
-  headers_handler_.reset(new TestHeadersHandler());
-  headers_ir_ = MakeUnique<SpdyHeadersIR>(stream_id);
+  headers_ = SpdyMakeUnique<StringPairVector>();
+  headers_handler_ = SpdyMakeUnique<TestHeadersHandler>();
+  headers_ir_ = SpdyMakeUnique<SpdyHeadersIR>(stream_id);
   headers_ir_->set_fin(fin);
   if (has_priority) {
     headers_ir_->set_has_priority(true);
     headers_ir_->set_weight(weight);
     headers_ir_->set_parent_stream_id(parent_stream_id);
     headers_ir_->set_exclusive(exclusive);
   }
 }
 
 // The HTTP/2 protocol refers to the payload, |unique_id| here, as 8 octets of
 // opaque data that is to be echoed back to the sender, with the ACK bit added.
 // It isn't defined as a counter,
 // or frame id, as the SpdyPingId naming might imply.
 // Responding to a PING is supposed to be at the highest priority.
 void SpdyTestDeframerImpl::OnPing(uint64_t unique_id, bool is_ack) {
   DVLOG(1) << "OnPing unique_id: " << unique_id
            << "      is_ack: " << (is_ack ? "true" : "false");
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
-  auto ptr = MakeUnique<SpdyPingIR>(unique_id);
+  auto ptr = SpdyMakeUnique<SpdyPingIR>(unique_id);
   if (is_ack) {
     ptr->set_is_ack(is_ack);
     listener_->OnPingAck(std::move(ptr));
   } else {
     listener_->OnPing(std::move(ptr));
   }
 }
 
 void SpdyTestDeframerImpl::OnPriority(SpdyStreamId stream_id,
                                       SpdyStreamId parent_stream_id,
                                       int weight,
                                       bool exclusive) {
   DVLOG(1) << "OnPriority stream_id: " << stream_id;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   CHECK_GT(stream_id, 0u);
 
-  listener_->OnPriority(MakeUnique<SpdyPriorityIR>(stream_id, parent_stream_id,
-                                                   weight, exclusive));
+  listener_->OnPriority(SpdyMakeUnique<SpdyPriorityIR>(
+      stream_id, parent_stream_id, weight, exclusive));
 }
 
 void SpdyTestDeframerImpl::OnPushPromise(SpdyStreamId stream_id,
                                          SpdyStreamId promised_stream_id,
                                          bool end) {
   DVLOG(1) << "OnPushPromise stream_id: " << stream_id;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   CHECK_GT(stream_id, 0u);
 
   frame_type_ = PUSH_PROMISE;
   stream_id_ = stream_id;
   end_ = end;
 
-  headers_.reset(new StringPairVector());
-  headers_handler_.reset(new TestHeadersHandler());
+  headers_ = SpdyMakeUnique<StringPairVector>();
+  headers_handler_ = SpdyMakeUnique<TestHeadersHandler>();
   push_promise_ir_ =
-      MakeUnique<SpdyPushPromiseIR>(stream_id, promised_stream_id);
+      SpdyMakeUnique<SpdyPushPromiseIR>(stream_id, promised_stream_id);
 }
 
 // Closes the specified stream. After this the sender may still send PRIORITY
 // frames for this stream, which we can ignore.
 void SpdyTestDeframerImpl::OnRstStream(SpdyStreamId stream_id,
                                        SpdyErrorCode error_code) {
   DVLOG(1) << "OnRstStream stream_id: " << stream_id
            << "     error code: " << error_code;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   CHECK_GT(stream_id, 0u);
 
-  listener_->OnRstStream(MakeUnique<SpdyRstStreamIR>(stream_id, error_code));
+  listener_->OnRstStream(
+      SpdyMakeUnique<SpdyRstStreamIR>(stream_id, error_code));
 }
 
 // Called for an individual setting. There is no negotiation, the sender is
 // stating the value that the sender is using.
 void SpdyTestDeframerImpl::OnSetting(SpdySettingsIds id, uint32_t value) {
   DVLOG(1) << "OnSetting id: " << id << std::hex << "    value: " << value;
   CHECK_EQ(frame_type_, SETTINGS) << "   frame_type_="
                                   << Http2FrameTypeToString(frame_type_);
   CHECK(settings_);
   settings_->push_back(std::make_pair(id, value));
   settings_ir_->AddSetting(id, value);
 }
 
 // Called at the start of a SETTINGS frame with setting entries, but not the
 // (required) ACK of a SETTINGS frame. There is no stream_id because
 // the settings apply to the entire connection, not to an individual stream.
 // The |clear_persisted| flag is a pre-HTTP/2 remnant.
 void SpdyTestDeframerImpl::OnSettings(bool /*clear_persisted*/) {
   DVLOG(1) << "OnSettings";
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   CHECK_EQ(nullptr, settings_ir_.get());
   CHECK_EQ(nullptr, settings_.get());
   frame_type_ = SETTINGS;
   ack_ = false;
 
-  settings_.reset(new SettingVector());
-  settings_ir_.reset(new SpdySettingsIR());
+  settings_ = SpdyMakeUnique<SettingVector>();
+  settings_ir_ = SpdyMakeUnique<SpdySettingsIR>();
 }
 
 void SpdyTestDeframerImpl::OnSettingsAck() {
   DVLOG(1) << "OnSettingsAck";
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
-  auto ptr = MakeUnique<SpdySettingsIR>();
+  auto ptr = SpdyMakeUnique<SpdySettingsIR>();
   ptr->set_is_ack(true);
   listener_->OnSettingsAck(std::move(ptr));
 }
 
 void SpdyTestDeframerImpl::OnSettingsEnd() {
   DVLOG(1) << "OnSettingsEnd";
   CHECK_EQ(frame_type_, SETTINGS) << "   frame_type_="
                                   << Http2FrameTypeToString(frame_type_);
   CHECK(!ack_);
   CHECK_NE(nullptr, settings_ir_.get());
@@ skipping 51 matching lines @@
 // closed.
 void SpdyTestDeframerImpl::OnWindowUpdate(SpdyStreamId stream_id,
                                           int delta_window_size) {
   DVLOG(1) << "OnWindowUpdate stream_id: " << stream_id
            << "    delta_window_size: " << delta_window_size;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   CHECK_NE(0, delta_window_size);
 
   listener_->OnWindowUpdate(
-      MakeUnique<SpdyWindowUpdateIR>(stream_id, delta_window_size));
+      SpdyMakeUnique<SpdyWindowUpdateIR>(stream_id, delta_window_size));
 }
 
 // Return true to indicate that the stream_id is valid; if not valid then
 // SpdyFramer considers the connection corrupted. Requires keeping track
 // of the set of currently open streams. For now we'll assume that unknown
 // frame types are unsupported.
 bool SpdyTestDeframerImpl::OnUnknownFrame(SpdyStreamId stream_id,
                                           uint8_t frame_type) {
   DVLOG(1) << "OnAltSvc stream_id: " << stream_id;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
@@ skipping 47 matching lines @@
   CHECK(!got_hpack_end_);
   got_hpack_end_ = true;
 }
 
 class LoggingSpdyDeframerDelegate : public SpdyDeframerVisitorInterface {
  public:
   explicit LoggingSpdyDeframerDelegate(
       std::unique_ptr<SpdyDeframerVisitorInterface> wrapped)
       : wrapped_(std::move(wrapped)) {
     if (!wrapped_) {
-      wrapped_ = MakeUnique<SpdyDeframerVisitorInterface>();
+      wrapped_ = SpdyMakeUnique<SpdyDeframerVisitorInterface>();
     }
   }
   ~LoggingSpdyDeframerDelegate() override {}
 
   void OnAltSvc(std::unique_ptr<SpdyAltSvcIR> frame) override {
     DVLOG(1) << "LoggingSpdyDeframerDelegate::OnAltSvc";
     wrapped_->OnAltSvc(std::move(frame));
   }
   void OnData(std::unique_ptr<SpdyDataIR> frame) override {
     DVLOG(1) << "LoggingSpdyDeframerDelegate::OnData";
@@ skipping 69 matching lines @@
   }
 
  private:
   std::unique_ptr<SpdyDeframerVisitorInterface> wrapped_;
 };
 
 // static
 std::unique_ptr<SpdyDeframerVisitorInterface>
 SpdyDeframerVisitorInterface::LogBeforeVisiting(
     std::unique_ptr<SpdyDeframerVisitorInterface> wrapped_listener) {
-  return MakeUnique<LoggingSpdyDeframerDelegate>(std::move(wrapped_listener));
+  return SpdyMakeUnique<LoggingSpdyDeframerDelegate>(
+      std::move(wrapped_listener));
 }
 
 CollectedFrame::CollectedFrame() {}
 
 CollectedFrame::CollectedFrame(CollectedFrame&& other)
     : frame_ir(std::move(other.frame_ir)),
       headers(std::move(other.headers)),
       settings(std::move(other.settings)),
       error_reported(other.error_reported) {}
 
@@ skipping 137 matching lines @@
 // The SpdyFramer will not process any more data at this point.
 void DeframerCallbackCollector::OnError(SpdyFramer* framer,
                                         SpdyTestDeframer* deframer) {
   CollectedFrame cf;
   cf.error_reported = true;
   collected_frames_->push_back(std::move(cf));
 }
 
 }  // namespace test
 }  // namespace net