Move multipart resource handling to core/fetch (2/2)

content/child/web_url_loader_impl_unittest.cc

 // Copyright 2014 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 "content/child/web_url_loader_impl.h"
 
 #include <stdint.h>
 #include <string.h>
 #include <utility>
 #include <vector>
@@ skipping 34 matching lines @@
 const char kTestData[] = "blah!";
 
 const char kFtpDirMimeType[] = "text/vnd.chromium.ftp-dir";
 // Simple FTP directory listing.  Tests are not concerned with correct parsing,
 // but rather correct cleanup when deleted while parsing.  Important details of
 // this list are that it contains more than one entry that are not "." or "..".
 const char kFtpDirListing[] =
     "drwxr-xr-x    3 ftp      ftp          4096 May 15 18:11 goat\n"
     "drwxr-xr-x    3 ftp      ftp          4096 May 15 18:11 hat";
 
-const char kMultipartResponseMimeType[] = "multipart/x-mixed-replace";
-const char kMultipartResponseHeaders[] =
-    "HTTP/1.0 200 Peachy\r\n"
-    "Content-Type: multipart/x-mixed-replace; boundary=boundary\r\n\r\n";
-// Simple multipart response.  Imporant details for the tests are that it
-// contains multiple chunks, and that it doesn't end with a boundary, so will
-// send data in OnResponseComplete.  Also, it will resolve to kTestData.
-const char kMultipartResponse[] =
-    "--boundary\n"
-    "Content-type: text/html\n\n"
-    "bl"
-    "--boundary\n"
-    "Content-type: text/html\n\n"
-    "ah!";
-
 class TestResourceDispatcher : public ResourceDispatcher {
  public:
   TestResourceDispatcher() :
       ResourceDispatcher(nullptr, nullptr),
       canceled_(false) {
   }
 
   ~TestResourceDispatcher() override {}
 
   // TestDispatcher implementation:
@@ skipping 29 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcher);
 };
 
 class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
  public:
   TestWebURLLoaderClient(ResourceDispatcher* dispatcher,
                          scoped_refptr<scheduler::TaskQueue> task_runner)
       : loader_(new WebURLLoaderImpl(
             dispatcher,
             make_scoped_ptr(new scheduler::WebTaskRunnerImpl(task_runner)))),
-        expect_multipart_response_(false),
         delete_on_receive_redirect_(false),
         delete_on_receive_response_(false),
         delete_on_receive_data_(false),
         delete_on_finish_(false),
         delete_on_fail_(false),
         did_receive_redirect_(false),
         did_receive_response_(false),
         did_finish_(false) {}
 
   ~TestWebURLLoaderClient() override {}
@@ skipping 19 matching lines @@
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
   }
 
   void didReceiveResponse(
       blink::WebURLLoader* loader,
       const blink::WebURLResponse& response) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
 
-    // Only multipart requests may receive multiple response headers.
-    EXPECT_TRUE(expect_multipart_response_ || !did_receive_response_);

[hiroshige, 2016/02/26 19:02:12]

Can this be |EXPECT_FALSE(did_receive_response_);|?

[yhirano, 2016/02/27 01:27:45]

Done.

-
     did_receive_response_ = true;
     response_ = response;
     if (delete_on_receive_response_)
       loader_.reset();
   }
 
   void didDownloadData(blink::WebURLLoader* loader,
                        int dataLength,
                        int encodedDataLength) override {
     EXPECT_TRUE(loader_);
@@ skipping 46 matching lines @@
 
     if (delete_on_fail_)
       loader_.reset();
   }
 
   WebURLLoaderImpl* loader() { return loader_.get(); }
   void DeleteLoader() {
     loader_.reset();
   }
 
-  void set_expect_multipart_response() { expect_multipart_response_ = true; }
-
   void set_delete_on_receive_redirect() { delete_on_receive_redirect_ = true; }
   void set_delete_on_receive_response() { delete_on_receive_response_ = true; }
   void set_delete_on_receive_data() { delete_on_receive_data_ = true; }
   void set_delete_on_finish() { delete_on_finish_ = true; }
   void set_delete_on_fail() { delete_on_fail_ = true; }
 
   bool did_receive_redirect() const { return did_receive_redirect_; }
   bool did_receive_response() const { return did_receive_response_; }
   const std::string& received_data() const { return received_data_; }
   bool did_finish() const { return did_finish_; }
   const blink::WebURLError& error() const { return error_; }
   const blink::WebURLResponse& response() const { return response_; }
 
  private:
   scoped_ptr<WebURLLoaderImpl> loader_;
 
-  bool expect_multipart_response_;
-
   bool delete_on_receive_redirect_;
   bool delete_on_receive_response_;
   bool delete_on_receive_data_;
   bool delete_on_finish_;
   bool delete_on_fail_;
 
   bool did_receive_redirect_;
   bool did_receive_response_;
   std::string received_data_;
   bool did_finish_;
@@ skipping 78 matching lines @@
     EXPECT_TRUE(client()->did_receive_response());
   }
 
   void DoReceiveDataFtp() {
     peer()->OnReceivedData(make_scoped_ptr(new FixedReceivedData(
         kFtpDirListing, strlen(kFtpDirListing), strlen(kFtpDirListing))));
     // The FTP delegate should modify the data the client sees.
     EXPECT_NE(kFtpDirListing, client()->received_data());
   }
 
