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

content/child/shared_memory_received_data_factory.cc

 // Copyright 2015 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/shared_memory_received_data_factory.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "content/common/resource_messages.h"
 #include "ipc/ipc_sender.h"
 
 namespace content {
 
 class SharedMemoryReceivedDataFactory::SharedMemoryReceivedData final
     : public RequestPeer::ReceivedData {
  public:
   SharedMemoryReceivedData(
       const char* payload,
       int length,
       int encoded_data_length,
-      int encoded_body_length,
       scoped_refptr<SharedMemoryReceivedDataFactory> factory,
       SharedMemoryReceivedDataFactory::TicketId id)
       : payload_(payload),
         length_(length),
         encoded_data_length_(encoded_data_length),
-        encoded_body_length_(encoded_body_length),
         factory_(factory),
         id_(id) {}
 
   ~SharedMemoryReceivedData() override { factory_->Reclaim(id_); }
 
   const char* payload() const override { return payload_; }
   int length() const override { return length_; }
   int encoded_data_length() const override { return encoded_data_length_; }
-  int encoded_body_length() const override { return encoded_body_length_; }
 
  private:
   const char* const payload_;
   const int length_;
   const int encoded_data_length_;
-  const int encoded_body_length_;
 
   scoped_refptr<SharedMemoryReceivedDataFactory> factory_;
   SharedMemoryReceivedDataFactory::TicketId id_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedMemoryReceivedData);
 };
 
 SharedMemoryReceivedDataFactory::SharedMemoryReceivedDataFactory(
     IPC::Sender* message_sender,
     int request_id,
     linked_ptr<base::SharedMemory> memory)
     : id_(0),
       oldest_(0),
       message_sender_(message_sender),
       request_id_(request_id),
       is_stopped_(false),
       memory_(memory) {
 }
 
 SharedMemoryReceivedDataFactory::~SharedMemoryReceivedDataFactory() {
   if (!is_stopped_)
     SendAck(released_tickets_.size());
 }
 
 std::unique_ptr<RequestPeer::ReceivedData>
 SharedMemoryReceivedDataFactory::Create(int offset,
                                         int length,
-                                        int encoded_data_length,
-                                        int encoded_body_length) {
+                                        int encoded_data_length) {
   const char* start = static_cast<char*>(memory_->memory());
   const char* payload = start + offset;
   TicketId id = id_++;
 
   return base::MakeUnique<SharedMemoryReceivedData>(
-      payload, length, encoded_data_length, encoded_body_length, this, id);
+      payload, length, encoded_data_length, this, id);
 }
 
 void SharedMemoryReceivedDataFactory::Stop() {
   is_stopped_ = true;
   released_tickets_.clear();
   message_sender_ = nullptr;
 }
 
 class SharedMemoryReceivedDataFactory::TicketComparator final {
  public:
@@ skipping 39 matching lines @@
   SendAck(count);
 }
 
 void SharedMemoryReceivedDataFactory::SendAck(size_t count) {
   for (size_t i = 0; i < count; ++i) {
     message_sender_->Send(new ResourceHostMsg_DataReceived_ACK(request_id_));
   }
 }
 
 }  // namespace content