Enabled actual transfer size in chromium

webkit/glue/multipart_response_delegate.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 "webkit/glue/multipart_response_delegate.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "net/base/net_util.h"
@@ skipping 44 matching lines @@
 }  // namespace
 
 MultipartResponseDelegate::MultipartResponseDelegate(
     WebURLLoaderClient* client,
     WebURLLoader* loader,
     const WebURLResponse& response,
     const std::string& boundary)
     : client_(client),
       loader_(loader),
       original_response_(response),
+      raw_data_length_(0),
       boundary_("--"),
       first_received_data_(true),
       processing_headers_(false),
       stop_sending_(false),
       has_sent_first_response_(false) {
   // Some servers report a boundary prefixed with "--".  See bug 5786.
   if (StartsWithASCII(boundary, "--", true)) {
     boundary_.assign(boundary);
   } else {
     boundary_.append(boundary);
   }
 }
 
 void MultipartResponseDelegate::OnReceivedData(const char* data,
-                                               int data_len) {
+                                               int data_len,
+                                               int raw_data_length) {
   // stop_sending_ means that we've already received the final boundary token.
   // The server should stop sending us data at this point, but if it does, we
   // just throw it away.
   if (stop_sending_)
     return;
 
   data_.append(data, data_len);
+  raw_data_length_ += raw_data_length;
   if (first_received_data_) {
     // Some servers don't send a boundary token before the first chunk of
     // data.  We handle this case anyway (Gecko does too).
     first_received_data_ = false;
 
     // Eat leading \r\n
     int pos = PushOverLine(data_, 0);
     if (pos)
       data_ = data_.substr(pos);
 
@@ skipping 37 matching lines @@
         data_length--;
         if (boundary_pos > 1 && data_[boundary_pos - 2] == '\r') {
           data_length--;
         }
       }
       if (data_length > 0) {
         // Send the last data chunk.
         client_->didReceiveData(loader_,
                                 data_.data(),
                                 static_cast<int>(data_length),
-                                -1);
+                                raw_data_length_);
+        raw_data_length_ = 0;
       }
     }
     size_t boundary_end_pos = boundary_pos + boundary_.length();
     if (boundary_end_pos < data_.length() && '-' == data_[boundary_end_pos]) {
       // This was the last boundary so we can stop processing.
       stop_sending_ = true;
       data_.clear();
       return;
     }
 
@@ skipping 10 matching lines @@
 
   // At this point, we should send over any data we have, but keep enough data
   // buffered to handle a boundary that may have been truncated.
   if (!processing_headers_ && data_.length() > boundary_.length()) {
     // If the last character is a new line character, go ahead and just send
     // everything we have buffered.  This matches an optimization in Gecko.
     int send_length = data_.length() - boundary_.length();
     if (data_[data_.length() - 1] == '\n')
       send_length = data_.length();
     if (client_)
-      client_->didReceiveData(loader_, data_.data(), send_length, -1);
+      client_->didReceiveData(loader_,
+                              data_.data(),
+                              send_length,
+                              raw_data_length_);
     data_ = data_.substr(send_length);
+    raw_data_length_ = 0;
   }
 }
 
 void MultipartResponseDelegate::OnCompletedRequest() {
   // If we have any pending data and we're not in a header, go ahead and send
   // it to WebCore.
   if (!processing_headers_ && !data_.empty() && !stop_sending_ && client_) {
     client_->didReceiveData(loader_,
                             data_.data(),
-                            static_cast<int>(data_.length()), -1);
+                            static_cast<int>(data_.length()),
+                            raw_data_length_);
+    raw_data_length_ = 0;

[darin (slow to review), 2011/04/08 15:47:18]

it can sometimes be dangerous to assume that |this| is still valid after calling
out to a client interface.  given that other calls to didReceiveData are already
followed by dereferencing |this|, it is probably safe to assume that it is safe
in this case too, but are you sure?  are you sure that the
MultipartResponseDelegate isn't destroyed during the call to didReceiveData?

[vsevik, 2011/04/08 16:23:48]

Yes, I am sure. It is destroyed right after the OnCompletedRequest call.
http://codesearch.google.com/codesearch/p?hl=en#OAMlx_jo-ck/src/webkit/glue/w...

   }
 }
 
 int MultipartResponseDelegate::PushOverLine(const std::string& data,
                                             size_t pos) {
   int offset = 0;
   if (pos < data.length() && (data[pos] == '\r' || data[pos] == '\n')) {
     ++offset;
     if (pos + 1 < data.length() && data[pos + 1] == '\n')
       ++offset;
@@ skipping 186 matching lines @@
   if (!base::StringToInt(byte_range_lower_bound, content_range_lower_bound))
     return false;
   if (!base::StringToInt(byte_range_upper_bound, content_range_upper_bound))
     return false;
   if (!base::StringToInt(byte_range_instance_size, content_range_instance_size))
     return false;
   return true;
 }
 
 }  // namespace webkit_glue