Drive API: Simplify lifetime management of child requests in BatchUploadRequest.

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 "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"
@@ skipping 40 matching lines @@
 const char kTestDownloadPathPrefix[] = "/host/";
 
 // Used as a GetContentCallback.
 void AppendContent(std::string* out,
                    DriveApiErrorCode error,
                    scoped_ptr<std::string> content) {
   EXPECT_EQ(HTTP_SUCCESS, error);
   out->append(*content);
 }
 
-class TestBatchableRequest : public BatchableRequestBase {
+class TestBatchableDelegate : public BatchableDelegate {
  public:
-  TestBatchableRequest(RequestSender* sender,
-                       const GURL url,
-                       const std::string& content_type,
-                       const std::string& content_data,
-                       const base::Closure& callback)
-      : BatchableRequestBase(sender),
-        url_(url),
+  TestBatchableDelegate(const GURL url,
+                        const std::string& content_type,
+                        const std::string& content_data,
+                        const base::Closure& callback)
+      : url_(url),
         content_type_(content_type),
         content_data_(content_data),
         callback_(callback) {}
   GURL GetURL() const override { return url_; }
-  void RunCallbackOnPrematureFailure(DriveApiErrorCode code) override {
-    callback_.Run();
-  }
-  void ProcessURLFetchResults(DriveApiErrorCode code,
-                              const std::string& body) override {
-    callback_.Run();
-  }
   net::URLFetcher::RequestType GetRequestType() const override {
     return net::URLFetcher::PUT;
   }
+  std::vector<std::string> GetExtraRequestHeaders() const override {
+    return std::vector<std::string>();
+  }
+  void Prepare(const PrepareCallback& callback) override {
+    callback.Run(HTTP_SUCCESS);
+  }
   bool GetContentData(std::string* upload_content_type,
                       std::string* upload_content) override {
     upload_content_type->assign(content_type_);
     upload_content->assign(content_data_);
     return true;
   }
-  void OnURLFetchUploadProgress(const net::URLFetcher* source,
-                                int64 current,
-                                int64 total) override {
+  void NotifyError(DriveApiErrorCode code) override { callback_.Run(); }
+  void NotifyResult(DriveApiErrorCode code,
+                    const std::string& body,
+                    const base::Closure& closure) override {
+    callback_.Run();
+    closure.Run();
+  }
+  void NotifyUploadProgress(const net::URLFetcher* source,
+                            int64 current,
+                            int64 total) override {
     progress_values_.push_back(current);
   }
   const std::vector<int64>& progress_values() const { return progress_values_; }
 
  private:
   GURL url_;
   std::string content_type_;
   std::string content_data_;
   base::Closure callback_;
   std::vector<int64> progress_values_;
@@ skipping 1892 matching lines @@
   request_sender_->StartRequestWithRetry(request);
 
   // Create child request.
   DriveApiErrorCode errors[] = {DRIVE_OTHER_ERROR, DRIVE_OTHER_ERROR};
   scoped_ptr<FileResource> file_resources[2];
   base::RunLoop run_loop[2];
   for (int i = 0; i < 2; ++i) {
     const FileResourceCallback callback = test_util::CreateQuitCallback(
         &run_loop[i],
         test_util::CreateCopyResultCallback(&errors[i], &file_resources[i]));
-    drive::MultipartUploadNewFileRequest* const child_request =
-        new drive::MultipartUploadNewFileRequest(
+    drive::MultipartUploadNewFileDelegate* const child_request =
+        new drive::MultipartUploadNewFileDelegate(
             request_sender_.get(), base::StringPrintf("new file title %d", i),
             "parent_resource_id", kTestContentType, kTestContent.size(),
             base::Time(), base::Time(), kTestFilePath, drive::Properties(),
             *url_generator_, callback, ProgressCallback());
     child_request->SetBoundaryForTesting("INNERBOUNDARY");
     request->AddRequest(child_request);
   }
   request->Commit();
   run_loop[0].Run();
   run_loop[1].Run();
@@ skipping 38 matching lines @@
       "Content-Type: text/plain\n"
       "\n"
       "aaaaaaaaaa\n"
       "--INNERBOUNDARY--\n"
       "--OUTERBOUNDARY--",
       http_request_.content);
   EXPECT_EQ(HTTP_SUCCESS, errors[0]);
   ASSERT_TRUE(file_resources[0]);
   EXPECT_EQ("file_id_1", file_resources[0]->file_id());
   ASSERT_FALSE(file_resources[1]);
-  EXPECT_EQ(DRIVE_PARSE_ERROR, errors[1]);
+  EXPECT_EQ(HTTP_SERVICE_UNAVAILABLE, errors[1]);
 }
 
 TEST_F(DriveApiRequestsTest, EmptyBatchUploadRequest) {
   drive::BatchUploadRequest* const request =
       new drive::BatchUploadRequest(request_sender_.get(), *url_generator_);
   base::WeakPtr<drive::BatchUploadRequest> weak_ptr =
       request->GetWeakPtrAsBatchUploadRequest();
   request->Commit();
   ASSERT_FALSE(weak_ptr.get());
 }
 
 TEST_F(DriveApiRequestsTest, BatchUploadRequestWithBodyIncludingZero) {
   // Create batch request.
   drive::BatchUploadRequest* const request =
       new drive::BatchUploadRequest(request_sender_.get(), *url_generator_);
   request->SetBoundaryForTesting("OUTERBOUNDARY");
   request_sender_->StartRequestWithRetry(request);
 
   // Create child request.
   {
     base::RunLoop loop;
-    TestBatchableRequest* child_request = new TestBatchableRequest(
-        request_sender_.get(), GURL("http://example.com/test"),
-        "application/binary", std::string("Apple\0Orange\0", 13),
-        loop.QuitClosure());
+    TestBatchableDelegate* const child_request = new TestBatchableDelegate(
+        GURL("http://example.com/test"), "application/binary",
+        std::string("Apple\0Orange\0", 13), loop.QuitClosure());
     request->AddRequest(child_request);
     request->Commit();
     loop.Run();
   }
 
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("batch", http_request_.headers["X-Goog-Upload-Protocol"]);
   EXPECT_EQ("multipart/mixed; boundary=OUTERBOUNDARY",
             http_request_.headers["Content-Type"]);
   EXPECT_EQ(
       "--OUTERBOUNDARY\n"
       "Content-Type: application/http\n"
       "\n"
       "PUT /test HTTP/1.1\n"
       "Host: 127.0.0.1\n"
       "X-Goog-Upload-Protocol: multipart\n"
       "Content-Type: application/binary\n"
       "\n" +
           std::string("Apple\0Orange\0", 13) +
           "\n"
           "--OUTERBOUNDARY--",
       http_request_.content);
 }
 
 TEST_F(DriveApiRequestsTest, BatchUploadRequestProgress) {
   // Create batch request.
   drive::BatchUploadRequest* const request =
       new drive::BatchUploadRequest(request_sender_.get(), *url_generator_);
-  TestBatchableRequest* requests[] = {
-      new TestBatchableRequest(request_sender_.get(),
-                               GURL("http://example.com/test"),
-                               "application/binary", std::string(100, 'a'),
-                               base::Bind(&EmptyClosure)),
-      new TestBatchableRequest(request_sender_.get(),
-                               GURL("http://example.com/test"),
-                               "application/binary", std::string(50, 'b'),
-                               base::Bind(&EmptyClosure)),
-      new TestBatchableRequest(request_sender_.get(),
-                               GURL("http://example.com/test"),
-                               "application/binary", std::string(0, 'c'),
-                               base::Bind(&EmptyClosure))};
+  TestBatchableDelegate* requests[] = {
+      new TestBatchableDelegate(GURL("http://example.com/test"),
+                                "application/binary", std::string(100, 'a'),
+                                base::Bind(&EmptyClosure)),
+      new TestBatchableDelegate(GURL("http://example.com/test"),
+                                "application/binary", std::string(50, 'b'),
+                                base::Bind(&EmptyClosure)),
+      new TestBatchableDelegate(GURL("http://example.com/test"),
+                                "application/binary", std::string(0, 'c'),
+                                base::Bind(&EmptyClosure))};
   const size_t kExpectedUploadDataPosition[] = {208, 517, 776};
   const size_t kExpectedUploadDataSize = 851;
   request->AddRequest(requests[0]);
   request->AddRequest(requests[1]);
   request->AddRequest(requests[2]);
   request->Commit();
   request->Prepare(base::Bind(&EmptyPreapreCallback));
 
   request->OnURLFetchUploadProgress(nullptr, 0, kExpectedUploadDataSize);
   request->OnURLFetchUploadProgress(nullptr, 150, kExpectedUploadDataSize);
@@ skipping 136 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