Get rid of RequestRegistry (part 3): remove Drive path from request objects.

chrome/browser/google_apis/gdata_wapi_requests_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 898 matching lines @@
 
   // 1) Get the upload URL for uploading a new file.
   InitiateUploadNewFileRequest* initiate_request =
       new InitiateUploadNewFileRequest(
           request_sender_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code, &upload_url)),
-          base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
           "text/plain",
           kUploadContent.size(),
           "folder:id",
           "New file");
 
   request_sender_->StartRequestWithRetry(initiate_request);
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_new_file"), upload_url);
@@ skipping 20 matching lines @@
   UploadRangeResponse response;
   scoped_ptr<ResourceEntry> new_entry;
 
   ResumeUploadRequest* resume_request = new ResumeUploadRequest(
       request_sender_.get(),
       request_context_getter_.get(),
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&response, &new_entry)),
       ProgressCallback(),
-      base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
       upload_url,
       0,  // start_position
       kUploadContent.size(),  // end_position (exclusive)
       kUploadContent.size(),  // content_length,
       "text/plain",  // content_type
       kTestFilePath);
 
   request_sender_->StartRequestWithRetry(resume_request);
   base::MessageLoop::current()->Run();
 
@@ skipping 10 matching lines @@
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ(kUploadContent, http_request_.content);
 
   // Check the response.
   EXPECT_EQ(HTTP_CREATED, response.code);  // Because it's a new file
   // The start and end positions should be set to -1, if an upload is complete.
   EXPECT_EQ(-1, response.start_position_received);
   EXPECT_EQ(-1, response.end_position_received);
 }
 
-// TODO(kinaba): crbug.com/{241241,164098} Re-enable the test.
-#define NO_GET_UPLOAD_STATUS_TEST
-
 // This test exercises InitiateUploadNewFileRequest and ResumeUploadRequest
 // for a scenario of uploading a new *large* file, which requires multiple
 // requests of ResumeUploadRequest. GetUploadRequest is also tested in this
 // test case.
 TEST_F(GDataWapiRequestsTest, UploadNewLargeFile) {
   const size_t kMaxNumBytes = 10;
   // This is big enough to cause multiple requests of ResumeUploadRequest
   // as we are going to send at most kMaxNumBytes at a time.
   // So, sending "kMaxNumBytes * 2 + 1" bytes ensures three
   // ResumeUploadRequests, which are start, middle and last requests.
   const std::string kUploadContent(kMaxNumBytes * 2 + 1, 'a');
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("upload_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kUploadContent));
 
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // 1) Get the upload URL for uploading a new file.
   InitiateUploadNewFileRequest* initiate_request =
       new InitiateUploadNewFileRequest(
           request_sender_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code, &upload_url)),
-          base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
           "text/plain",
           kUploadContent.size(),
           "folder:id",
           "New file");
 
   request_sender_->StartRequestWithRetry(initiate_request);
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_new_file"), upload_url);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ(
       "/feeds/upload/create-session/default/private/full/folder%3Aid/contents"
       "?convert=false&v=3&alt=json&showroot=true",
       http_request_.relative_url);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\" "
             "xmlns:docs=\"http://schemas.google.com/docs/2007\">\n"
             " <title>New file</title>\n"
             "</entry>\n",
             http_request_.content);
 
-#if !defined(NO_GET_UPLOAD_STATUS_TEST)
   // 2) Before sending any data, check the current status.
   // This is an edge case test for GetUploadStatusRequest
   // (UploadRangeRequestBase).
   {
     UploadRangeResponse response;
     scoped_ptr<ResourceEntry> new_entry;
 
     // Check the response by GetUploadStatusRequest.
     GetUploadStatusRequest* get_upload_status_request =
         new GetUploadStatusRequest(
             request_sender_.get(),
             request_context_getter_.get(),
             CreateComposedCallback(
                 base::Bind(&test_util::RunAndQuit),
                 test_util::CreateCopyResultCallback(&response, &new_entry)),
-            base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
             upload_url,
             kUploadContent.size());
     request_sender_->StartRequestWithRetry(get_upload_status_request);
     base::MessageLoop::current()->Run();
 
     // METHOD_PUT should be used to upload data.
     EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
     // Request should go to the upload URL.
     EXPECT_EQ(upload_url.path(), http_request_.relative_url);
     // Content-Range header should be added.
     EXPECT_EQ("bytes */" + base::Int64ToString(kUploadContent.size()),
               http_request_.headers["Content-Range"]);
     EXPECT_TRUE(http_request_.has_content);
     EXPECT_TRUE(http_request_.content.empty());
 
     // Check the response.
     EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
     EXPECT_EQ(0, response.start_position_received);
     EXPECT_EQ(0, response.end_position_received);
   }
