Make WebURLLoader capable of retaining received buffers.

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 <string.h>
+#include <vector>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/request_info.h"
 #include "content/child/resource_dispatcher.h"
 #include "content/public/child/request_peer.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/resource_response_info.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/url_request/redirect_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLLoaderClient.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "url/gurl.h"
 
 namespace content {
 namespace {
 
+class FixedReceivedData final : public RequestPeer::ReceivedData {
+ public:
+  FixedReceivedData(const char* payload, int length, int encoded_length)
+      : data_(&payload[0], &payload[length]), encoded_length_(encoded_length) {}
+  ~FixedReceivedData() override {}
+
+  const char* payload() const override {
+    // TODO(yhirano): Use |data_.data()| when we can use c++11.
+    return data_.empty() ? nullptr : &data_[0];
+  }
+  int length() const override { return data_.size(); }
+  int encoded_length() const override { return encoded_length_; }
+
+ private:
+  const std::vector<char> data_;
+  const int encoded_length_;
+
+  DISALLOW_COPY_AND_ASSIGN(FixedReceivedData);
+};
+
 const char kTestURL[] = "http://foo";
 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";
@@ skipping 232 matching lines @@
 
   void DoReceiveResponse() {
     EXPECT_FALSE(client()->did_receive_response());
     peer()->OnReceivedResponse(content::ResourceResponseInfo());
     EXPECT_TRUE(client()->did_receive_response());
   }
 
   // Assumes it is called only once for a request.
   void DoReceiveData() {
     EXPECT_EQ("", client()->received_data());
-    peer()->OnReceivedData(kTestData, strlen(kTestData), strlen(kTestData));
+    peer()->OnReceivedData(make_scoped_ptr(new FixedReceivedData(
+        kTestData, strlen(kTestData), strlen(kTestData))));
     EXPECT_EQ(kTestData, client()->received_data());
   }
 
   void DoCompleteRequest() {
     EXPECT_FALSE(client()->did_finish());
     peer()->OnCompletedRequest(net::OK, false, false, "", base::TimeTicks(),
                                strlen(kTestData));
     EXPECT_TRUE(client()->did_finish());
     // There should be no error.
     EXPECT_EQ(net::OK, client()->error().reason);
@@ skipping 11 matching lines @@
 
   void DoReceiveResponseFtp() {
     EXPECT_FALSE(client()->did_receive_response());
     content::ResourceResponseInfo response_info;
     response_info.mime_type = kFtpDirMimeType;
     peer()->OnReceivedResponse(response_info);
     EXPECT_TRUE(client()->did_receive_response());
   }
 
   void DoReceiveDataFtp() {
-    peer()->OnReceivedData(kFtpDirListing, strlen(kFtpDirListing),
-                           strlen(kFtpDirListing));
+    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(kMultipartResponse, strlen(kMultipartResponse),
-                           strlen(kMultipartResponse));
+    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_; }
   TestResourceDispatcher* dispatcher() { return &dispatcher_; }
   RequestPeer* peer() { return dispatcher()->peer(); }
   base::MessageLoop* message_loop() { return &message_loop_; }
 
  private:
@@ skipping 329 matching lines @@
   EXPECT_EQ(kMimeType, client()->response().mimeType().latin1());
 
   DoReceiveData();
   DoCompleteRequest();
   EXPECT_FALSE(dispatcher()->canceled());
   EXPECT_EQ(kTestData, client()->received_data());
 }
 
 }  // namespace
 }  // namespace content