Enabled actual transfer size in chromium

webkit/glue/multipart_response_delegate_unittest.cc

 // Copyright (c) 2006-2008 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 <vector>
 
 #include "base/basictypes.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoaderClient.h"
@@ skipping 56 matching lines @@
     data_.clear();
   }
   // FIXME(vsevik): rename once renamed in webkit
   virtual void didReceiveData2(
       WebKit::WebURLLoader* loader,
       const char* data,
       int data_length,
       int length_received) {
     ++received_data_;
     data_.append(data, data_length);
+    length_received_ += length_received;
   }
 
   // FIXME(vsevik): remove once removed in webkit
   virtual void didReceiveData(
       WebKit::WebURLLoader* loader,
       const char* data,
       int data_length) {
     didReceiveData2(loader, data, data_length, -1);
   }
   virtual void didFinishLoading(WebURLLoader*, double finishTime) {}
   virtual void didFail(WebURLLoader*, const WebURLError&) {}
 
   void Reset() {
-    received_response_ = received_data_ = 0;
+    received_response_ = received_data_ = length_received_ = 0;
     data_.clear();
     response_.reset();
   }
 
   string GetResponseHeader(const char* name) const {
     return string(response_.httpHeaderField(WebString::fromUTF8(name)).utf8());
   }
 
