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

net/server/web_socket_encoder.cc

Index: net/server/web_socket_encoder.cc
diff --git a/net/server/web_socket_encoder.cc b/net/server/web_socket_encoder.cc
index d90a156aaae7b855d9596320f59eb8cf7578558e..60a9a47021c8181376504724f090c7099cdca39a 100644
--- a/net/server/web_socket_encoder.cc
+++ b/net/server/web_socket_encoder.cc
@@ -9,6 +9,7 @@
 #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"
@@ -186,12 +187,12 @@ void EncodeFrameHybi17(const std::string& message,
 }  // 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;
@@ -218,9 +219,9 @@ scoped_ptr<WebSocketEncoder> WebSocketEncoder::CreateServer(
     }
     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())) {
@@ -228,16 +229,16 @@ scoped_ptr<WebSocketEncoder> WebSocketEncoder::CreateServer(
       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.
 
@@ -248,12 +249,12 @@ scoped_ptr<WebSocketEncoder> WebSocketEncoder::CreateClient(
     // 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;
@@ -261,26 +262,26 @@ scoped_ptr<WebSocketEncoder> WebSocketEncoder::CreateClient(
   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)) {}