Remove inline small resource transfer experiment

content/browser/loader/async_resource_handler.cc

 // Copyright (c) 2012 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/browser/loader/async_resource_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/debug/alias.h"
-#include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "content/browser/loader/netlog_observer.h"
 #include "content/browser/loader/resource_buffer.h"
 #include "content/browser/loader/resource_controller.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/loader/upload_progress_tracker.h"
 #include "content/common/resource_messages.h"
 #include "content/common/resource_request_completion_status.h"
 #include "content/common/view_messages.h"
-#include "content/public/common/content_features.h"
 #include "content/public/common/resource_response.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/upload_progress.h"
 #include "net/url_request/redirect_info.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace content {
 namespace {
 
 static int kBufferSize = 1024 * 512;
 static int kMinAllocationSize = 1024 * 4;
 static int kMaxAllocationSize = 1024 * 32;
 
-// Used when kOptimizeLoadingIPCForSmallResources is enabled.
-// Small resource typically issues two Read call: one for the content itself
-// and another for getting zero response to detect EOF.
-// Inline these two into the IPC message to avoid allocating an expensive
-// SharedMemory for small resources.
-const int kNumLeadingChunk = 2;
-const int kInlinedLeadingChunkSize = 2048;
-
 void GetNumericArg(const std::string& name, int* result) {
   const std::string& value =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(name);
   if (!value.empty())
     base::StringToInt(value, result);
 }
 
 void InitializeResourceBufferConstants() {
   static bool did_init = false;
   if (did_init)
@@ skipping 11 matching lines @@
   EQ_RESPONSE_BODY_GT_EQ_BUFFER_SIZE = 1,
   GT_EQ_BUFFER_SIZE = 2,
   LT_RESPONSE_BODY = 3,
   GT_RESPONSE_BODY = 4,
   UNKNOWN = 5,
   EXPECTED_CONTENT_MAX,
 };
 
 }  // namespace
 
-// Used when kOptimizeLoadingIPCForSmallResources is enabled.
-// The instance hooks the buffer allocation of AsyncResourceHandler, and
-// determine if we should use SharedMemory or should inline the data into
-// the IPC message.
-class AsyncResourceHandler::InliningHelper {
- public:
-
-  InliningHelper() {}
-  ~InliningHelper() {}
-
-  void OnResponseReceived(const ResourceResponse& response) {
-    InliningStatus status = IsInliningApplicable(response);
-    UMA_HISTOGRAM_ENUMERATION(
-        "Net.ResourceLoader.InliningStatus",
-        static_cast<int>(status),
-        static_cast<int>(InliningStatus::INLINING_STATUS_COUNT));
-    inlining_applicable_ = status == InliningStatus::APPLICABLE;
-  }
-
-  // Returns true if InliningHelper allocates the buffer for inlining.
-  bool PrepareInlineBufferIfApplicable(scoped_refptr<net::IOBuffer>* buf,
-                                      int* buf_size) {
-    ++num_allocation_;
-
-    // If the server sends the resource in multiple small chunks,
-    // |num_allocation_| may exceed |kNumLeadingChunk|. Disable inlining and
-    // fall back to the regular resource loading path in that case.
-    if (!inlining_applicable_ ||
-        num_allocation_ > kNumLeadingChunk ||
-        !base::FeatureList::IsEnabled(
-            features::kOptimizeLoadingIPCForSmallResources)) {
-      return false;
-    }
-
-    leading_chunk_buffer_ = new net::IOBuffer(kInlinedLeadingChunkSize);
-    *buf = leading_chunk_buffer_;
-    *buf_size = kInlinedLeadingChunkSize;
-    return true;
-  }
-
-  // Returns true if the received data is sent to the consumer.
-  bool SendInlinedDataIfApplicable(int bytes_read,
-                                   int encoded_data_length,
-                                   IPC::Sender* sender,
-                                   int request_id) {
-    DCHECK(sender);
-    if (!leading_chunk_buffer_)
-      return false;
-
-    std::vector<char> data(
-        leading_chunk_buffer_->data(),
-        leading_chunk_buffer_->data() + bytes_read);
-    leading_chunk_buffer_ = nullptr;
-
-    sender->Send(new ResourceMsg_InlinedDataChunkReceived(
-        request_id, data, encoded_data_length));
-    return true;
-  }
-
-  void RecordHistogram(int64_t elapsed_time) {
-    if (inlining_applicable_) {
-      UMA_HISTOGRAM_CUSTOM_COUNTS(
-          "Net.ResourceLoader.ResponseStartToEnd.InliningApplicable",
-          elapsed_time, 1, 100000, 100);
-    }
-  }
-
- private:
-  enum class InliningStatus : int {
-    APPLICABLE = 0,
-    EARLY_ALLOCATION = 1,
-    UNKNOWN_CONTENT_LENGTH = 2,
-    LARGE_CONTENT = 3,
-    HAS_TRANSFER_ENCODING = 4,
-    HAS_CONTENT_ENCODING = 5,
-    INLINING_STATUS_COUNT,
-  };
-
-  InliningStatus IsInliningApplicable(const ResourceResponse& response) {
-    // Disable if the leading chunk is already arrived.
-    if (num_allocation_)
-      return InliningStatus::EARLY_ALLOCATION;
-
-    // Disable if the content is known to be large.
-    if (response.head.content_length > kInlinedLeadingChunkSize)
-      return InliningStatus::LARGE_CONTENT;
-
-    // Disable if the length of the content is unknown.
-    if (response.head.content_length < 0)
-      return InliningStatus::UNKNOWN_CONTENT_LENGTH;
-
-    if (response.head.headers) {
-      if (response.head.headers->HasHeader("Transfer-Encoding"))
-        return InliningStatus::HAS_TRANSFER_ENCODING;
-      if (response.head.headers->HasHeader("Content-Encoding"))
-        return InliningStatus::HAS_CONTENT_ENCODING;
-    }
-
-    return InliningStatus::APPLICABLE;
-  }
-
-  int num_allocation_ = 0;
-  bool inlining_applicable_ = false;
-  scoped_refptr<net::IOBuffer> leading_chunk_buffer_;
-};
-
 class DependentIOBuffer : public net::WrappedIOBuffer {
  public:
   DependentIOBuffer(ResourceBuffer* backing, char* memory)
       : net::WrappedIOBuffer(memory),
         backing_(backing) {
   }
  private:
   ~DependentIOBuffer() override {}
   scoped_refptr<ResourceBuffer> backing_;
 };
 
 AsyncResourceHandler::AsyncResourceHandler(net::URLRequest* request,
                                            ResourceDispatcherHostImpl* rdh)
     : ResourceHandler(request),
       ResourceMessageDelegate(request),
       rdh_(rdh),
       pending_data_count_(0),
       allocation_size_(0),
       total_read_body_bytes_(0),
       has_checked_for_sufficient_resources_(false),
       sent_received_response_msg_(false),
       sent_data_buffer_msg_(false),