-  int received_response_, received_data_;
+  int received_response_, received_data_, length_received_;
   string data_;
   WebURLResponse response_;
 };
 
 // We can't put this in an anonymous function because it's a friend class for
 // access to private members.
 TEST(MultipartResponseTest, Functions) {
   // PushOverLine tests
 
   WebURLResponse response;
@@ skipping 108 matching lines @@
   MockWebURLLoaderClient client;
   MultipartResponseDelegate delegate(&client, NULL, response, "bound");
 
   // No start boundary
   string no_start_boundary(
     "Content-type: text/plain\n\n"
     "This is a sample response\n"
     "--bound--"
     "ignore junk after end token --bound\n\nTest2\n");
   delegate.OnReceivedData(no_start_boundary.c_str(),
+                          static_cast<int>(no_start_boundary.length()),
                           static_cast<int>(no_start_boundary.length()));
   EXPECT_EQ(1, client.received_response_);
   EXPECT_EQ(1, client.received_data_);
-  EXPECT_EQ(string("This is a sample response"),
-            client.data_);
+  EXPECT_EQ(string("This is a sample response"), client.data_);
+  EXPECT_EQ(static_cast<int>(no_start_boundary.length()),
+            client.length_received_);
 
   delegate.OnCompletedRequest();
   EXPECT_EQ(1, client.received_response_);
   EXPECT_EQ(1, client.received_data_);
 
   // No end boundary
   client.Reset();
   MultipartResponseDelegate delegate2(&client, NULL, response, "bound");
   string no_end_boundary(
     "bound\nContent-type: text/plain\n\n"
     "This is a sample response\n");
   delegate2.OnReceivedData(no_end_boundary.c_str(),
+                          static_cast<int>(no_end_boundary.length()),
                           static_cast<int>(no_end_boundary.length()));
   EXPECT_EQ(1, client.received_response_);
   EXPECT_EQ(1, client.received_data_);
   EXPECT_EQ("This is a sample response\n", client.data_);
+  EXPECT_EQ(static_cast<int>(no_end_boundary.length()),
+            client.length_received_);
 
   delegate2.OnCompletedRequest();
   EXPECT_EQ(1, client.received_response_);
   EXPECT_EQ(1, client.received_data_);
-  EXPECT_EQ(string("This is a sample response\n"),
-            client.data_);
+  EXPECT_EQ(string("This is a sample response\n"), client.data_);
+  EXPECT_EQ(static_cast<int>(no_end_boundary.length()),
+            client.length_received_);
 
   // Neither boundary
   client.Reset();
   MultipartResponseDelegate delegate3(&client, NULL, response, "bound");
   string no_boundaries(
     "Content-type: text/plain\n\n"
     "This is a sample response\n");
   delegate3.OnReceivedData(no_boundaries.c_str(),
+                           static_cast<int>(no_boundaries.length()),
                            static_cast<int>(no_boundaries.length()));
   EXPECT_EQ(1, client.received_response_);
   EXPECT_EQ(1, client.received_data_);
   EXPECT_EQ("This is a sample response\n", client.data_);
+  EXPECT_EQ(static_cast<int>(no_boundaries.length()), client.length_received_);
 
   delegate3.OnCompletedRequest();
   EXPECT_EQ(1, client.received_response_);
   EXPECT_EQ(1, client.received_data_);
-  EXPECT_EQ(string("This is a sample response\n"),
-            client.data_);
+  EXPECT_EQ(string("This is a sample response\n"), client.data_);
+  EXPECT_EQ(static_cast<int>(no_boundaries.length()), client.length_received_);
 }
 
 TEST(MultipartResponseTest, MalformedBoundary) {
   // Some servers send a boundary that is prefixed by "--".  See bug 5786.
 
   WebURLResponse response;
   response.initialize();
   response.setMIMEType("multipart/x-mixed-replace");
   response.setHTTPHeaderField("Foo", "Bar");
   response.setHTTPHeaderField("Content-type", "text/plain");
   MockWebURLLoaderClient client;
   MultipartResponseDelegate delegate(&client, NULL, response, "--bound");
 
   string data(
     "--bound\n"
     "Content-type: text/plain\n\n"
     "This is a sample response\n"
     "--bound--"
     "ignore junk after end token --bound\n\nTest2\n");
-  delegate.OnReceivedData(data.c_str(), static_cast<int>(data.length()));
+  delegate.OnReceivedData(data.c_str(),
+                          static_cast<int>(data.length()),
+                          static_cast<int>(data.length()));
   EXPECT_EQ(1, client.received_response_);
   EXPECT_EQ(1, client.received_data_);
   EXPECT_EQ(string("This is a sample response"), client.data_);
+  EXPECT_EQ(static_cast<int>(data.length()), client.length_received_);
 
   delegate.OnCompletedRequest();
   EXPECT_EQ(1, client.received_response_);
   EXPECT_EQ(1, client.received_data_);
 }
 
 
 // Used in for tests that break the data in various places.
 struct TestChunk {
   const int start_pos;  // offset in data
   const int end_pos;    // end offset in data
   const int expected_responses;
   const int expected_received_data;
   const char* expected_data;
+  const int expected_length_received;
 };
 
 void VariousChunkSizesTest(const TestChunk chunks[], int chunks_size,
                            int responses, int received_data,
-                           const char* completed_data) {
+                           const char* completed_data,
+                           int completed_length_received) {
   const string data(
     "--bound\n"                    // 0-7
     "Content-type: image/png\n\n"  // 8-32
     "datadatadatadatadata"         // 33-52
     "--bound\n"                    // 53-60
     "Content-type: image/jpg\n\n"  // 61-85
     "foofoofoofoofoo"              // 86-100
     "--bound--");                  // 101-109
 
   WebURLResponse response;
   response.initialize();
   response.setMIMEType("multipart/x-mixed-replace");
   MockWebURLLoaderClient client;
   MultipartResponseDelegate delegate(&client, NULL, response, "bound");
 
   for (int i = 0; i < chunks_size; ++i) {
     ASSERT_TRUE(chunks[i].start_pos < chunks[i].end_pos);
     string chunk = data.substr(chunks[i].start_pos,
                                chunks[i].end_pos - chunks[i].start_pos);
-    delegate.OnReceivedData(chunk.c_str(), static_cast<int>(chunk.length()));
-    EXPECT_EQ(chunks[i].expected_responses,
-              client.received_response_);
-    EXPECT_EQ(chunks[i].expected_received_data,
-              client.received_data_);
-    EXPECT_EQ(string(chunks[i].expected_data),
-              client.data_);
+    delegate.OnReceivedData(
+        chunk.c_str(),
+        static_cast<int>(chunk.length()),
+        static_cast<int>(chunk.length()));
+    EXPECT_EQ(chunks[i].expected_responses, client.received_response_);
+    EXPECT_EQ(chunks[i].expected_received_data, client.received_data_);
+    EXPECT_EQ(string(chunks[i].expected_data), client.data_);
+    EXPECT_EQ(chunks[i].expected_length_received, client.length_received_);
   }
   // Check final state
   delegate.OnCompletedRequest();
-  EXPECT_EQ(responses,
-            client.received_response_);
-  EXPECT_EQ(received_data,
-            client.received_data_);
-  EXPECT_EQ(string(completed_data),
-            client.data_);
+  EXPECT_EQ(responses, client.received_response_);
+  EXPECT_EQ(received_data, client.received_data_);
+  string completed_data_string(completed_data);
+  EXPECT_EQ(completed_data_string, client.data_);
+  EXPECT_EQ(completed_length_received, client.length_received_);
 }
 
 TEST(MultipartResponseTest, BreakInBoundary) {
   // Break in the first boundary
   const TestChunk bound1[] = {
-    { 0, 4, 0, 0, ""},
-    { 4, 110, 2, 2, "foofoofoofoofoo" },
+    { 0, 4, 0, 0, "", 0 },
+    { 4, 110, 2, 2, "foofoofoofoofoo", 110 },
   };
   VariousChunkSizesTest(bound1, arraysize(bound1),
-                        2, 2, "foofoofoofoofoo");
+                        2, 2, "foofoofoofoofoo", 110);
 
   // Break in first and second
   const TestChunk bound2[] = {
-    { 0, 4, 0, 0, ""},
-    { 4, 55, 1, 1, "datadatadatadat" },
-    { 55, 65, 1, 2, "datadatadatadatadata" },
-    { 65, 110, 2, 3, "foofoofoofoofoo" },
+    { 0, 4, 0, 0, "", 0 },
+    { 4, 55, 1, 1, "datadatadatadat", 55 },
+    { 55, 65, 1, 2, "datadatadatadatadata", 65 },
+    { 65, 110, 2, 3, "foofoofoofoofoo", 110 },
   };
   VariousChunkSizesTest(bound2, arraysize(bound2),
-                        2, 3, "foofoofoofoofoo");
+                        2, 3, "foofoofoofoofoo", 110);
 
   // Break in second only
   const TestChunk bound3[] = {
-    { 0, 55, 1, 1, "datadatadatadat" },
-    { 55, 110, 2, 3, "foofoofoofoofoo" },
+    { 0, 55, 1, 1, "datadatadatadat", 55 },
+    { 55, 110, 2, 3, "foofoofoofoofoo", 110 },
   };
   VariousChunkSizesTest(bound3, arraysize(bound3),
-                        2, 3, "foofoofoofoofoo");
+                        2, 3, "foofoofoofoofoo", 110);
 }
 
 TEST(MultipartResponseTest, BreakInHeaders) {
   // Break in first header
   const TestChunk header1[] = {
-    { 0, 10, 0, 0, "" },
-    { 10, 35, 1, 0, "" },
-    { 35, 110, 2, 2, "foofoofoofoofoo" },
+    { 0, 10, 0, 0, "", 0 },
+    { 10, 35, 1, 0, "", 0 },
+    { 35, 110, 2, 2, "foofoofoofoofoo", 110 },
   };
   VariousChunkSizesTest(header1, arraysize(header1),
-                        2, 2, "foofoofoofoofoo");
+                        2, 2, "foofoofoofoofoo", 110);
 
   // Break in both headers
   const TestChunk header2[] = {
-    { 0, 10, 0, 0, "" },
-    { 10, 65, 1, 1, "datadatadatadatadata" },
-    { 65, 110, 2, 2, "foofoofoofoofoo" },
+    { 0, 10, 0, 0, "", 0 },
+    { 10, 65, 1, 1, "datadatadatadatadata", 65 },
+    { 65, 110, 2, 2, "foofoofoofoofoo", 110 },
   };
   VariousChunkSizesTest(header2, arraysize(header2),
-                        2, 2, "foofoofoofoofoo");
+                        2, 2, "foofoofoofoofoo", 110);
 
   // Break at end of a header
   const TestChunk header3[] = {
-    { 0, 33, 1, 0, "" },
-    { 33, 65, 1, 1, "datadatadatadatadata" },
-    { 65, 110, 2, 2, "foofoofoofoofoo" },
+    { 0, 33, 1, 0, "", 0 },
+    { 33, 65, 1, 1, "datadatadatadatadata", 65 },
+    { 65, 110, 2, 2, "foofoofoofoofoo", 110 },
   };
   VariousChunkSizesTest(header3, arraysize(header3),
-                        2, 2, "foofoofoofoofoo");
+                        2, 2, "foofoofoofoofoo", 110);
 }
 
 TEST(MultipartResponseTest, BreakInData) {
   // All data as one chunk
   const TestChunk data1[] = {
-    { 0, 110, 2, 2, "foofoofoofoofoo" },
+    { 0, 110, 2, 2, "foofoofoofoofoo", 110 },
   };
   VariousChunkSizesTest(data1, arraysize(data1),
-                        2, 2, "foofoofoofoofoo");
+                        2, 2, "foofoofoofoofoo", 110);
 
   // breaks in data segment
   const TestChunk data2[] = {
-    { 0, 35, 1, 0, "" },
-    { 35, 65, 1, 1, "datadatadatadatadata" },
-    { 65, 90, 2, 1, "" },
-    { 90, 110, 2, 2, "foofoofoofoofoo" },
+    { 0, 35, 1, 0, "", 0 },
+    { 35, 65, 1, 1, "datadatadatadatadata", 65 },
+    { 65, 90, 2, 1, "", 65 },
+    { 90, 110, 2, 2, "foofoofoofoofoo", 110 },
   };
   VariousChunkSizesTest(data2, arraysize(data2),
-                        2, 2, "foofoofoofoofoo");
+                        2, 2, "foofoofoofoofoo", 110);
 
   // Incomplete send
   const TestChunk data3[] = {
-    { 0, 35, 1, 0, "" },
-    { 35, 90, 2, 1, "" },
+    { 0, 35, 1, 0, "", 0 },
+    { 35, 90, 2, 1, "", 90 },
   };
   VariousChunkSizesTest(data3, arraysize(data3),
-                        2, 2, "foof");
+                        2, 2, "foof", 90);
 }
 
 TEST(MultipartResponseTest, SmallChunk) {
   WebURLResponse response;
   response.initialize();
   response.setMIMEType("multipart/x-mixed-replace");
   response.setHTTPHeaderField("Content-type", "text/plain");
   MockWebURLLoaderClient client;
   MultipartResponseDelegate delegate(&client, NULL, response, "bound");
 
   // Test chunks of size 1, 2, and 0.
   string data(
     "--boundContent-type: text/plain\n\n"
     "\n--boundContent-type: text/plain\n\n"
     "\n\n--boundContent-type: text/plain\n\n"
     "--boundContent-type: text/plain\n\n"
     "end--bound--");
   delegate.OnReceivedData(data.c_str(),
+                          static_cast<int>(data.length()),
                           static_cast<int>(data.length()));
   EXPECT_EQ(4, client.received_response_);
   EXPECT_EQ(2, client.received_data_);
   EXPECT_EQ(string("end"), client.data_);
+  EXPECT_EQ(static_cast<int>(data.length()), client.length_received_);
 
   delegate.OnCompletedRequest();
   EXPECT_EQ(4, client.received_response_);
   EXPECT_EQ(2, client.received_data_);
 }
 
 TEST(MultipartResponseTest, MultipleBoundaries) {
   // Test multiple boundaries back to back
   WebURLResponse response;
   response.initialize();
   response.setMIMEType("multipart/x-mixed-replace");
   MockWebURLLoaderClient client;
   MultipartResponseDelegate delegate(&client, NULL, response, "bound");
 
   string data("--bound\r\n\r\n--bound\r\n\r\nfoofoo--bound--");
-  delegate.OnReceivedData(data.c_str(), static_cast<int>(data.length()));
-  EXPECT_EQ(2,
-            client.received_response_);
-  EXPECT_EQ(1,
-            client.received_data_);
-  EXPECT_EQ(string("foofoo"),
-            client.data_);
+  delegate.OnReceivedData(data.c_str(),
+                          static_cast<int>(data.length()),
+                          static_cast<int>(data.length()));
+  EXPECT_EQ(2, client.received_response_);
+  EXPECT_EQ(1, client.received_data_);
+  EXPECT_EQ(string("foofoo"), client.data_);
+  EXPECT_EQ(static_cast<int>(data.length()), client.length_received_);
 }
 
 TEST(MultipartResponseTest, MultipartByteRangeParsingTest) {
   // Test multipart/byteranges based boundary parsing.
   WebURLResponse response1;
   response1.initialize();
   response1.setMIMEType("multipart/x-mixed-replace");
   response1.setHTTPHeaderField("Content-Length", "200");
   response1.setHTTPHeaderField("Content-type",
                                "multipart/byteranges; boundary=--bound--");
@@ skipping 142 matching lines @@
   response.initialize();
   response.setMIMEType("multipart/x-mixed-replace");
   MockWebURLLoaderClient client;
   MultipartResponseDelegate delegate(&client, NULL, response, "bound");
 
   string data(
       "--bound\n"
       "Content-type: text/plain\n\n"
       "response data\n"
       "--bound\n");
-  delegate.OnReceivedData(data.c_str(), static_cast<int>(data.length()));
-  EXPECT_EQ(1,
-            client.received_response_);
-  EXPECT_EQ(string("response data"),
-            client.data_);
+  delegate.OnReceivedData(data.c_str(),
+                          static_cast<int>(data.length()),
+                          static_cast<int>(data.length()));
+  EXPECT_EQ(1, client.received_response_);
+  EXPECT_EQ(string("response data"), client.data_);
+  EXPECT_EQ(static_cast<int>(data.length()), client.length_received_);
   EXPECT_FALSE(client.response_.isMultipartPayload());
 
   string data2(
       "Content-type: text/plain\n\n"
       "response data2\n"
       "--bound\n");
-  delegate.OnReceivedData(data2.c_str(), static_cast<int>(data2.length()));
-  EXPECT_EQ(2,
-            client.received_response_);
-  EXPECT_EQ(string("response data2"),
-            client.data_);
+  delegate.OnReceivedData(data2.c_str(),
+                          static_cast<int>(data2.length()),
+                          static_cast<int>(data2.length()));
+  EXPECT_EQ(2, client.received_response_);
+  EXPECT_EQ(string("response data2"), client.data_);
+  EXPECT_EQ(static_cast<int>(data.length()) + static_cast<int>(data2.length()),
+            client.length_received_);
   EXPECT_TRUE(client.response_.isMultipartPayload());
 }
 
 }  // namespace