Implement SpdyMakeUnique and SpdyWrapUnique.

net/spdy/core/spdy_framer.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 <string.h>
 
 #include <algorithm>
 #include <cctype>
@@ skipping 14 matching lines @@
 #include "net/spdy/core/hpack/hpack_constants.h"
 #include "net/spdy/core/hpack/hpack_decoder.h"
 #include "net/spdy/core/hpack/hpack_decoder3.h"
 #include "net/spdy/core/http2_frame_decoder_adapter.h"
 #include "net/spdy/core/spdy_bitmasks.h"
 #include "net/spdy/core/spdy_bug_tracker.h"
 #include "net/spdy/core/spdy_frame_builder.h"
 #include "net/spdy/core/spdy_frame_reader.h"
 #include "net/spdy/core/spdy_framer_decoder_adapter.h"
 #include "net/spdy/platform/api/spdy_estimate_memory_usage.h"
+#include "net/spdy/platform/api/spdy_ptr_util.h"
 #include "net/spdy/platform/api/spdy_string_utils.h"
 
 using std::vector;
 
 namespace net {
 
 namespace {
 
 // Pack parent stream ID and exclusive flag into the format used by HTTP/2
 // headers and priority frames.
@@ skipping 1398 matching lines @@
 size_t SpdyFramer::ProcessAltSvcFramePayload(const char* data, size_t len) {
   if (len == 0) {
     return 0;
   }
 
   // Clamp to the actual remaining payload.
   len = std::min(len, remaining_data_length_);
 
   if (altsvc_scratch_ == nullptr) {
     size_t capacity = current_frame_length_ - GetFrameHeaderSize();
-    altsvc_scratch_.reset(new CharBuffer(capacity));
+    altsvc_scratch_ = SpdyMakeUnique<CharBuffer>(capacity);
   }
   altsvc_scratch_->CopyFrom(data, len);
   remaining_data_length_ -= len;
   if (remaining_data_length_ > 0) {
     return len;
   }
 
   SpdyFrameReader reader(altsvc_scratch_->data(), altsvc_scratch_->len());
   SpdyStringPiece origin;
   bool successful_read = reader.ReadStringPiece16(&origin);
@@ skipping 217 matching lines @@
   }
   if (!has_next_frame_) {
     SPDY_BUG << "SpdyFramer::SpdyFrameIterator::NextFrame called without "
              << "a next frame.";
     return false;
   }
 
   size_t size_without_block = is_first_frame_
                                   ? GetFrameSizeSansBlock()
                                   : framer_->GetContinuationMinimumSize();
-  auto encoding = base::MakeUnique<SpdyString>();
+  auto encoding = SpdyMakeUnique<SpdyString>();
   encoder_->Next(kMaxControlFrameSize - size_without_block, encoding.get());
   has_next_frame_ = encoder_->HasNext();
 
   if (framer_->debug_visitor_ != nullptr) {
     debug_total_size_ += size_without_block;
     debug_total_size_ += encoding->size();
     if (!has_next_frame_) {
       // TODO(birenroy) are these (here and below) still necessary?
       // HTTP2 uses HPACK for header compression. However, continue to
       // use GetSerializedLength() for an apples-to-apples comparision of
@@ skipping 1175 matching lines @@
     ret &= builder->WriteBytes(
         &hpack_encoding[hpack_encoding.size() - bytes_remaining],
         bytes_to_write);
     bytes_remaining -= bytes_to_write;
   }
   return ret;
 }
 
 HpackEncoder* SpdyFramer::GetHpackEncoder() {
   if (hpack_encoder_.get() == nullptr) {
-    hpack_encoder_.reset(new HpackEncoder(ObtainHpackHuffmanTable()));
+    hpack_encoder_ = SpdyMakeUnique<HpackEncoder>(ObtainHpackHuffmanTable());
     if (!compression_enabled()) {
       hpack_encoder_->DisableCompression();
     }
   }
   return hpack_encoder_.get();
 }
 
 HpackDecoderInterface* SpdyFramer::GetHpackDecoder() {
   if (hpack_decoder_.get() == nullptr) {
     if (FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3) {
-      hpack_decoder_.reset(new HpackDecoder3());
+      hpack_decoder_ = SpdyMakeUnique<HpackDecoder3>();
     } else {
-      hpack_decoder_.reset(new HpackDecoder());
+      hpack_decoder_ = SpdyMakeUnique<HpackDecoder>();
     }
   }
   return hpack_decoder_.get();
 }
 
 void SpdyFramer::SetDecoderHeaderTableDebugVisitor(
     std::unique_ptr<HpackHeaderTable::DebugVisitorInterface> visitor) {
   if (decoder_adapter_ != nullptr) {
     decoder_adapter_->SetDecoderHeaderTableDebugVisitor(std::move(visitor));
   } else {
@@ skipping 38 matching lines @@
   builder->WriteUInt32(header_block.size());
 
   // Serialize each header.
   for (const auto& header : header_block) {
     builder->WriteStringPiece32(base::ToLowerASCII(header.first));
     builder->WriteStringPiece32(header.second);
   }
 }
 
 }  // namespace net