-#endif  // NO_GET_UPLOAD_STATUS_TEST
 
   // 3) Upload the content to the upload URL with multiple requests.
   size_t num_bytes_consumed = 0;
   for (size_t start_position = 0; start_position < kUploadContent.size();
        start_position += kMaxNumBytes) {
     SCOPED_TRACE(testing::Message("start_position: ") << start_position);
 
     // The payload is at most kMaxNumBytes.
     const size_t remaining_size = kUploadContent.size() - start_position;
     const std::string payload = kUploadContent.substr(
         start_position, std::min(kMaxNumBytes, remaining_size));
     num_bytes_consumed += payload.size();
     // The end position is exclusive.
     const size_t end_position = start_position + payload.size();
 
     UploadRangeResponse response;
     scoped_ptr<ResourceEntry> new_entry;
 
     ResumeUploadRequest* resume_request = new ResumeUploadRequest(
         request_sender_.get(),
         request_context_getter_.get(),
         CreateComposedCallback(
             base::Bind(&test_util::RunAndQuit),
             test_util::CreateCopyResultCallback(&response, &new_entry)),
         ProgressCallback(),
-        base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
         upload_url,
         start_position,
         end_position,
         kUploadContent.size(),  // content_length,
         "text/plain",  // content_type
         kTestFilePath);
 
     request_sender_->StartRequestWithRetry(resume_request);
     base::MessageLoop::current()->Run();
 
@@ skipping 20 matching lines @@
       EXPECT_EQ(-1, response.end_position_received);
       // The upload process is completed, so exit from the loop.
       break;
     }
 
     EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
     EXPECT_EQ(0, response.start_position_received);
     EXPECT_EQ(static_cast<int64>(end_position),
               response.end_position_received);
 
-#if !defined(NO_GET_UPLOAD_STATUS_TEST)
     // Check the response by GetUploadStatusRequest.
     GetUploadStatusRequest* get_upload_status_request =
         new GetUploadStatusRequest(
             request_sender_.get(),
             request_context_getter_.get(),
             CreateComposedCallback(
                 base::Bind(&test_util::RunAndQuit),
                 test_util::CreateCopyResultCallback(&response, &new_entry)),
-            base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
             upload_url,
             kUploadContent.size());
-    request_sender_->StartRequestWithRetry(get_upload_request);
+    request_sender_->StartRequestWithRetry(get_upload_status_request);
     base::MessageLoop::current()->Run();
 
     // METHOD_PUT should be used to upload data.
     EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
     // Request should go to the upload URL.
     EXPECT_EQ(upload_url.path(), http_request_.relative_url);
     // Content-Range header should be added.
     EXPECT_EQ("bytes */" + base::Int64ToString(kUploadContent.size()),
               http_request_.headers["Content-Range"]);
     EXPECT_TRUE(http_request_.has_content);
     EXPECT_TRUE(http_request_.content.empty());
 
     // Check the response.
     EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
     EXPECT_EQ(0, response.start_position_received);
     EXPECT_EQ(static_cast<int64>(end_position),
               response.end_position_received);
-#endif  // NO_GET_UPLOAD_STATUS_TEST
   }
 
   EXPECT_EQ(kUploadContent.size(), num_bytes_consumed);
 }
 
 // This test exercises InitiateUploadNewFileRequest and ResumeUploadRequest
 // for a scenario of uploading a new *empty* file.
 //
 // The test is almost identical to UploadNewFile. The only difference is the
 // expectation for the Content-Range header.
 TEST_F(GDataWapiRequestsTest, UploadNewEmptyFile) {
   const std::string kUploadContent;
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("empty_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kUploadContent));
 
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // 1) Get the upload URL for uploading a new file.
   InitiateUploadNewFileRequest* initiate_request =
       new InitiateUploadNewFileRequest(
           request_sender_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code, &upload_url)),
-          base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
           "text/plain",
           kUploadContent.size(),
           "folder:id",
           "New file");
 
   request_sender_->StartRequestWithRetry(initiate_request);
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_new_file"), upload_url);
@@ skipping 20 matching lines @@
   UploadRangeResponse response;
   scoped_ptr<ResourceEntry> new_entry;
 
   ResumeUploadRequest* resume_request = new ResumeUploadRequest(
       request_sender_.get(),
       request_context_getter_.get(),
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&response, &new_entry)),
       ProgressCallback(),
