DevTools: report correct content length for resources

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_util.h"
 #include "net/base/net_util.h"
 #include "webkit/api/public/WebHTTPHeaderVisitor.h"
@@ skipping 63 matching lines @@
 }
 
 void MultipartResponseDelegate::OnReceivedData(const char* data,
                                                int data_len) {
   // 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;
 
-  // TODO(tc): Figure out what to use for length_received.  Maybe we can just
-  // pass the value on from our caller.
-  int length_received = -1;
-
   data_.append(data, data_len);
   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 27 matching lines @@
     }
   }
   DCHECK(!processing_headers_);
 
   size_t boundary_pos;
   while ((boundary_pos = FindBoundary()) != std::string::npos) {
     if (boundary_pos > 0) {
       // Send the last data chunk.
       client_->didReceiveData(loader_,
                               data_.data(),
-                              static_cast<int>(boundary_pos),
-                              length_received);
+                              static_cast<int>(boundary_pos));
     }
     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;
     }
 
     // We can now throw out data up through the boundary
     int offset = PushOverLine(data_, boundary_end_pos);
     data_ = data_.substr(boundary_end_pos + offset);
 
     // Ok, back to parsing headers
     if (!ParseHeaders()) {
       processing_headers_ = true;
       break;
     }
   }
 }
 
 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()) {
-    // TODO(tc): Figure out what to use for length_received.  Maybe we can just
-    // pass the value on from our caller.
-    int length_received = -1;
     client_->didReceiveData(loader_,
                             data_.data(),
-                            static_cast<int>(data_.length()),
-                            length_received);
+                            static_cast<int>(data_.length()));
   }
 }
 
 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 151 matching lines @@
                            byte_range_upper_bound_characters);
 
   if (!StringToInt(byte_range_lower_bound, content_range_lower_bound))
     return false;
   if (!StringToInt(byte_range_upper_bound, content_range_upper_bound))
     return false;
   return true;
 }
 
 }  // namespace webkit_glue