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),
+      length_received_(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 length_received) {
   // 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);
+  length_received_ += length_received;
   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.
         // FIXME(vsevik): rename once renamed in webkit
         client_->didReceiveData2(loader_,
                                  data_.data(),
-                                 static_cast<int>(data_length), -1);
+                                 static_cast<int>(data_length),
+                                 length_received_);
+        length_received_ = 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 11 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();
     // FIXME(vsevik): rename didReceiveData2 once renamed in webkit
     if (client_)
-      client_->didReceiveData2(loader_, data_.data(), send_length, -1);
+      client_->didReceiveData2(loader_,
+                               data_.data(),
+                               send_length,
+                               length_received_);
     data_ = data_.substr(send_length);
+    length_received_ = 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_) {
     // FIXME(vsevik): rename didReceiveData2 once renamed in webkit
     client_->didReceiveData2(loader_,
                              data_.data(),
-                             static_cast<int>(data_.length()), -1);
+                             static_cast<int>(data_.length()),
+                             length_received_);
+    length_received_ = 0;
   }
 }
 
 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