Convert Pass()→std::move() in //components (Android edition)

components/cronet/android/test/native_test_server.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 "native_test_server.h"
+#include "components/cronet/android/test/native_test_server.h"
 
 #include <string>
+#include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/android/path_utils.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
@@ skipping 43 matching lines @@
   std::string file_contents;
   bool read_file = base::ReadFileToString(file_path, &file_contents);
   DCHECK(read_file);
   base::FilePath headers_path(
       file_path.AddExtension(FILE_PATH_LITERAL("mock-http-headers")));
   std::string headers_contents;
   bool read_headers = base::ReadFileToString(headers_path, &headers_contents);
   DCHECK(read_headers);
   scoped_ptr<net::test_server::RawHttpResponse> http_response(
       new net::test_server::RawHttpResponse(headers_contents, file_contents));
-  return http_response.Pass();
+  return http_response;
 }
 
 scoped_ptr<net::test_server::HttpResponse> NativeTestServerRequestHandler(
     const net::test_server::HttpRequest& request) {
   DCHECK(g_test_server);
   scoped_ptr<net::test_server::BasicHttpResponse> response(
       new net::test_server::BasicHttpResponse());
   response->set_content_type("text/plain");
 
   if (request.relative_url == kEchoBodyPath) {
     if (request.has_content) {
       response->set_content(request.content);
     } else {
       response->set_content("Request has no body. :(");
     }
-    return response.Pass();
+    return std::move(response);
   }
 
   if (base::StartsWith(request.relative_url, kEchoHeaderPath,
                        base::CompareCase::SENSITIVE)) {
     GURL url = g_test_server->GetURL(request.relative_url);
     auto it = request.headers.find(url.query());
     if (it != request.headers.end()) {
       response->set_content(it->second);
     } else {
       response->set_content("Header not found. :(");
     }
-    return response.Pass();
+    return std::move(response);
   }
 
   if (request.relative_url == kEchoAllHeadersPath) {
     response->set_content(request.all_headers);
-    return response.Pass();
+    return std::move(response);
   }
 
   if (request.relative_url == kEchoMethodPath) {
     response->set_content(request.method_string);
-    return response.Pass();
+    return std::move(response);
   }
 
   if (request.relative_url == kRedirectToEchoBodyPath) {
     response->set_code(net::HTTP_TEMPORARY_REDIRECT);
     response->AddCustomHeader("Location", kEchoBodyPath);
-    return response.Pass();
+    return std::move(response);
   }
 
   // Unhandled requests result in the Embedded test server sending a 404.
   return scoped_ptr<net::test_server::BasicHttpResponse>();
 }
 
 scoped_ptr<net::test_server::HttpResponse> SdchRequestHandler(
     const net::test_server::HttpRequest& request) {
   DCHECK(g_test_server);
   base::FilePath dir_path;
   bool get_data_dir = base::android::GetDataDirectory(&dir_path);
   DCHECK(get_data_dir);
   dir_path = dir_path.Append(FILE_PATH_LITERAL("test"));
 
   if (base::StartsWith(request.relative_url, kSdchPath,
                        base::CompareCase::SENSITIVE)) {
     base::FilePath file_path = dir_path.Append("sdch/index");
     scoped_ptr<net::test_server::RawHttpResponse> response =
-        ConstructResponseBasedOnFile(file_path).Pass();
+        ConstructResponseBasedOnFile(file_path);
     // Check for query params to see which dictionary to advertise.
     // For instance, ?q=dictionaryA will make the server advertise dictionaryA.
     GURL url = g_test_server->GetURL(request.relative_url);
     std::string dictionary;
     if (!net::GetValueForKeyInQuery(url, "q", &dictionary)) {
       CHECK(false) << "dictionary is not found in query params of "
                    << request.relative_url;
     }
     auto accept_encoding_header = request.headers.find("Accept-Encoding");
     if (accept_encoding_header != request.headers.end()) {
       if (accept_encoding_header->second.find("sdch") != std::string::npos)
         response->AddHeader(base::StringPrintf(
             "Get-Dictionary: %s%s", kSdchDictPath, dictionary.c_str()));
     }
-    return response.Pass();
+    return std::move(response);
   }
 
   if (base::StartsWith(request.relative_url, kSdchTestPath,
                        base::CompareCase::SENSITIVE)) {
     auto avail_dictionary_header = request.headers.find("Avail-Dictionary");
     if (avail_dictionary_header != request.headers.end()) {
       base::FilePath file_path = dir_path.Append(
           "sdch/" + avail_dictionary_header->second + "_encoded");
-      return ConstructResponseBasedOnFile(file_path).Pass();
+      return ConstructResponseBasedOnFile(file_path);
     }
     scoped_ptr<net::test_server::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse());
     response->set_content_type("text/plain");
     response->set_content("Sdch is not used.\n");
-    return response.Pass();
+    return std::move(response);
   }
 
   // Unhandled requests result in the Embedded test server sending a 404.
   return scoped_ptr<net::test_server::BasicHttpResponse>();
 }
 
 void RegisterHostResolverProcHelper(
     net::URLRequestContext* url_request_context) {
   net::HostResolverImpl* resolver =
       static_cast<net::HostResolverImpl*>(url_request_context->host_resolver());
@@ skipping 144 matching lines @@
 #else
   return JNI_FALSE;
 #endif
 }
 
 bool RegisterNativeTestServer(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace cronet