Convert Pass()→std::move() in //google_apis

google_apis/drive/drive_api_requests_unittest.cc

 // Copyright (c) 2013 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 "google_apis/drive/drive_api_requests.h"
+
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "google_apis/drive/drive_api_parser.h"
-#include "google_apis/drive/drive_api_requests.h"
 #include "google_apis/drive/drive_api_url_generator.h"
 #include "google_apis/drive/dummy_auth_service.h"
 #include "google_apis/drive/request_sender.h"
 #include "google_apis/drive/test_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 207 matching lines @@
       // processing to the next handler.
       return scoped_ptr<net::test_server::HttpResponse>();
     }
 
     http_request_ = request;
 
     // Return the response with just "204 No Content" status code.
     scoped_ptr<net::test_server::BasicHttpResponse> http_response(
         new net::test_server::BasicHttpResponse);
     http_response->set_code(net::HTTP_NO_CONTENT);
-    return http_response.Pass();
+    return std::move(http_response);
   }
 
   // Reads the data file of |expected_data_file_path_| and returns its content
   // for the request.
   // To use this method, it is necessary to set |expected_data_file_path_|
   // to the appropriate file path before sending the request to the server.
   scoped_ptr<net::test_server::HttpResponse> HandleDataFileRequest(
       const net::test_server::HttpRequest& request) {
     if (expected_data_file_path_.empty()) {
       // The file is not specified. Delegate the processing to the next
@@ skipping 17 matching lines @@
       // next handler.
       return scoped_ptr<net::test_server::HttpResponse>();
     }
 
     http_request_ = request;
 
     scoped_ptr<net::test_server::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse);
     response->set_code(net::HTTP_NO_CONTENT);
 
-    return response.Pass();
+    return std::move(response);
   }
 
   // Returns PRECONDITION_FAILED response for ETag mismatching with error JSON
   // content specified by |expected_precondition_failed_file_path_|.
   // To use this method, it is necessary to set the variable to the appropriate
   // file path before sending the request to the server.
   scoped_ptr<net::test_server::HttpResponse> HandlePreconditionFailedRequest(
       const net::test_server::HttpRequest& request) {
     if (expected_precondition_failed_file_path_.empty()) {
       // The file is not specified. Delegate the process to the next handler.
       return scoped_ptr<net::test_server::HttpResponse>();
     }
 
     http_request_ = request;
 
     scoped_ptr<net::test_server::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse);
     response->set_code(net::HTTP_PRECONDITION_FAILED);
 
     std::string content;
     if (base::ReadFileToString(expected_precondition_failed_file_path_,
                                &content)) {
       response->set_content(content);
       response->set_content_type("application/json");
     }
 