-      base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
       upload_url,
       0,  // start_position
       kUploadContent.size(),  // end_position (exclusive)
       kUploadContent.size(),  // content_length,
       "text/plain",  // content_type
       kTestFilePath);
 
   request_sender_->StartRequestWithRetry(resume_request);
   base::MessageLoop::current()->Run();
 
@@ skipping 28 matching lines @@
 
   // 1) Get the upload URL for uploading an existing file.
   InitiateUploadExistingFileRequest* initiate_request =
       new InitiateUploadExistingFileRequest(
           request_sender_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code, &upload_url)),
-          base::FilePath::FromUTF8Unsafe("drive/existingfile.txt"),
           "text/plain",
           kUploadContent.size(),
           "file:foo",
           std::string() /* etag */);
 
   request_sender_->StartRequestWithRetry(initiate_request);
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_existing_file"), upload_url);
@@ skipping 19 matching lines @@
   UploadRangeResponse response;
   scoped_ptr<ResourceEntry> new_entry;
 
   ResumeUploadRequest* resume_request = new ResumeUploadRequest(
       request_sender_.get(),
       request_context_getter_.get(),
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&response, &new_entry)),
       ProgressCallback(),
-      base::FilePath::FromUTF8Unsafe("drive/existingfile.txt"),
       upload_url,
       0,  // start_position
       kUploadContent.size(),  // end_position (exclusive)
       kUploadContent.size(),  // content_length,
       "text/plain",  // content_type
       kTestFilePath);
 
   request_sender_->StartRequestWithRetry(resume_request);
   base::MessageLoop::current()->Run();
 
@@ skipping 30 matching lines @@
 
   // 1) Get the upload URL for uploading an existing file.
   InitiateUploadExistingFileRequest* initiate_request =
       new InitiateUploadExistingFileRequest(
           request_sender_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code, &upload_url)),
-          base::FilePath::FromUTF8Unsafe("drive/existingfile.txt"),
           "text/plain",
           kUploadContent.size(),
           "file:foo",
           kTestETag);
 
   request_sender_->StartRequestWithRetry(initiate_request);
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_existing_file"), upload_url);
@@ skipping 19 matching lines @@
   UploadRangeResponse response;
   scoped_ptr<ResourceEntry> new_entry;
 
   ResumeUploadRequest* resume_request = new ResumeUploadRequest(
       request_sender_.get(),
       request_context_getter_.get(),
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&response, &new_entry)),
       ProgressCallback(),
-      base::FilePath::FromUTF8Unsafe("drive/existingfile.txt"),
       upload_url,
       0,  // start_position
       kUploadContent.size(),  // end_position (exclusive)
       kUploadContent.size(),  // content_length,
       "text/plain",  // content_type
       kTestFilePath);
 
   request_sender_->StartRequestWithRetry(resume_request);
   base::MessageLoop::current()->Run();
 
@@ skipping 26 matching lines @@
   GURL upload_url;
 
   InitiateUploadExistingFileRequest* initiate_request =
       new InitiateUploadExistingFileRequest(
           request_sender_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code, &upload_url)),
-          base::FilePath::FromUTF8Unsafe("drive/existingfile.txt"),
           "text/plain",
           kUploadContent.size(),
           "file:foo",
           kWrongETag);
 
   request_sender_->StartRequestWithRetry(initiate_request);
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_PRECONDITION, result_code);
   // For updating an existing file, METHOD_PUT should be used.
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full/file%3Afoo"
             "?convert=false&v=3&alt=json&showroot=true",
             http_request_.relative_url);
   // Even though the body is empty, the content type should be set to
   // "text/plain".
   EXPECT_EQ("text/plain", http_request_.headers["Content-Type"]);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   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