GTTF: Convert most tests in content to use EmbeddedTestServer.

chrome/browser/google_apis/drive_api_operations_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 "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
@@ skipping 137 matching lines @@
     if (request.method != net::test_server::METHOD_DELETE ||
         request.relative_url.find("/children/") == string::npos) {
       // The request is not the "Children: delete" operation. Delegate the
       // 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::HttpResponse> http_response(
-        new net::test_server::HttpResponse);
+    scoped_ptr<net::test_server::BasicHttpResponse> http_response(
+        new net::test_server::BasicHttpResponse);
     http_response->set_code(net::test_server::NO_CONTENT);
-    return http_response.Pass();
+    return http_response.PassAs<net::test_server::HttpResponse>();
   }
 
   // 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
       // handler.
       return scoped_ptr<net::test_server::HttpResponse>();
     }
 
     http_request_ = request;
 
     // Return the response from the data file.
-    return test_util::CreateHttpResponseFromFile(expected_data_file_path_);
+    return test_util::CreateHttpResponseFromFile(
+        expected_data_file_path_).PassAs<net::test_server::HttpResponse>();
   }
 
   // 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_ ||
         expected_upload_path_.empty()) {
       // The request is for resume uploading or the expected upload url 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::HttpResponse> response(
-        new net::test_server::HttpResponse);
+    scoped_ptr<net::test_server::BasicHttpResponse> response(
+        new net::test_server::BasicHttpResponse);
 
     // Check an ETag.
     std::map<std::string, std::string>::const_iterator found =
         request.headers.find("If-Match");
     if (found != request.headers.end() &&
         found->second != "*" &&
         found->second != kTestETag) {
       response->set_code(net::test_server::PRECONDITION);
-      return response.Pass();
+      return response.PassAs<net::test_server::HttpResponse>();
     }
 
     // Check if the X-Upload-Content-Length is present. If yes, store the
     // length of the file.
     found = request.headers.find("X-Upload-Content-Length");
     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::test_server::SUCCESS);
     response->AddCustomHeader(
         "Location",
         test_server_.base_url().Resolve(expected_upload_path_).spec());
-    return response.Pass();
+    return response.PassAs<net::test_server::HttpResponse>();
   }
 
   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 17 matching lines @@
       }
 
       EXPECT_EQ(start_position, received_bytes_);
       EXPECT_EQ(length, content_length_);
 
       // end_position is inclusive, but so +1 to change the range to byte size.
       received_bytes_ = end_position + 1;
     }
 
     if (received_bytes_ < content_length_) {
-      scoped_ptr<net::test_server::HttpResponse> response(
-          new net::test_server::HttpResponse);
+      scoped_ptr<net::test_server::BasicHttpResponse> response(
+          new net::test_server::BasicHttpResponse);
       // Set RESUME INCOMPLETE (308) status code.
       response->set_code(net::test_server::RESUME_INCOMPLETE);
 
       // 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 response.PassAs<net::test_server::HttpResponse>();
     }
 
     // All bytes are received. Return the "success" response with the file's
     // (dummy) metadata.
-    scoped_ptr<net::test_server::HttpResponse> response =
+    scoped_ptr<net::test_server::BasicHttpResponse> response =
         test_util::CreateHttpResponseFromFile(
             test_util::GetTestFilePath("chromeos/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::test_server::CREATED);
     }
 
-    return response.Pass();
+    return response.PassAs<net::test_server::HttpResponse>();
   }
 
   // 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::HttpResponse> response(
-        new net::test_server::HttpResponse);
+    scoped_ptr<net::test_server::BasicHttpResponse> response(
+        new net::test_server::BasicHttpResponse);
     response->set_code(net::test_server::SUCCESS);
     response->set_content_type(expected_content_type_);
     response->set_content(expected_content_);
-    return response.Pass();
+    return response.PassAs<net::test_server::HttpResponse>();
   }
 
   // These are for the current upload file status.
   int64 received_bytes_;
   int64 content_length_;
 };
 
 TEST_F(DriveApiOperationsTest, GetAboutOperation_ValidJson) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
@@ skipping 985 matching lines @@
   EXPECT_EQ("Conflicting-etag", http_request_.headers["If-Match"]);
 
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("/upload/drive/v2/files/resource_id?uploadType=resumable",
             http_request_.relative_url);
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_TRUE(http_request_.content.empty());
 }
 
 }  // namespace google_apis