-    return response.Pass();
+    return std::move(response);
   }
 
   // Returns the response based on set expected upload url.
   // The response contains the url in its "Location: " header. Also, it doesn't
   // have any content.
   // To use this method, it is necessary to set |expected_upload_path_|
   // to the string representation of the url to be returned.
   scoped_ptr<net::test_server::HttpResponse> HandleInitiateUploadRequest(
       const net::test_server::HttpRequest& request) {
     if (request.relative_url == expected_upload_path_ ||
@@ skipping 14 matching lines @@
     if (found == request.headers.end() ||
         !base::StringToInt64(found->second, &content_length_)) {
       return scoped_ptr<net::test_server::HttpResponse>();
     }
     received_bytes_ = 0;
 
     response->set_code(net::HTTP_OK);
     response->AddCustomHeader(
         "Location",
         test_server_.base_url().Resolve(expected_upload_path_).spec());
-    return response.Pass();
+    return std::move(response);
   }
 
   scoped_ptr<net::test_server::HttpResponse> HandleResumeUploadRequest(
       const net::test_server::HttpRequest& request) {
     if (request.relative_url != expected_upload_path_) {
       // The request path is different from the expected path for uploading.
       // Delegate the processing to the next handler.
       return scoped_ptr<net::test_server::HttpResponse>();
     }
 
@@ skipping 29 matching lines @@
       response->set_code(static_cast<net::HttpStatusCode>(308));
 
       // Add Range header to the response, based on the values of
       // Content-Range header in the request.
       // The header is annotated only when at least one byte is received.
       if (received_bytes_ > 0) {
         response->AddCustomHeader(
             "Range", "bytes=0-" + base::Int64ToString(received_bytes_ - 1));
       }
 
-      return response.Pass();
+      return std::move(response);
     }
 
     // All bytes are received. Return the "success" response with the file's
     // (dummy) metadata.
     scoped_ptr<net::test_server::BasicHttpResponse> response =
         test_util::CreateHttpResponseFromFile(
             test_util::GetTestFilePath("drive/file_entry.json"));
 
     // The response code is CREATED if it is new file uploading.
     if (http_request_.relative_url == kTestUploadNewFilePath) {
       response->set_code(net::HTTP_CREATED);
     }
 
-    return response.Pass();
+    return std::move(response);
   }
 
   // Returns the response based on set expected content and its type.
   // To use this method, both |expected_content_type_| and |expected_content_|
   // must be set in advance.
   scoped_ptr<net::test_server::HttpResponse> HandleContentResponse(
       const net::test_server::HttpRequest& request) {
     if (expected_content_type_.empty() || expected_content_.empty()) {
       // Expected content is not set. Delegate the processing to the next
       // handler.
       return scoped_ptr<net::test_server::HttpResponse>();
     }
 
     http_request_ = request;
 
     scoped_ptr<net::test_server::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse);
     response->set_code(net::HTTP_OK);
     response->set_content_type(expected_content_type_);
     response->set_content(expected_content_);
-    return response.Pass();
+    return std::move(response);
   }
 
   // Handles a request for downloading a file.
   scoped_ptr<net::test_server::HttpResponse> HandleDownloadRequest(
       const net::test_server::HttpRequest& request) {
     http_request_ = request;
 
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     std::string id;
     if (!test_util::RemovePrefix(absolute_url.path(),
                                  kTestDownloadPathPrefix,
                                  &id)) {
       return scoped_ptr<net::test_server::HttpResponse>();
     }
 
     // For testing, returns a text with |id| repeated 3 times.
     scoped_ptr<net::test_server::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse);
     response->set_code(net::HTTP_OK);
     response->set_content(id + id + id);
     response->set_content_type("text/plain");
-    return response.Pass();
+    return std::move(response);
   }
 
   scoped_ptr<net::test_server::HttpResponse> HandleBatchUploadRequest(
       const net::test_server::HttpRequest& request) {
     http_request_ = request;
 
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     std::string id;
     if (absolute_url.path() != "/upload/drive")
       return scoped_ptr<net::test_server::HttpResponse>();
@@ skipping 17 matching lines @@
         "--BOUNDARY\r\n"
         "Content-Type: application/http\r\n"
         "\r\n"
         "HTTP/1.1 403 Forbidden\r\n"
         "Content-Type: application/json; charset=UTF-8\r\n"
         "\r\n"
         "{\"error\":{\"errors\": ["
         " {\"reason\": \"userRateLimitExceeded\"}]}}\r\n"
         "\r\n"
         "--BOUNDARY--\r\n");
-    return response.Pass();
+    return std::move(response);
   }
 
   // These are for the current upload file status.
   int64_t received_bytes_;
   int64_t content_length_;
 };
 
 TEST_F(DriveApiRequestsTest, DriveApiDataRequest_Fields) {
   // Make sure that "fields" query param is supported by using its subclass,
   // AboutGetRequest.
@@ skipping 1785 matching lines @@
                                     "Header: value\r\n"
                                     "\r\n"
                                     "BODY\r\n"
                                     "--BOUNDARY-- \t",
                                     &parts));
   ASSERT_EQ(1u, parts.size());
   EXPECT_EQ(HTTP_SUCCESS, parts[0].code);
   EXPECT_EQ("BODY", parts[0].body);
 }
 }  // namespace google_apis