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

content/browser/appcache/appcache_update_job.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/appcache/appcache_update_job.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
@@ skipping 11 matching lines @@
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
 #include "net/url_request/url_request_context.h"
 #include "url/origin.h"
 
 namespace content {
 
 namespace {
 
-const int kBufferSize = 32768;
+const int kAppCacheFetchBufferSize = 32768;
 const size_t kMaxConcurrentUrlFetches = 2;
 const int kMax503Retries = 3;
 
 std::string FormatUrlErrorMessage(
       const char* format, const GURL& url,
       AppCacheUpdateJob::ResultType error,
       int response_code) {
     // Show the net response code if we have one.
     int code = response_code;
     if (error != AppCacheUpdateJob::SERVER_ERROR)
@@ skipping 138 matching lines @@
 // Helper class to fetch resources. Depending on the fetch type,
 // can either fetch to an in-memory string or write the response
 // data out to the disk cache.
 AppCacheUpdateJob::URLFetcher::URLFetcher(const GURL& url,
                                           FetchType fetch_type,
                                           AppCacheUpdateJob* job)
     : url_(url),
       job_(job),
       fetch_type_(fetch_type),
       retry_503_attempts_(0),
-      buffer_(new net::IOBuffer(kBufferSize)),
+      buffer_(new net::IOBuffer(kAppCacheFetchBufferSize)),
       request_(
           job->service_->request_context()->CreateRequest(url,
                                                           net::DEFAULT_PRIORITY,
                                                           this,
                                                           kTrafficAnnotation)),
       result_(UPDATE_OK),
       redirect_response_code_(-1) {}
 
 AppCacheUpdateJob::URLFetcher::~URLFetcher() {
   // To defend against URLRequest calling delegate methods during
@@ skipping 94 matching lines @@
   if (!request_)
     return;
   DCHECK_NE(net::ERR_IO_PENDING, bytes_read);
   DCHECK_EQ(request_.get(), request);
   bool data_consumed = true;
   if (bytes_read > 0) {
     job_->MadeProgress();
     data_consumed = ConsumeResponseData(bytes_read);
     if (data_consumed) {
       while (true) {
-        bytes_read = request->Read(buffer_.get(), kBufferSize);
+        bytes_read = request->Read(buffer_.get(), kAppCacheFetchBufferSize);
         if (bytes_read <= 0)
           break;
         data_consumed = ConsumeResponseData(bytes_read);
         if (!data_consumed)
           break;
       }
     }
   }
 
   if (data_consumed && bytes_read != net::ERR_IO_PENDING) {
@@ skipping 36 matching lines @@
     OnResponseCompleted(net::ERR_ABORTED);
     return;
   }
   ReadResponseData();
 }
 
 void AppCacheUpdateJob::URLFetcher::ReadResponseData() {
   InternalUpdateState state = job_->internal_state_;
   if (state == CACHE_FAILURE || state == CANCELLED || state == COMPLETED)
     return;
-  int bytes_read = request_->Read(buffer_.get(), kBufferSize);
+  int bytes_read = request_->Read(buffer_.get(), kAppCacheFetchBufferSize);
   if (bytes_read != net::ERR_IO_PENDING)
     OnReadCompleted(request_.get(), bytes_read);
 }
 
 // Returns false if response data is processed asynchronously, in which
 // case ReadResponseData will be invoked when it is safe to continue
 // reading more response data from the request.
 bool AppCacheUpdateJob::URLFetcher::ConsumeResponseData(int bytes_read) {
   DCHECK_GT(bytes_read, 0);
   switch (fetch_type_) {
@@ skipping 827 matching lines @@
       AppCacheHistograms::AddMissingManifestEntrySample();
       service->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
     }
     return;
   }
 
   // Load manifest data from storage to compare against fetched manifest.
   manifest_response_reader_.reset(
       storage_->CreateResponseReader(manifest_url_,
                                      entry->response_id()));
-  read_manifest_buffer_ = new net::IOBuffer(kBufferSize);
+  read_manifest_buffer_ = new net::IOBuffer(kAppCacheFetchBufferSize);
   manifest_response_reader_->ReadData(
       read_manifest_buffer_.get(),
-      kBufferSize,
+      kAppCacheFetchBufferSize,
       base::Bind(&AppCacheUpdateJob::OnManifestDataReadComplete,
                  base::Unretained(this)));  // async read
 }
 
 void AppCacheUpdateJob::OnManifestDataReadComplete(int result) {
   if (result > 0) {
     loaded_manifest_data_.append(read_manifest_buffer_->data(), result);
     manifest_response_reader_->ReadData(
         read_manifest_buffer_.get(),
-        kBufferSize,
+        kAppCacheFetchBufferSize,
         base::Bind(&AppCacheUpdateJob::OnManifestDataReadComplete,
                    base::Unretained(this)));  // read more
   } else {
     read_manifest_buffer_ = NULL;
     manifest_response_reader_.reset();
     ContinueHandleManifestFetchCompleted(
         result < 0 || manifest_data_ != loaded_manifest_data_);
   }
 }
 
@@ skipping 520 matching lines @@
   // on this object after we've posted a task to delete ourselves.
   if (group_) {
     group_->SetUpdateAppCacheStatus(AppCacheGroup::IDLE);
     group_ = NULL;
   }
 
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
 }
 
 }  // namespace content