Convert Pass()→std::move() 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/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"
@@ skipping 112 matching lines @@
   }
 
   RequestQuery query = ParseQuery(request_url);
 
   scoped_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 failed_response.Pass();
+      return std::move(failed_response);
     }
   }
 
   if (query.find("expected_headers") != query.end()) {
     for (const auto& header : query["expected_headers"]) {
       if (header.find(":") == std::string::npos)
-        return failed_response.Pass();
+        return std::move(failed_response);
       std::string key = header.substr(0, header.find(":"));
       std::string value = header.substr(header.find(":") + 1);
       if (request.headers.find(key) == request.headers.end() ||
           request.headers.at(key) != value) {
-        return failed_response.Pass();
+        return std::move(failed_response);
       }
     }
   }
 
   // Trim the first byte ('/').
   DCHECK(base::StartsWith(relative_path, "/", base::CompareCase::SENSITIVE));
   std::string request_path = relative_path.substr(1);
   base::FilePath file_path(server_root.AppendASCII(request_path));
   std::string file_contents;
   if (!base::ReadFileToString(file_path, &file_contents)) {
     file_path = file_path.AppendASCII("index.html");
     if (!base::ReadFileToString(file_path, &file_contents))
       return nullptr;
   }
 
   if (request.method == METHOD_HEAD)
     file_contents = "";
 
   if (query.find("replace_text") != query.end()) {
     for (const auto& replacement : query["replace_text"]) {
       if (replacement.find(":") == std::string::npos)
-        return failed_response.Pass();
+        return std::move(failed_response);
       std::string find;
       std::string with;
       base::Base64Decode(replacement.substr(0, replacement.find(":")), &find);
       base::Base64Decode(replacement.substr(replacement.find(":") + 1), &with);
       base::ReplaceSubstringsAfterOffset(&file_contents, 0, find, with);
     }
   }
 
   base::FilePath headers_path(
       file_path.AddExtension(FILE_PATH_LITERAL("mock-http-headers")));
@@ skipping 27 matching lines @@
                              file_contents.size()));
 
       file_contents = file_contents.substr(start, end - start + 1);
     }
   }
 
   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 http_response.Pass();
+  return std::move(http_response);
 }
 
 }  // namespace test_server
 }  // namespace net