-  void DoReceiveResponseMultipart() {
-    EXPECT_FALSE(client()->did_receive_response());
-    content::ResourceResponseInfo response_info;
-    response_info.headers = new net::HttpResponseHeaders(
-        net::HttpUtil::AssembleRawHeaders(kMultipartResponseHeaders,
-                                          strlen(kMultipartResponseHeaders)));
-    response_info.mime_type = kMultipartResponseMimeType;
-    peer()->OnReceivedResponse(response_info);
-    EXPECT_TRUE(client()->did_receive_response());
-  }
-
-  void DoReceiveDataMultipart() {
-    peer()->OnReceivedData(make_scoped_ptr(
-        new FixedReceivedData(kMultipartResponse, strlen(kMultipartResponse),
-                              strlen(kMultipartResponse))));
-    // Multipart delegate should modify the data the client sees.
-    EXPECT_NE(kMultipartResponse, client()->received_data());
-  }
-
   TestWebURLLoaderClient* client() { return client_.get(); }
   TestResourceDispatcher* dispatcher() { return &dispatcher_; }
   RequestPeer* peer() { return dispatcher()->peer(); }
   base::MessageLoop* message_loop() { return &message_loop_; }
 
  private:
   base::MessageLoop message_loop_;
   // WorkerScheduler is needed because WebURLLoaderImpl needs a
   // scheduler::TaskQueue.
   scoped_ptr<scheduler::WorkerScheduler> worker_scheduler_;
@@ skipping 213 matching lines @@
 }
 
 TEST_F(WebURLLoaderImplTest, FtpDeleteOnFail) {
   client()->set_delete_on_fail();
   DoStartAsyncRequest();
   DoReceiveResponseFtp();
   DoReceiveDataFtp();
   DoFailRequest();
 }
 
-// Multipart integration tests.  These are focused more on safe deletion than
-// correct parsing of Multipart responses.
-
-TEST_F(WebURLLoaderImplTest, Multipart) {
-  client()->set_expect_multipart_response();
-  DoStartAsyncRequest();
-  DoReceiveResponseMultipart();
-  DoReceiveDataMultipart();
-  DoCompleteRequest();
-  EXPECT_EQ(kTestData, client()->received_data());
-  EXPECT_FALSE(dispatcher()->canceled());
-}
-
-TEST_F(WebURLLoaderImplTest, MultipartDeleteOnReceiveFirstResponse) {
-  client()->set_expect_multipart_response();
-  client()->set_delete_on_receive_response();
-  DoStartAsyncRequest();
-  DoReceiveResponseMultipart();
-  EXPECT_EQ("", client()->received_data());
-}
-
-TEST_F(WebURLLoaderImplTest, MultipartDeleteOnReceiveSecondResponse) {
-  client()->set_expect_multipart_response();
-  DoStartAsyncRequest();
-  DoReceiveResponseMultipart();
-  client()->set_delete_on_receive_response();
-  DoReceiveDataMultipart();
-  EXPECT_EQ("", client()->received_data());
-}
-
-TEST_F(WebURLLoaderImplTest, MultipartDeleteOnReceiveFirstData) {
-  client()->set_expect_multipart_response();
-  client()->set_delete_on_receive_data();
-  DoStartAsyncRequest();
-  DoReceiveResponseMultipart();
-  DoReceiveDataMultipart();
-  EXPECT_EQ("bl", client()->received_data());
-}
-
-TEST_F(WebURLLoaderImplTest, MultipartDeleteOnReceiveMoreData) {
-  client()->set_expect_multipart_response();
-  DoStartAsyncRequest();
-  DoReceiveResponseMultipart();
-  DoReceiveDataMultipart();
-  // For multipart responses, the delegate may send some data when notified
-  // of a request completing.
-  client()->set_delete_on_receive_data();
-  peer()->OnCompletedRequest(net::OK, false, false, "", base::TimeTicks(),
-                              strlen(kTestData));
-  EXPECT_FALSE(client()->did_finish());
-  EXPECT_EQ(kTestData, client()->received_data());
-}
-
-TEST_F(WebURLLoaderImplTest, MultipartDeleteFinish) {
-  client()->set_expect_multipart_response();
-  client()->set_delete_on_finish();
-  DoStartAsyncRequest();
-  DoReceiveResponseMultipart();
-  DoReceiveDataMultipart();
-  DoCompleteRequest();
-  EXPECT_EQ(kTestData, client()->received_data());
-}
-
-TEST_F(WebURLLoaderImplTest, MultipartDeleteFail) {
-  client()->set_expect_multipart_response();
-  client()->set_delete_on_fail();
-  DoStartAsyncRequest();
-  DoReceiveResponseMultipart();
-  DoReceiveDataMultipart();
-  DoFailRequest();
-}
-
 // PlzNavigate: checks that the stream override parameters provided on
 // navigation commit are properly applied.
 TEST_F(WebURLLoaderImplTest, BrowserSideNavigationCommit) {
   // Initialize the request and the stream override.
   const GURL kNavigationURL = GURL(kTestURL);
   const GURL kStreamURL = GURL("http://bar");
   const std::string kMimeType = "text/html";
   blink::WebURLRequest request;
   request.initialize();
   request.setURL(kNavigationURL);
@@ skipping 25 matching lines @@
   EXPECT_EQ(kMimeType, client()->response().mimeType().latin1());
 
   DoReceiveData();
   DoCompleteRequest();
   EXPECT_FALSE(dispatcher()->canceled());
   EXPECT_EQ(kTestData, client()->received_data());
 }
 
 }  // namespace
 }  // namespace content