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

content/browser/appcache/appcache_storage_impl.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_storage_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
@@ skipping 26 matching lines @@
 #include "storage/browser/quota/quota_client.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace content {
 
 // Hard coded default when not using quota management.
 static const int kDefaultQuota = 5 * 1024 * 1024;
 
-static const int kMaxDiskCacheSize = 250 * 1024 * 1024;
-static const int kMaxMemDiskCacheSize = 10 * 1024 * 1024;
+static const int kAppCacheMaxDiskCacheSize = 250 * 1024 * 1024;
+static const int kAppCacheMaxMemDiskCacheSize = 10 * 1024 * 1024;
 static const base::FilePath::CharType kDiskCacheDirectoryName[] =
     FILE_PATH_LITERAL("Cache");
 
 namespace {
 
 // Helpers for clearing data from the AppCacheDatabase.
 bool DeleteGroupAndRelatedRecords(
     AppCacheDatabase* database,
     int64_t group_id,
     std::vector<int64_t>* deletable_response_ids) {
@@ skipping 11 matching lines @@
         database->InsertDeletableResponseIds(*deletable_response_ids);
   } else {
     NOTREACHED() << "A existing group without a cache is unexpected";
     success = database->DeleteGroup(group_id);
   }
   return success;
 }
 
 // Destroys |database|. If there is appcache data to be deleted
 // (|force_keep_session_state| is false), deletes session-only appcache data.
-void ClearSessionOnlyOrigins(
+void AppCacheClearSessionOnlyOrigins(
     AppCacheDatabase* database,
     scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy,
     bool force_keep_session_state) {
   std::unique_ptr<AppCacheDatabase> database_to_delete(database);
 
   // If saving session state, only delete the database.
   if (force_keep_session_state)
     return;
 
   bool has_session_only_appcaches =
@@ skipping 1310 matching lines @@
 
 AppCacheStorageImpl::~AppCacheStorageImpl() {
   for (auto* task : pending_quota_queries_)
     task->CancelCompletion();
   for (auto* task : scheduled_database_tasks_)
     task->CancelCompletion();
 
   if (database_ &&
       !db_task_runner_->PostTask(
           FROM_HERE,
-          base::BindOnce(&ClearSessionOnlyOrigins, database_,
+          base::BindOnce(&AppCacheClearSessionOnlyOrigins, database_,
                          make_scoped_refptr(service_->special_storage_policy()),
                          service()->force_keep_session_state()))) {
     delete database_;
   }
   database_ = NULL;  // So no further database tasks can be scheduled.
 }
 
 void AppCacheStorageImpl::Initialize(
     const base::FilePath& cache_directory,
     const scoped_refptr<base::SequencedTaskRunner>& db_task_runner) {
@@ skipping 459 matching lines @@
 
 AppCacheDiskCache* AppCacheStorageImpl::disk_cache() {
   DCHECK(IsInitTaskComplete());
   DCHECK(!is_disabled_);
 
   if (!disk_cache_) {
     int rv = net::OK;
     disk_cache_.reset(new AppCacheDiskCache);
     if (is_incognito_) {
       rv = disk_cache_->InitWithMemBackend(
-          kMaxMemDiskCacheSize,
+          kAppCacheMaxMemDiskCacheSize,
           base::Bind(&AppCacheStorageImpl::OnDiskCacheInitialized,
                      base::Unretained(this)));
     } else {
       expecting_cleanup_complete_on_disable_ = true;
       rv = disk_cache_->InitWithDiskBackend(
-          cache_directory_.Append(kDiskCacheDirectoryName), kMaxDiskCacheSize,
+          cache_directory_.Append(kDiskCacheDirectoryName),
+          kAppCacheMaxDiskCacheSize,
           false,
           base::BindOnce(&AppCacheStorageImpl::OnDiskCacheCleanupComplete,
                          weak_factory_.GetWeakPtr()),
           base::Bind(&AppCacheStorageImpl::OnDiskCacheInitialized,
                      base::Unretained(this)));
     }
 
     if (rv != net::ERR_IO_PENDING)
       OnDiskCacheInitialized(rv);
   }
@@ skipping 62 matching lines @@
 
 void AppCacheStorageImpl::OnLazyCommitTimer() {
   lazy_commit_timer_.Stop();
   if (is_disabled())
     return;
   scoped_refptr<DatabaseTask> task(new CommitLastAccessTimesTask(this));
   task->Schedule();
 }
 
 }  // namespace content