GTTF: convert some tests in chrome to use EmbeddedTestServer patch nr 1

chrome/browser/google_apis/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 "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
@@ skipping 132 matching lines @@
       // The request is not the "Children: delete" request. 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::BasicHttpResponse> http_response(
         new net::test_server::BasicHttpResponse);
-    http_response->set_code(net::test_server::NO_CONTENT);
+    http_response->set_code(net::HTTP_NO_CONTENT);
     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()) {
@@ skipping 27 matching lines @@
 
     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);
+      response->set_code(net::HTTP_PRECONDITION_FAILED);
       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->set_code(net::HTTP_OK);
     response->AddCustomHeader(
         "Location",
         test_server_.base_url().Resolve(expected_upload_path_).spec());
     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.
@@ skipping 24 matching lines @@
       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::BasicHttpResponse> response(
           new net::test_server::BasicHttpResponse);
       // Set RESUME INCOMPLETE (308) status code.
-      response->set_code(net::test_server::RESUME_INCOMPLETE);
+      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.PassAs<net::test_server::HttpResponse>();
     }
 
     // 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("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);
+      response->set_code(net::HTTP_CREATED);
     }
 
     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::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse);
-    response->set_code(net::test_server::SUCCESS);
+    response->set_code(net::HTTP_OK);
     response->set_content_type(expected_content_type_);
     response->set_content(expected_content_);
     return response.PassAs<net::test_server::HttpResponse>();
   }
 
   // These are for the current upload file status.
   int64 received_bytes_;
   int64 content_length_;
 };
 
@@ skipping 1049 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