Revert "Revert 202112 "GTTF: Convert most tests in content to use Embedd...""

chrome/browser/google_apis/gdata_wapi_operations_unittest.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <map>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 91 matching lines @@
       const net::test_server::HttpRequest& request) {
     http_request_ = request;
 
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     std::string remaining_path;
     if (absolute_url.path() == "/feeds/default/private/full" &&
         request.method == net::test_server::METHOD_POST) {
       // This is a request for copying a document.
       // TODO(satorux): we should generate valid JSON data for the newly
       // copied document but for now, just return "file_entry.json"
-      return test_util::CreateHttpResponseFromFile(
-          test_util::GetTestFilePath("chromeos/gdata/file_entry.json"));
+      scoped_ptr<net::test_server::BasicHttpResponse> result(
+          test_util::CreateHttpResponseFromFile(
+              test_util::GetTestFilePath("chromeos/gdata/file_entry.json")));
+      return result.PassAs<net::test_server::HttpResponse>();
     }
 
     if (!test_util::RemovePrefix(absolute_url.path(),
                                  "/feeds/default/private/full",
                                  &remaining_path)) {
       return scoped_ptr<net::test_server::HttpResponse>();
     }
 
     if (remaining_path.empty()) {
       // Process the default feed.
-      return test_util::CreateHttpResponseFromFile(
-          test_util::GetTestFilePath("chromeos/gdata/root_feed.json"));
+      scoped_ptr<net::test_server::BasicHttpResponse> result(
+          test_util::CreateHttpResponseFromFile(
+              test_util::GetTestFilePath("chromeos/gdata/root_feed.json")));
+      return result.PassAs<net::test_server::HttpResponse>();
     } else {
       // Process a feed for a single resource ID.
       const std::string resource_id = net::UnescapeURLComponent(
           remaining_path.substr(1), net::UnescapeRule::URL_SPECIAL_CHARS);
       if (resource_id == "file:2_file_resource_id") {
-        return test_util::CreateHttpResponseFromFile(
-            test_util::GetTestFilePath("chromeos/gdata/file_entry.json"));
+        scoped_ptr<net::test_server::BasicHttpResponse> result(
+            test_util::CreateHttpResponseFromFile(
+                test_util::GetTestFilePath("chromeos/gdata/file_entry.json")));
+        return result.PassAs<net::test_server::HttpResponse>();
       } else if (resource_id == "folder:root/contents" &&
                  request.method == net::test_server::METHOD_POST) {
         // This is a request for creating a directory in the root directory.
         // TODO(satorux): we should generate valid JSON data for the newly
         // created directory but for now, just return "directory_entry.json"
-        return test_util::CreateHttpResponseFromFile(
-            test_util::GetTestFilePath("chromeos/gdata/directory_entry.json"));
+        scoped_ptr<net::test_server::BasicHttpResponse> result(
+            test_util::CreateHttpResponseFromFile(
+                test_util::GetTestFilePath(
+                    "chromeos/gdata/directory_entry.json")));
+        return result.PassAs<net::test_server::HttpResponse>();
       } else if (resource_id ==
                  "folder:root/contents/file:2_file_resource_id" &&
                  request.method == net::test_server::METHOD_DELETE) {
         // This is a request for deleting a file from the root directory.
         // TODO(satorux): Investigate what's returned from the server, and
         // copy it. For now, just return a random file, as the contents don't
         // matter.
-        return test_util::CreateHttpResponseFromFile(
-            test_util::GetTestFilePath("chromeos/gdata/testfile.txt"));
+        scoped_ptr<net::test_server::BasicHttpResponse> result(
+            test_util::CreateHttpResponseFromFile(
+                test_util::GetTestFilePath("chromeos/gdata/testfile.txt")));
+        return result.PassAs<net::test_server::HttpResponse>();
       } else if (resource_id == "invalid_resource_id") {
         // Check if this is an authorization request for an app.
         // This emulates to return invalid formatted result from the server.
         if (request.method == net::test_server::METHOD_PUT &&
             request.content.find("<docs:authorizedApp>") != std::string::npos) {
-          return test_util::CreateHttpResponseFromFile(
-              test_util::GetTestFilePath("chromeos/gdata/testfile.txt"));
+          scoped_ptr<net::test_server::BasicHttpResponse> result(
+              test_util::CreateHttpResponseFromFile(
+                  test_util::GetTestFilePath("chromeos/gdata/testfile.txt")));
+          return result.PassAs<net::test_server::HttpResponse>();
         }
       }
     }
 
     return scoped_ptr<net::test_server::HttpResponse>();
   }
 
   // Handles a request for fetching a metadata feed.
   scoped_ptr<net::test_server::HttpResponse> HandleMetadataRequest(
       const net::test_server::HttpRequest& request) {
     http_request_ = request;
 
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     if (absolute_url.path() != "/feeds/metadata/default")
       return scoped_ptr<net::test_server::HttpResponse>();
 
-    scoped_ptr<net::test_server::HttpResponse> result(
+    scoped_ptr<net::test_server::BasicHttpResponse> result(
         test_util::CreateHttpResponseFromFile(
             test_util::GetTestFilePath(
                 "chromeos/gdata/account_metadata.json")));
     if (absolute_url.query().find("include-installed-apps=true") ==
         string::npos) {
       // Exclude the list of installed apps.
       scoped_ptr<base::Value> parsed_content(
           base::JSONReader::Read(result->content(), base::JSON_PARSE_RFC));
       CHECK(parsed_content);
 
       // Remove the install apps node.
       base::DictionaryValue* dictionary_value;
       CHECK(parsed_content->GetAsDictionary(&dictionary_value));
       dictionary_value->Remove("entry.docs$installedApp", NULL);
 
       // Write back it as the content of the result.
       std::string content;
       base::JSONWriter::Write(parsed_content.get(), &content);
       result->set_content(content);
     }
 
-    return result.Pass();
+    return result.PassAs<net::test_server::HttpResponse>();
   }
 
   // Handles a request for creating a session for uploading.
   scoped_ptr<net::test_server::HttpResponse> HandleCreateSessionRequest(
       const net::test_server::HttpRequest& request) {
     http_request_ = request;
 
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     if (StartsWithASCII(absolute_url.path(),
                         "/feeds/upload/create-session/default/private/full",
                         true)) {  // case sensitive
       // This is an initiating upload URL.
-      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);
 
       // 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) {
         http_response->set_code(net::test_server::PRECONDITION);
-        return http_response.Pass();
+        return http_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;
 
       http_response->set_code(net::test_server::SUCCESS);
       GURL upload_url;
       // POST is used for a new file, and PUT is used for an existing file.
       if (request.method == net::test_server::METHOD_POST) {
         upload_url = test_server_.GetURL("/upload_new_file");
       } else if (request.method == net::test_server::METHOD_PUT) {
         upload_url = test_server_.GetURL("/upload_existing_file");
       } else {
         return scoped_ptr<net::test_server::HttpResponse>();
       }
       http_response->AddCustomHeader("Location", upload_url.spec());
-      return http_response.Pass();
+      return http_response.PassAs<net::test_server::HttpResponse>();
     }
 
     return scoped_ptr<net::test_server::HttpResponse>();
   }
 
   // Handles a request for uploading content.
   scoped_ptr<net::test_server::HttpResponse> HandleUploadRequest(
       const net::test_server::HttpRequest& request) {
     http_request_ = request;
 
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     if (absolute_url.path() != "/upload_new_file" &&
         absolute_url.path() != "/upload_existing_file") {
       return scoped_ptr<net::test_server::HttpResponse>();
     }
 
     // TODO(satorux): We should create a correct JSON data for the uploaded
     // file, but for now, just return file_entry.json.
-    scoped_ptr<net::test_server::HttpResponse> response =
+    scoped_ptr<net::test_server::BasicHttpResponse> response =
         test_util::CreateHttpResponseFromFile(
             test_util::GetTestFilePath("chromeos/gdata/file_entry.json"));
     // response.code() is set to SUCCESS. Change it to CREATED if it's a new
     // file.
     if (absolute_url.path() == "/upload_new_file")
       response->set_code(net::test_server::CREATED);
 
     // Check if the Content-Range header is present. This must be present if
     // the request body is not empty.
     if (!request.content.empty()) {
@@ skipping 22 matching lines @@
     if (received_bytes_ > 0) {
       response->AddCustomHeader(
           "Range",
           "bytes=0-" + base::Int64ToString(received_bytes_ - 1));
     }
 
     // Change the code to RESUME_INCOMPLETE if upload is not complete.
     if (received_bytes_ < content_length_)
       response->set_code(net::test_server::RESUME_INCOMPLETE);
 
-    return response.Pass();
+    return response.PassAs<net::test_server::HttpResponse>();
   }
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
   net::test_server::EmbeddedTestServer test_server_;
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<OperationRunner> operation_runner_;
   scoped_ptr<GDataWapiUrlGenerator> url_generator_;
@@ skipping 1182 matching lines @@
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
   // For updating an existing file, an empty body should be attached (PUT
   // requires a body)
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("", http_request_.content);
   EXPECT_EQ(kWrongETag, http_request_.headers["If-Match"]);
 }
 
 }  // namespace google_apis