Snapshot of all changes to get jumbo in blink and content.

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"
@@ skipping 23 matching lines @@
 #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 kBufferMinAllocationSize = 1024 * 4;
 static int kMaxAllocationSize = 1024 * 32;
 
-void GetNumericArg(const std::string& name, int* result) {
+void GetNumericCommandLineArg(const std::string& name, int* result) {
   const std::string& value =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(name);
   if (!value.empty())
     base::StringToInt(value, result);
 }
 
-void InitializeResourceBufferConstants() {
+void InitializeResourceBufferConstantsFoo() {
   static bool did_init = false;
   if (did_init)
     return;
   did_init = true;
 
-  GetNumericArg("resource-buffer-size", &kBufferSize);
-  GetNumericArg("resource-buffer-min-allocation-size", &kMinAllocationSize);
-  GetNumericArg("resource-buffer-max-allocation-size", &kMaxAllocationSize);
+  GetNumericCommandLineArg("resource-buffer-size", &kBufferSize);
+  GetNumericCommandLineArg("resource-buffer-min-allocation-size", &kBufferMinAllocationSize);
+  GetNumericCommandLineArg("resource-buffer-max-allocation-size", &kMaxAllocationSize);
 }
 
 // This enum is used for logging a histogram and should not be reordered.
 enum ExpectedContentSizeResult {
   EQ_RESPONSE_BODY = 0,
   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
 
-class DependentIOBuffer : public net::WrappedIOBuffer {
+class DependentIOBufferFoo : public net::WrappedIOBuffer {
  public:
-  DependentIOBuffer(ResourceBuffer* backing, char* memory)
+  DependentIOBufferFoo(ResourceBuffer* backing, char* memory)
       : net::WrappedIOBuffer(memory),
         backing_(backing) {
   }
  private:
-  ~DependentIOBuffer() override {}
+  ~DependentIOBufferFoo() 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),
       reported_transfer_size_(0) {
   DCHECK(GetRequestInfo()->requester_info()->IsRenderer());
-  InitializeResourceBufferConstants();
+  InitializeResourceBufferConstantsFoo();
 }
 
 AsyncResourceHandler::~AsyncResourceHandler() {
   if (has_checked_for_sufficient_resources_)
     rdh_->FinishedWithResourcesForRequest(request());
 }
 
 bool AsyncResourceHandler::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AsyncResourceHandler, message)
@@ skipping 143 matching lines @@
 
   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);
+  *buf = new DependentIOBufferFoo(buffer_.get(), memory);
   *buf_size = allocation_size_;
 
   controller->Resume();
 }
 
 void AsyncResourceHandler::OnReadCompleted(
     int bytes_read,
     std::unique_ptr<ResourceController> controller) {
   DCHECK(!has_controller());
   DCHECK_GE(bytes_read, 0);
@@ skipping 114 matching lines @@
 }
 
 bool AsyncResourceHandler::EnsureResourceBufferIsInitialized() {
   DCHECK(has_checked_for_sufficient_resources_);
 
   if (buffer_.get() && buffer_->IsInitialized())
     return true;
 
   buffer_ = new ResourceBuffer();
   return buffer_->Initialize(kBufferSize,
-                             kMinAllocationSize,
+                             kBufferMinAllocationSize,
                              kMaxAllocationSize);
 }
 
 void AsyncResourceHandler::ResumeIfDeferred() {
   if (has_controller()) {
     request()->LogUnblocked();
     Resume();
   }
 }
 
@@ skipping 76 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