Change scoped_ptr to std::unique_ptr in //net.

net/server/web_socket_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/server/web_socket_encoder.h"
 
 #include <limits>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/websockets/websocket_deflate_parameters.h"
 #include "net/websockets/websocket_extension.h"
 #include "net/websockets/websocket_extension_parser.h"
 
 namespace net {
 
 const char WebSocketEncoder::kClientExtensions[] =
@@ skipping 157 matching lines @@
       frame.push_back(data[i] ^ mask_bytes[i % kMaskingKeyWidthInBytes]);
   } else {
     frame.insert(frame.end(), data, data + data_length);
   }
   *output = std::string(&frame[0], frame.size());
 }
 
 }  // anonymous namespace
 
 // static
-scoped_ptr<WebSocketEncoder> WebSocketEncoder::CreateServer() {
-  return make_scoped_ptr(new WebSocketEncoder(FOR_SERVER, nullptr, nullptr));
+std::unique_ptr<WebSocketEncoder> WebSocketEncoder::CreateServer() {
+  return base::WrapUnique(new WebSocketEncoder(FOR_SERVER, nullptr, nullptr));
 }
 
 // static
-scoped_ptr<WebSocketEncoder> WebSocketEncoder::CreateServer(
+std::unique_ptr<WebSocketEncoder> WebSocketEncoder::CreateServer(
     const std::string& extensions,
     WebSocketDeflateParameters* deflate_parameters) {
   WebSocketExtensionParser parser;
   if (!parser.Parse(extensions)) {
     // Failed to parse Sec-WebSocket-Extensions header. We MUST fail the
     // connection.
     return nullptr;
   }
 
   for (const auto& extension : parser.extensions()) {
     std::string failure_message;
     WebSocketDeflateParameters offer;
     if (!offer.Initialize(extension, &failure_message) ||
         !offer.IsValidAsRequest(&failure_message)) {
       // We decline unknown / malformed extensions.
       continue;
     }
 
     WebSocketDeflateParameters response = offer;
     if (offer.is_client_max_window_bits_specified() &&
         !offer.has_client_max_window_bits_value()) {
       // We need to choose one value for the response.
       response.SetClientMaxWindowBits(15);
     }
     DCHECK(response.IsValidAsResponse());
     DCHECK(offer.IsCompatibleWith(response));
-    auto deflater = make_scoped_ptr(
+    auto deflater = base::WrapUnique(
         new WebSocketDeflater(response.server_context_take_over_mode()));
-    auto inflater = make_scoped_ptr(
+    auto inflater = base::WrapUnique(
         new WebSocketInflater(kInflaterChunkSize, kInflaterChunkSize));
     if (!deflater->Initialize(response.PermissiveServerMaxWindowBits()) ||
         !inflater->Initialize(response.PermissiveClientMaxWindowBits())) {
       // For some reason we cannot accept the parameters.
       continue;
     }
     *deflate_parameters = response;
-    return make_scoped_ptr(new WebSocketEncoder(FOR_SERVER, std::move(deflater),
-                                                std::move(inflater)));
+    return base::WrapUnique(new WebSocketEncoder(
+        FOR_SERVER, std::move(deflater), std::move(inflater)));
   }
 
   // We cannot find an acceptable offer.
-  return make_scoped_ptr(new WebSocketEncoder(FOR_SERVER, nullptr, nullptr));
+  return base::WrapUnique(new WebSocketEncoder(FOR_SERVER, nullptr, nullptr));
 }
 
 // static
-scoped_ptr<WebSocketEncoder> WebSocketEncoder::CreateClient(
+std::unique_ptr<WebSocketEncoder> WebSocketEncoder::CreateClient(
     const std::string& response_extensions) {
   // TODO(yhirano): Add a way to return an error.
 
   WebSocketExtensionParser parser;
   if (!parser.Parse(response_extensions)) {
     // Parse error. Note that there are two cases here.
     // 1) There is no Sec-WebSocket-Extensions header.
     // 2) There is a malformed Sec-WebSocketExtensions header.
     // We should return a deflate-disabled encoder for the former case and
     // fail the connection for the latter case.
-    return make_scoped_ptr(new WebSocketEncoder(FOR_CLIENT, nullptr, nullptr));
+    return base::WrapUnique(new WebSocketEncoder(FOR_CLIENT, nullptr, nullptr));
   }
   if (parser.extensions().size() != 1) {
     // Only permessage-deflate extension is supported.
     // TODO (yhirano): Fail the connection.
-    return make_scoped_ptr(new WebSocketEncoder(FOR_CLIENT, nullptr, nullptr));
+    return base::WrapUnique(new WebSocketEncoder(FOR_CLIENT, nullptr, nullptr));
   }
   const auto& extension = parser.extensions()[0];
   WebSocketDeflateParameters params;
   std::string failure_message;
   if (!params.Initialize(extension, &failure_message) ||
       !params.IsValidAsResponse(&failure_message)) {
     // TODO (yhirano): Fail the connection.
-    return make_scoped_ptr(new WebSocketEncoder(FOR_CLIENT, nullptr, nullptr));
+    return base::WrapUnique(new WebSocketEncoder(FOR_CLIENT, nullptr, nullptr));
   }
 
-  auto deflater = make_scoped_ptr(
+  auto deflater = base::WrapUnique(
       new WebSocketDeflater(params.client_context_take_over_mode()));
-  auto inflater = make_scoped_ptr(
+  auto inflater = base::WrapUnique(
       new WebSocketInflater(kInflaterChunkSize, kInflaterChunkSize));
   if (!deflater->Initialize(params.PermissiveClientMaxWindowBits()) ||
       !inflater->Initialize(params.PermissiveServerMaxWindowBits())) {
     // TODO (yhirano): Fail the connection.
-    return make_scoped_ptr(new WebSocketEncoder(FOR_CLIENT, nullptr, nullptr));
+    return base::WrapUnique(new WebSocketEncoder(FOR_CLIENT, nullptr, nullptr));
   }
 
-  return make_scoped_ptr(new WebSocketEncoder(FOR_CLIENT, std::move(deflater),
-                                              std::move(inflater)));
+  return base::WrapUnique(new WebSocketEncoder(FOR_CLIENT, std::move(deflater),
+                                               std::move(inflater)));
 }
 
 WebSocketEncoder::WebSocketEncoder(Type type,
-                                   scoped_ptr<WebSocketDeflater> deflater,
-                                   scoped_ptr<WebSocketInflater> inflater)
+                                   std::unique_ptr<WebSocketDeflater> deflater,
+                                   std::unique_ptr<WebSocketInflater> inflater)
     : type_(type),
       deflater_(std::move(deflater)),
       inflater_(std::move(inflater)) {}
 
 WebSocketEncoder::~WebSocketEncoder() {}
 
 WebSocket::ParseResult WebSocketEncoder::DecodeFrame(
     const base::StringPiece& frame,
     int* bytes_consumed,
     std::string* output) {
@@ skipping 51 matching lines @@
     return false;
   scoped_refptr<IOBufferWithSize> buffer =
       deflater_->GetOutput(deflater_->CurrentOutputSize());
   if (!buffer.get())
     return false;
   *output = std::string(buffer->data(), buffer->size());
   return true;
 }
 
 }  // namespace net