-      inlining_helper_(new InliningHelper),
       reported_transfer_size_(0) {
   DCHECK(GetRequestInfo()->requester_info()->IsRenderer());
   InitializeResourceBufferConstants();
 }
 
 AsyncResourceHandler::~AsyncResourceHandler() {
   if (has_checked_for_sufficient_resources_)
     rdh_->FinishedWithResourcesForRequest(request());
 }
 
@@ skipping 103 matching lines @@
       new ResourceMsg_ReceivedResponse(GetRequestID(), response->head));
   sent_received_response_msg_ = true;
 
   if (request()->response_info().metadata.get()) {
     std::vector<char> copy(request()->response_info().metadata->data(),
                            request()->response_info().metadata->data() +
                                request()->response_info().metadata->size());
     filter->Send(new ResourceMsg_ReceivedCachedMetadata(GetRequestID(), copy));
   }
 
-  inlining_helper_->OnResponseReceived(*response);
   controller->Resume();
 }
 
 void AsyncResourceHandler::OnWillStart(
     const GURL& url,
     std::unique_ptr<ResourceController> controller) {
   ResourceMessageFilter* filter = GetFilter();
   if (!filter) {
     controller->Cancel();
     return;
@@ skipping 14 matching lines @@
     scoped_refptr<net::IOBuffer>* buf,
     int* buf_size,
     std::unique_ptr<ResourceController> controller) {
   DCHECK(!has_controller());
 
   if (!CheckForSufficientResource()) {
     controller->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
     return;
   }
 
-  // Return early if InliningHelper allocates the buffer, so that we should
-  // inline the data into the IPC message without allocating SharedMemory.
-  if (inlining_helper_->PrepareInlineBufferIfApplicable(buf, buf_size)) {
-    controller->Resume();
-    return;
-  }
-
   if (!EnsureResourceBufferIsInitialized()) {
     controller->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
     return;
   }
 
   DCHECK(buffer_->CanAllocate());
   char* memory = buffer_->Allocate(&allocation_size_);
   CHECK(memory);
 
   *buf = new DependentIOBuffer(buffer_.get(), memory);
@@ skipping 18 matching lines @@
     controller->Cancel();
     return;
   }
 
   int encoded_data_length = CalculateEncodedDataLengthToReport();
   if (!first_chunk_read_)
     encoded_data_length -= request()->raw_header_size();
 
   first_chunk_read_ = true;
 
-  // Return early if InliningHelper handled the received data.
-  if (inlining_helper_->SendInlinedDataIfApplicable(
-          bytes_read, encoded_data_length, filter, GetRequestID())) {
-    controller->Resume();
-    return;
-  }
-
   buffer_->ShrinkLastAllocation(bytes_read);
 
   total_read_body_bytes_ += bytes_read;
 
   if (!sent_data_buffer_msg_) {
     base::SharedMemoryHandle handle = base::SharedMemory::DuplicateHandle(
         buffer_->GetSharedMemory().handle());
     if (!base::SharedMemory::IsHandleValid(handle)) {
       controller->Cancel();
       return;
@@ skipping 143 matching lines @@
     // The resource was smaller than single chunk.
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Net.ResourceLoader.ResponseStartToEnd.LT_512kB",
         elapsed_time, 1, 100000, 100);
   } else {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Net.ResourceLoader.ResponseStartToEnd.Over_512kB",
         elapsed_time, 1, 100000, 100);
   }
 
-  inlining_helper_->RecordHistogram(elapsed_time);
-
   // Record if content size was known in advance.
   int64_t expected_content_size = request()->GetExpectedContentSize();
   ExpectedContentSizeResult expected_content_size_result =
       ExpectedContentSizeResult::UNKNOWN;
   if (expected_content_size >= 0) {
     // Compare response body size to expected content size.
     if (expected_content_size == total_read_body_bytes_ &&
         expected_content_size >= kBufferSize) {
       expected_content_size_result =
           ExpectedContentSizeResult::EQ_RESPONSE_BODY_GT_EQ_BUFFER_SIZE;
@@ skipping 19 matching lines @@
 void AsyncResourceHandler::SendUploadProgress(
     const net::UploadProgress& progress) {
   ResourceMessageFilter* filter = GetFilter();
   if (!filter)
     return;
   filter->Send(new ResourceMsg_UploadProgress(
       GetRequestID(), progress.position(), progress.size()));
 }
 
 }  // namespace content