Enabled actual transfer size in chromium

content/common/resource_dispatcher_unittest.cc

 // Copyright (c) 2011 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 <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process.h"
@@ skipping 38 matching lines @@
     *has_new_first_party_for_cookies = false;
     return true;
   }
 
   virtual void OnReceivedResponse(const ResourceResponseInfo& info) {
   }
 
   virtual void OnDownloadedData(int len) {
   }
 
-  virtual void OnReceivedData(const char* data, int len) {
+  virtual void OnReceivedData(const char* data,
+                              int data_length,
+                              int raw_data_length) {
     EXPECT_FALSE(complete_);
-    data_.append(data, len);
+    data_.append(data, data_length);
+    total_raw_data_length_ += raw_data_length;
   }
 
   virtual void OnCompletedRequest(const net::URLRequestStatus& status,
                                   const std::string& security_info,
                                   const base::Time& completion_time) {
     EXPECT_FALSE(complete_);
     complete_ = true;
   }
 
+  bool complete() const {
+    return complete_;
+  }
   const std::string& data() const {
     return data_;
   }
-  bool complete() const {
-    return complete_;
+  int total_raw_data_length() const {
+    return total_raw_data_length_;
   }
 
  private:
   bool complete_;
   std::string data_;
+  int total_raw_data_length_;
 };
 
 
 // Sets up the message sender override for the unit test
 class ResourceDispatcherTest : public testing::Test,
                                public IPC::Message::Sender {
  public:
   // Emulates IPC send operations (IPC::Message::Sender) by adding
   // pending messages to the queue.
   virtual bool Send(IPC::Message* msg) {
@@ skipping 25 matching lines @@
 
       // received data message with the test contents
       base::SharedMemory shared_mem;
       EXPECT_TRUE(shared_mem.CreateAndMapAnonymous(test_page_contents_len));
       char* put_data_here = static_cast<char*>(shared_mem.memory());
       memcpy(put_data_here, test_page_contents, test_page_contents_len);
       base::SharedMemoryHandle dup_handle;
       EXPECT_TRUE(shared_mem.GiveToProcess(
           base::Process::Current().handle(), &dup_handle));
       dispatcher_->OnReceivedData(
-          message_queue_[0], request_id, dup_handle, test_page_contents_len);
+          message_queue_[0],
+          request_id,
+          dup_handle,
+          test_page_contents_len,
+          test_page_contents_len);
 
       message_queue_.erase(message_queue_.begin());
 
       // read the ack message.
       Tuple1<int> request_ack;
       ASSERT_TRUE(ResourceHostMsg_DataReceived_ACK::Read(
           &message_queue_[0], &request_ack));
 
       ASSERT_EQ(request_ack.a, request_id);
 
@@ skipping 39 matching lines @@
   ResourceLoaderBridge* bridge = CreateBridge();
 
   bridge->Start(&callback);
 
   ProcessMessages();
 
   // FIXME(brettw) when the request complete messages are actually handledo
   // and dispatched, uncomment this.
   //EXPECT_TRUE(callback.complete());
   //EXPECT_STREQ(test_page_contents, callback.data().c_str());
+  //EXPECT_EQ(test_page_contents_len, callback.total_raw_data_length());
 
   delete bridge;
 }
 
 // Tests that the request IDs are straight when there are multiple requests.
 TEST_F(ResourceDispatcherTest, MultipleRequests) {
   // FIXME
 }
 
 // Tests that the cancel method prevents other messages from being received
@@ skipping 39 matching lines @@
 
     delete response_message;
 
     // Duplicate the shared memory handle so both the test and the callee can
     // close their copy.
     base::SharedMemoryHandle duplicated_handle;
     EXPECT_TRUE(shared_handle_.ShareToProcess(base::GetCurrentProcessHandle(),
                                               &duplicated_handle));
 
     response_message =
-        new ResourceMsg_DataReceived(0, 0, duplicated_handle, 100);
+        new ResourceMsg_DataReceived(0, 0, duplicated_handle, 100, 100);
 
     dispatcher_->OnMessageReceived(*response_message);
 
     delete response_message;
 
     set_defer_loading(false);
   }
 
   // ResourceLoaderBridge::Peer methods.
   virtual void OnUploadProgress(uint64 position, uint64 size) {
   }
 
   virtual bool OnReceivedRedirect(
       const GURL& new_url,
       const ResourceResponseInfo& info,
       bool* has_new_first_party_for_cookies,
       GURL* new_first_party_for_cookies) {
     *has_new_first_party_for_cookies = false;
     return true;
   }
 
   virtual void OnReceivedResponse(const ResourceResponseInfo& info) {
     EXPECT_EQ(defer_loading_, false);
     set_defer_loading(true);
   }
 
   virtual void OnDownloadedData(int len) {
   }
 
-  virtual void OnReceivedData(const char* data, int len) {
+  virtual void OnReceivedData(const char* data,
+                              int data_length,
+                              int raw_data_length) {
     EXPECT_EQ(defer_loading_, false);
     set_defer_loading(false);
   }
 
   virtual void OnCompletedRequest(const net::URLRequestStatus& status,
                                   const std::string& security_info,
                                   const base::Time& completion_time) {
   }
 
  protected:
@@ skipping 28 matching lines @@
 
   ResourceLoaderBridge* bridge = CreateBridge();
 
   bridge->Start(this);
   InitMessages();
 
   // Dispatch deferred messages.
   message_loop.RunAllPending();
   delete bridge;
 }