Send encoded_body_length to renderer when response completed (2/3)

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>
@@ skipping 172 matching lines @@
   void didDownloadData(blink::WebURLLoader* loader,
                        int dataLength,
                        int encodedDataLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
   }
 
   void didReceiveData(blink::WebURLLoader* loader,
                       const char* data,
                       int dataLength,
-                      int encodedDataLength,
-                      int encodedBodyLength) override {
+                      int encodedDataLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
     // The response should have started, but must not have finished, or failed.
     EXPECT_TRUE(did_receive_response_);
     EXPECT_FALSE(did_finish_);
     EXPECT_EQ(net::OK, error_.reason);
     EXPECT_EQ("", error_.domain.utf8());
 
     received_data_.append(data, dataLength);
 
     if (delete_on_receive_data_)
       loader_.reset();
   }
 
   void didReceiveCachedMetadata(blink::WebURLLoader* loader,
                                 const char* data,
                                 int dataLength) override {
     EXPECT_EQ(loader_.get(), loader);
   }
 
   void didFinishLoading(blink::WebURLLoader* loader,
                         double finishTime,
-                        int64_t totalEncodedDataLength) override {
+                        int64_t totalEncodedDataLength,
+                        int64_t totalEncodedBodyLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
     EXPECT_TRUE(did_receive_response_);
     EXPECT_FALSE(did_finish_);
     did_finish_ = true;
 
     if (delete_on_finish_)
       loader_.reset();
   }
 
   void didFail(blink::WebURLLoader* loader,
                const blink::WebURLError& error,
-               int64_t totalEncodedDataLength) override {
+               int64_t totalEncodedDataLength,
+               int64_t totalEncodedBodyLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
     EXPECT_FALSE(did_finish_);
     error_ = error;
 
     if (delete_on_fail_)
       loader_.reset();
   }
 
   WebURLLoaderImpl* loader() { return loader_.get(); }
@@ skipping 89 matching lines @@
     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());
     auto size = strlen(kTestData);
     peer()->OnReceivedData(
-        base::MakeUnique<FixedReceivedData>(kTestData, size, size, size));
+        base::MakeUnique<FixedReceivedData>(kTestData, size, size));
     EXPECT_EQ(kTestData, client()->received_data());
   }
 
   void DoCompleteRequest() {
     EXPECT_FALSE(client()->did_finish());
     peer()->OnCompletedRequest(net::OK, false, false, base::TimeTicks(),
-                               strlen(kTestData));
+                               strlen(kTestData), strlen(kTestData));
     EXPECT_TRUE(client()->did_finish());
     // There should be no error.
     EXPECT_EQ(net::OK, client()->error().reason);
     EXPECT_EQ("", client()->error().domain.utf8());
   }
 
   void DoFailRequest() {
     EXPECT_FALSE(client()->did_finish());
-    peer()->OnCompletedRequest(net::ERR_FAILED, false, false,
-                               base::TimeTicks(), strlen(kTestData));
+    peer()->OnCompletedRequest(net::ERR_FAILED, false, false, base::TimeTicks(),
+                               strlen(kTestData), strlen(kTestData));
     EXPECT_FALSE(client()->did_finish());
     EXPECT_EQ(net::ERR_FAILED, client()->error().reason);
     EXPECT_EQ(net::kErrorDomain, client()->error().domain.utf8());
   }
 
   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() {
     auto size = strlen(kFtpDirListing);
     peer()->OnReceivedData(
-        base::MakeUnique<FixedReceivedData>(kFtpDirListing, size, size, size));
+        base::MakeUnique<FixedReceivedData>(kFtpDirListing, size, size));
     // The FTP delegate should modify the data the client sees.
     EXPECT_NE(kFtpDirListing, 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:
@@ skipping 202 matching lines @@
 
 TEST_F(WebURLLoaderImplTest, FtpDeleteOnReceiveMoreData) {
   DoStartAsyncRequest();
   DoReceiveResponseFtp();
   DoReceiveDataFtp();
 
   // Directory listings are only parsed once the request completes, so this will
   // cancel in DoReceiveDataFtp, before the request finishes.
   client()->set_delete_on_receive_data();
   peer()->OnCompletedRequest(net::OK, false, false, base::TimeTicks(),
-                              strlen(kTestData));
+                             strlen(kTestData), strlen(kTestData));
   EXPECT_FALSE(client()->did_finish());
 }
 
 TEST_F(WebURLLoaderImplTest, FtpDeleteOnFinish) {
   client()->set_delete_on_finish();
   DoStartAsyncRequest();
   DoReceiveResponseFtp();
   DoReceiveDataFtp();
   DoCompleteRequest();
 }
@@ skipping 89 matching lines @@
   sync_load_response.data = kBodyData;
   ASSERT_EQ(17u, sync_load_response.data.size());
   sync_load_response.encoded_body_length = kEncodedBodyLength;
   sync_load_response.encoded_data_length = kEncodedDataLength;
   dispatcher()->set_sync_load_response(sync_load_response);
 
   blink::WebURLResponse response;
   blink::WebURLError error;
   blink::WebData data;
   int64_t encoded_data_length = 0;
-  client()->loader()->loadSynchronously(request, response, error, data,
-                                        encoded_data_length);
+  int64_t encoded_body_length = 0;
+  client()->loader()->loadSynchronously(
+      request, response, error, data, encoded_data_length, encoded_body_length);
 
-  EXPECT_EQ(kEncodedBodyLength, response.encodedBodyLengthForTesting());
+  EXPECT_EQ(kEncodedBodyLength, encoded_body_length);
   EXPECT_EQ(kEncodedDataLength, encoded_data_length);
-  int expected_decoded_body_length = strlen(kBodyData);
-  EXPECT_EQ(expected_decoded_body_length,
-            response.decodedBodyLengthForTesting());
 }
 
 }  // namespace
 }  // namespace content