Implement SpdyMakeUnique and SpdyWrapUnique.

net/spdy/core/hpack/hpack_encoder.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/spdy/core/hpack/hpack_encoder.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "net/spdy/core/hpack/hpack_constants.h"
 #include "net/spdy/core/hpack/hpack_header_table.h"
 #include "net/spdy/core/hpack/hpack_huffman_table.h"
 #include "net/spdy/core/hpack/hpack_output_stream.h"
 #include "net/spdy/platform/api/spdy_estimate_memory_usage.h"
+#include "net/spdy/platform/api/spdy_ptr_util.h"
 
 namespace net {
 
 class HpackEncoder::RepresentationIterator {
  public:
   // |pseudo_headers| and |regular_headers| must outlive the iterator.
   RepresentationIterator(const Representations& pseudo_headers,
                          const Representations& regular_headers)
       : pseudo_begin_(pseudo_headers.begin()),
         pseudo_end_(pseudo_headers.end()),
@@ skipping 293 matching lines @@
       CookieToCrumbs(header, &regular_headers_);
     } else if (!header.first.empty() &&
                header.first[0] == kPseudoHeaderPrefix) {
       use_compression ? DecomposeRepresentation(header, &pseudo_headers_)
                       : GatherRepresentation(header, &pseudo_headers_);
     } else {
       use_compression ? DecomposeRepresentation(header, &regular_headers_)
                       : GatherRepresentation(header, &regular_headers_);
     }
   }
-  header_it_ = base::MakeUnique<RepresentationIterator>(pseudo_headers_,
-                                                        regular_headers_);
+  header_it_ =
+      SpdyMakeUnique<RepresentationIterator>(pseudo_headers_, regular_headers_);
 
   encoder_->MaybeEmitTableSize();
 }
 
 void HpackEncoder::Encoderator::Next(size_t max_encoded_bytes,
                                      SpdyString* output) {
   SPDY_BUG_IF(!has_next_)
       << "Encoderator::Next called with nothing left to encode.";
   const bool use_compression = encoder_->enable_compression_;
 
@@ skipping 16 matching lines @@
       encoder_->EmitNonIndexedLiteral(header);
     }
   }
 
   has_next_ = encoder_->output_stream_.size() > max_encoded_bytes;
   encoder_->output_stream_.BoundedTakeString(max_encoded_bytes, output);
 }
 
 std::unique_ptr<HpackEncoder::ProgressiveEncoder> HpackEncoder::EncodeHeaderSet(
     const SpdyHeaderBlock& header_set) {
-  return base::MakeUnique<Encoderator>(header_set, this);
+  return SpdyMakeUnique<Encoderator>(header_set, this);
 }
 
 }  // namespace net