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

net/test/embedded_test_server/request_handler_util.cc

 // Copyright 2015 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/test/embedded_test_server/request_handler_util.h"
 
 #include <stdlib.h>
+
 #include <ctime>
 #include <sstream>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/base/escape.h"
 #include "net/base/url_util.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_util.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "url/gurl.h"
 
@@ skipping 43 matching lines @@
 
 }  // namespace
 
 bool ShouldHandle(const HttpRequest& request, const std::string& path_prefix) {
   GURL url = request.GetURL();
   return url.path() == path_prefix ||
          base::StartsWith(url.path(), path_prefix + "/",
                           base::CompareCase::SENSITIVE);
 }
 
-scoped_ptr<HttpResponse> HandlePrefixedRequest(
+std::unique_ptr<HttpResponse> HandlePrefixedRequest(
     const std::string& prefix,
     const EmbeddedTestServer::HandleRequestCallback& handler,
     const HttpRequest& request) {
   if (ShouldHandle(request, prefix))
     return handler.Run(request);
   return nullptr;
 }
 
 RequestQuery ParseQuery(const GURL& url) {
   RequestQuery queries;
@@ skipping 22 matching lines @@
     new_file_path += "replace_text=";
     new_file_path += base64_old;
     new_file_path += ":";
     new_file_path += base64_new;
   }
 
   *replacement_path = new_file_path;
 }
 
 // Handles |request| by serving a file from under |server_root|.
-scoped_ptr<HttpResponse> HandleFileRequest(const base::FilePath& server_root,
-                                           const HttpRequest& request) {
+std::unique_ptr<HttpResponse> HandleFileRequest(
+    const base::FilePath& server_root,
+    const HttpRequest& request) {
   // This is a test-only server. Ignore I/O thread restrictions.
   // TODO(svaldez): Figure out why thread is I/O restricted in the first place.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   // A proxy request will have an absolute path. Simulate the proxy by stripping
   // the scheme, host, and port.
   GURL request_url = request.GetURL();
   std::string relative_path(request_url.path());
 
   std::string post_prefix("/post/");
   if (base::StartsWith(relative_path, post_prefix,
                        base::CompareCase::SENSITIVE)) {
     if (request.method != METHOD_POST)
       return nullptr;
     relative_path = relative_path.substr(post_prefix.size() - 1);
   }
 
   RequestQuery query = ParseQuery(request_url);
 
-  scoped_ptr<BasicHttpResponse> failed_response(new BasicHttpResponse);
+  std::unique_ptr<BasicHttpResponse> failed_response(new BasicHttpResponse);
   failed_response->set_code(HTTP_NOT_FOUND);
 
   if (query.find("expected_body") != query.end()) {
     if (request.content.find(query["expected_body"].front()) ==
         std::string::npos) {
       return std::move(failed_response);
     }
   }
 
   if (query.find("expected_headers") != query.end()) {
@@ skipping 37 matching lines @@
 
   base::FilePath headers_path(
       file_path.AddExtension(FILE_PATH_LITERAL("mock-http-headers")));
 
   if (base::PathExists(headers_path)) {
     std::string headers_contents;
 
     if (!base::ReadFileToString(headers_path, &headers_contents))
       return nullptr;
 
-    return make_scoped_ptr(
+    return base::WrapUnique(
         new RawHttpResponse(headers_contents, file_contents));
   }
 
-  scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+  std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
   http_response->set_code(HTTP_OK);
 
   if (request.headers.find("Range") != request.headers.end()) {
     std::vector<HttpByteRange> ranges;
 
     if (HttpUtil::ParseRangeHeader(request.headers.at("Range"), &ranges) &&
         ranges.size() == 1) {
       ranges[0].ComputeBounds(file_contents.size());
       size_t start = ranges[0].first_byte_position();
       size_t end = ranges[0].last_byte_position();
@@ skipping 10 matching lines @@
 
   http_response->set_content_type(GetContentType(file_path));
   http_response->AddCustomHeader("Accept-Ranges", "bytes");
   http_response->AddCustomHeader("ETag", "'" + file_path.MaybeAsASCII() + "'");
   http_response->set_content(file_contents);
   return std::move(http_response);
 }
 
 }  // namespace test_server
 }  // namespace net