BASELINE: Update Chromium to 86.0.4240.124

Change-Id: Ide0ff151e94cd665ae6521a446995d34a9d1d644
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

32 files changed, 807 insertions, 506 deletions

diff --git a/chromium/content/browser/appcache/appcache.cc b/chromium/content/browser/appcache/appcache.cc
index 13811b177db..f309c6f23df 100644
--- a/chromium/content/browser/appcache/appcache.cc
+++ b/chromium/content/browser/appcache/appcache.cc
@@ -54,7 +54,7 @@ std::string AppCache::GetManifestScope(const GURL& manifest_url,
 AppCache::AppCache(AppCacheStorage* storage, int64_t cache_id)
     : cache_id_(cache_id),
       owning_group_(nullptr),
-      online_whitelist_all_(false),
+      online_safelist_all_(false),
       is_complete_(false),
       cache_size_(0),
       padding_size_(0),
@@ -153,8 +153,8 @@ void AppCache::InitializeWithManifest(AppCacheManifest* manifest) {
   manifest_scope_ = manifest->scope;
   intercept_namespaces_.swap(manifest->intercept_namespaces);
   fallback_namespaces_.swap(manifest->fallback_namespaces);
-  online_whitelist_namespaces_.swap(manifest->online_whitelist_namespaces);
-  online_whitelist_all_ = manifest->online_whitelist_all;
+  online_safelist_namespaces_.swap(manifest->online_safelist_namespaces);
+  online_safelist_all_ = manifest->online_safelist_all;
   token_expires_ = manifest->token_expires;
 
   // Sort the namespaces by url string length, longest to shortest,
@@ -170,11 +170,11 @@ void AppCache::InitializeWithDatabaseRecords(
     const std::vector<AppCacheDatabase::EntryRecord>& entries,
     const std::vector<AppCacheDatabase::NamespaceRecord>& intercepts,
     const std::vector<AppCacheDatabase::NamespaceRecord>& fallbacks,
-    const std::vector<AppCacheDatabase::OnlineWhiteListRecord>& whitelists) {
+    const std::vector<AppCacheDatabase::OnlineSafeListRecord>& safelists) {
   DCHECK_EQ(cache_id_, cache_record.cache_id);
   manifest_parser_version_ = cache_record.manifest_parser_version;
   manifest_scope_ = cache_record.manifest_scope;
-  online_whitelist_all_ = cache_record.online_wildcard;
+  online_safelist_all_ = cache_record.online_wildcard;
   update_time_ = cache_record.update_time;
   token_expires_ = cache_record.token_expires;
 
@@ -198,9 +198,9 @@ void AppCache::InitializeWithDatabaseRecords(
   std::sort(fallback_namespaces_.begin(), fallback_namespaces_.end(),
             SortNamespacesByLength);
 
-  for (const auto& record : whitelists) {
-    online_whitelist_namespaces_.emplace_back(APPCACHE_NETWORK_NAMESPACE,
-                                              record.namespace_url, GURL());
+  for (const auto& record : safelists) {
+    online_safelist_namespaces_.emplace_back(APPCACHE_NETWORK_NAMESPACE,
+                                             record.namespace_url, GURL());
   }
 }
 
@@ -210,13 +210,13 @@ void AppCache::ToDatabaseRecords(
     std::vector<AppCacheDatabase::EntryRecord>* entries,
     std::vector<AppCacheDatabase::NamespaceRecord>* intercepts,
     std::vector<AppCacheDatabase::NamespaceRecord>* fallbacks,
-    std::vector<AppCacheDatabase::OnlineWhiteListRecord>* whitelists) {
-  DCHECK(group && cache_record && entries && fallbacks && whitelists);
-  DCHECK(entries->empty() && fallbacks->empty() && whitelists->empty());
+    std::vector<AppCacheDatabase::OnlineSafeListRecord>* safelists) {
+  DCHECK(group && cache_record && entries && fallbacks && safelists);
+  DCHECK(entries->empty() && fallbacks->empty() && safelists->empty());
 
   cache_record->cache_id = cache_id_;
   cache_record->group_id = group->group_id();
-  cache_record->online_wildcard = online_whitelist_all_;
+  cache_record->online_wildcard = online_safelist_all_;
   cache_record->update_time = update_time_;
   cache_record->cache_size = cache_size_;
   cache_record->padding_size = padding_size_;
@@ -254,9 +254,9 @@ void AppCache::ToDatabaseRecords(
   }
 
   for (const AppCacheNamespace& online_namespace :
-       online_whitelist_namespaces_) {
-    whitelists->push_back(AppCacheDatabase::OnlineWhiteListRecord());
-    AppCacheDatabase::OnlineWhiteListRecord& record = whitelists->back();
+       online_safelist_namespaces_) {
+    safelists->push_back(AppCacheDatabase::OnlineSafeListRecord());
+    AppCacheDatabase::OnlineSafeListRecord& record = safelists->back();
     record.cache_id = cache_id_;
     record.namespace_url = online_namespace.namespace_url;
   }
@@ -308,7 +308,7 @@ bool AppCache::FindResponseForRequest(const GURL& url,
     return true;
   }
 
-  *found_network_namespace = online_whitelist_all_;
+  *found_network_namespace = online_safelist_all_;
   return *found_network_namespace;
 }
 
diff --git a/chromium/content/browser/appcache/appcache.h b/chromium/content/browser/appcache/appcache.h
index 14af3e86f15..e12205501f0 100644
--- a/chromium/content/browser/appcache/appcache.h
+++ b/chromium/content/browser/appcache/appcache.h
@@ -149,7 +149,7 @@ class CONTENT_EXPORT AppCache
       const std::vector<AppCacheDatabase::EntryRecord>& entries,
       const std::vector<AppCacheDatabase::NamespaceRecord>& intercepts,
       const std::vector<AppCacheDatabase::NamespaceRecord>& fallbacks,
-      const std::vector<AppCacheDatabase::OnlineWhiteListRecord>& whitelists);
+      const std::vector<AppCacheDatabase::OnlineSafeListRecord>& safelists);
 
   // Returns the database records to be stored in the AppCacheDatabase
   // to represent this cache.
@@ -159,7 +159,7 @@ class CONTENT_EXPORT AppCache
       std::vector<AppCacheDatabase::EntryRecord>* entries,
       std::vector<AppCacheDatabase::NamespaceRecord>* intercepts,
       std::vector<AppCacheDatabase::NamespaceRecord>* fallbacks,
-      std::vector<AppCacheDatabase::OnlineWhiteListRecord>* whitelists);
+      std::vector<AppCacheDatabase::OnlineSafeListRecord>* safelists);
 
   bool FindResponseForRequest(const GURL& url,
       AppCacheEntry* found_entry, GURL* found_intercept_namespace,
@@ -195,7 +195,7 @@ class CONTENT_EXPORT AppCache
     return FindNamespace(fallback_namespaces_, url);
   }
   bool IsInNetworkNamespace(const GURL& url) {
-    return FindNamespace(online_whitelist_namespaces_, url) != nullptr;
+    return FindNamespace(online_safelist_namespaces_, url) != nullptr;
   }
 
   GURL GetNamespaceEntryUrl(const std::vector<AppCacheNamespace>& namespaces,
@@ -215,8 +215,8 @@ class CONTENT_EXPORT AppCache
 
   std::vector<AppCacheNamespace> intercept_namespaces_;
   std::vector<AppCacheNamespace> fallback_namespaces_;
-  std::vector<AppCacheNamespace> online_whitelist_namespaces_;
-  bool online_whitelist_all_;
+  std::vector<AppCacheNamespace> online_safelist_namespaces_;
+  bool online_safelist_all_;
 
   bool is_complete_;
 
diff --git a/chromium/content/browser/appcache/appcache_backfillers.cc b/chromium/content/browser/appcache/appcache_backfillers.cc
index c6a6b9d9184..f3509a30e05 100644
--- a/chromium/content/browser/appcache/appcache_backfillers.cc
+++ b/chromium/content/browser/appcache/appcache_backfillers.cc
@@ -5,6 +5,7 @@
 #include "content/browser/appcache/appcache_backfillers.h"
 
 #include "content/browser/appcache/appcache_update_job.h"
+#include "net/http/http_request_headers.h"
 #include "sql/statement.h"
 #include "storage/browser/quota/padding_key.h"
 #include "url/gurl.h"
@@ -19,7 +20,7 @@ int64_t ComputeEntryPaddingSize(std::string response_url,
     return 0;
   return storage::ComputeResponsePadding(
       response_url, storage::GetDefaultPaddingKey(), /*has_metadata=*/false,
-      /*loaded_with_credentials=*/false);
+      /*loaded_with_credentials=*/false, net::HttpRequestHeaders::kGetMethod);
 }
 
 // Iterates over each Cache record; execute |callable| on each iteration.
diff --git a/chromium/content/browser/appcache/appcache_cache_test_helper.cc b/chromium/content/browser/appcache/appcache_cache_test_helper.cc
index 816c2a429ce..6cae91b4fb1 100644
--- a/chromium/content/browser/appcache/appcache_cache_test_helper.cc
+++ b/chromium/content/browser/appcache/appcache_cache_test_helper.cc
@@ -9,6 +9,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/appcache/appcache_response_info.h"
+#include "net/base/io_buffer.h"
 #include "net/http/http_response_headers.h"
 
 namespace content {
diff --git a/chromium/content/browser/appcache/appcache_database.cc b/chromium/content/browser/appcache/appcache_database.cc
index b97aa41c977..e2148da8719 100644
--- a/chromium/content/browser/appcache/appcache_database.cc
+++ b/chromium/content/browser/appcache/appcache_database.cc
@@ -60,7 +60,8 @@ const char kGroupsTable[] = "Groups";
 const char kCachesTable[] = "Caches";
 const char kEntriesTable[] = "Entries";
 const char kNamespacesTable[] = "Namespaces";
-const char kOnlineWhiteListsTable[] = "OnlineWhiteLists";
+// TODO(crbug.com/1108479): Update table name, add migration.
+const char kOnlineSafeListsTable[] = "OnlineWhiteLists";
 const char kDeletableResponseIdsTable[] = "DeletableResponseIds";
 
 struct TableInfo {
@@ -117,7 +118,7 @@ const TableInfo kTables[] = {
      " token_expires INTEGER)"},
 
     // The |is_pattern| field is obsolete.
-    {kOnlineWhiteListsTable,
+    {kOnlineSafeListsTable,
      "(cache_id INTEGER,"
      " namespace_url TEXT,"
      " is_pattern INTEGER CHECK(is_pattern IN (0, 1)))"},
@@ -126,60 +127,30 @@ const TableInfo kTables[] = {
 };
 
 const IndexInfo kIndexes[] = {
-  { "GroupsOriginIndex",
-    kGroupsTable,
-    "(origin)",
-    false },
-
-  { "GroupsManifestIndex",
-    kGroupsTable,
-    "(manifest_url)",
-    true },
-
-  { "CachesGroupIndex",
-    kCachesTable,
-    "(group_id)",
-    false },
-
-  { "EntriesCacheIndex",
-    kEntriesTable,
-    "(cache_id)",
-    false },
-
-  { "EntriesCacheAndUrlIndex",
-    kEntriesTable,
-    "(cache_id, url)",
-    true },
-
-  { "EntriesResponseIdIndex",
-    kEntriesTable,
-    "(response_id)",
-    true },
-
-  { "NamespacesCacheIndex",
-    kNamespacesTable,
-    "(cache_id)",
-    false },
-
-  { "NamespacesOriginIndex",
-    kNamespacesTable,
-    "(origin)",
-    false },
-
-  { "NamespacesCacheAndUrlIndex",
-    kNamespacesTable,
-    "(cache_id, namespace_url)",
-    true },
-
-  { "OnlineWhiteListCacheIndex",
-    kOnlineWhiteListsTable,
-    "(cache_id)",
-    false },
-
-  { "DeletableResponsesIdIndex",
-    kDeletableResponseIdsTable,
-    "(response_id)",
-    true },
+    {"GroupsOriginIndex", kGroupsTable, "(origin)", false},
+
+    {"GroupsManifestIndex", kGroupsTable, "(manifest_url)", true},
+
+    {"CachesGroupIndex", kCachesTable, "(group_id)", false},
+
+    {"EntriesCacheIndex", kEntriesTable, "(cache_id)", false},
+
+    {"EntriesCacheAndUrlIndex", kEntriesTable, "(cache_id, url)", true},
+
+    {"EntriesResponseIdIndex", kEntriesTable, "(response_id)", true},
+
+    {"NamespacesCacheIndex", kNamespacesTable, "(cache_id)", false},
+
+    {"NamespacesOriginIndex", kNamespacesTable, "(origin)", false},
+
+    {"NamespacesCacheAndUrlIndex", kNamespacesTable,
+     "(cache_id, namespace_url)", true},
+
+    // TODO(crbug.com/1108479): Update table name, add migration.
+    {"OnlineWhiteListCacheIndex", kOnlineSafeListsTable, "(cache_id)", false},
+
+    {"DeletableResponsesIdIndex", kDeletableResponseIdsTable, "(response_id)",
+     true},
 };
 
 bool CreateTable(sql::Database* db, const TableInfo& info) {
@@ -852,13 +823,14 @@ bool AppCacheDatabase::DeleteNamespacesForCache(int64_t cache_id) {
   return statement.Run();
 }
 
-bool AppCacheDatabase::FindOnlineWhiteListForCache(
+bool AppCacheDatabase::FindOnlineSafeListForCache(
     int64_t cache_id,
-    std::vector<OnlineWhiteListRecord>* records) {
+    std::vector<OnlineSafeListRecord>* records) {
   DCHECK(records && records->empty());
   if (!LazyOpen(kDontCreate))
     return false;
 
+  // TODO(crbug.com/1108479): Update table name.
   static const char kSql[] =
       "SELECT cache_id, namespace_url, is_pattern FROM OnlineWhiteLists"
       "  WHERE cache_id = ?";
@@ -867,18 +839,19 @@ bool AppCacheDatabase::FindOnlineWhiteListForCache(
   statement.BindInt64(0, cache_id);
 
   while (statement.Step()) {
-    records->push_back(OnlineWhiteListRecord());
-    this->ReadOnlineWhiteListRecord(statement, &records->back());
+    records->push_back(OnlineSafeListRecord());
+    this->ReadOnlineSafeListRecord(statement, &records->back());
     DCHECK(records->back().cache_id == cache_id);
   }
   return statement.Succeeded();
 }
 
-bool AppCacheDatabase::InsertOnlineWhiteList(
-    const OnlineWhiteListRecord* record) {
+bool AppCacheDatabase::InsertOnlineSafeList(
+    const OnlineSafeListRecord* record) {
   if (!LazyOpen(kCreateIfNeeded))
     return false;
 
+  // TODO(crbug.com/1108479): Update table name.
   static const char kSql[] =
       "INSERT INTO OnlineWhiteLists (cache_id, namespace_url, is_pattern)"
       "  VALUES (?, ?, ?)";
@@ -891,24 +864,25 @@ bool AppCacheDatabase::InsertOnlineWhiteList(
   return statement.Run();
 }
 
-bool AppCacheDatabase::InsertOnlineWhiteListRecords(
-    const std::vector<OnlineWhiteListRecord>& records) {
+bool AppCacheDatabase::InsertOnlineSafeListRecords(
+    const std::vector<OnlineSafeListRecord>& records) {
   if (records.empty())
     return true;
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
   for (const auto& record : records) {
-    if (!InsertOnlineWhiteList(&record))
+    if (!InsertOnlineSafeList(&record))
       return false;
   }
   return transaction.Commit();
 }
 
-bool AppCacheDatabase::DeleteOnlineWhiteListForCache(int64_t cache_id) {
+bool AppCacheDatabase::DeleteOnlineSafeListForCache(int64_t cache_id) {
   if (!LazyOpen(kDontCreate))
     return false;
 
+  // TODO(crbug.com/1108479): Update table name.
   static const char kSql[] = "DELETE FROM OnlineWhiteLists WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
@@ -1094,13 +1068,13 @@ void AppCacheDatabase::ReadNamespaceRecord(
   record->namespace_.target_url = GURL(statement->ColumnString(4));
   DCHECK(record->namespace_.type == APPCACHE_FALLBACK_NAMESPACE ||
          record->namespace_.type == APPCACHE_INTERCEPT_NAMESPACE);
-  // The APPCACHE_NETWORK_NAMESPACE are stored as OnlineWhiteListRecords.
+  // The APPCACHE_NETWORK_NAMESPACE are stored as OnlineSafeListRecords.
   record->token_expires =
       base::Time::FromInternalValue(statement->ColumnInt64(5));
 }
 
-void AppCacheDatabase::ReadOnlineWhiteListRecord(
-    const sql::Statement& statement, OnlineWhiteListRecord* record) {
+void AppCacheDatabase::ReadOnlineSafeListRecord(const sql::Statement& statement,
+                                                OnlineSafeListRecord* record) {
   record->cache_id = statement.ColumnInt64(0);
   record->namespace_url = GURL(statement.ColumnString(1));
 }
@@ -1293,7 +1267,7 @@ bool AppCacheDatabase::DeleteExistingAndCreateNewDatabase() {
 
   // This also deletes the disk cache data.
   base::FilePath directory = db_file_path_.DirName();
-  if (!base::DeleteFileRecursively(directory))
+  if (!base::DeletePathRecursively(directory))
     return false;
 
   // Make sure the steps above actually deleted things.
diff --git a/chromium/content/browser/appcache/appcache_database.h b/chromium/content/browser/appcache/appcache_database.h
index 06146d16417..2ff711d6fc1 100644
--- a/chromium/content/browser/appcache/appcache_database.h
+++ b/chromium/content/browser/appcache/appcache_database.h
@@ -39,7 +39,7 @@ FORWARD_DECLARE_TEST(AppCacheDatabaseTest, GroupRecords);
 FORWARD_DECLARE_TEST(AppCacheDatabaseTest, GroupAccessAndEvictionTimes);
 FORWARD_DECLARE_TEST(AppCacheDatabaseTest, LazyOpen);
 FORWARD_DECLARE_TEST(AppCacheDatabaseTest, ExperimentalFlags);
-FORWARD_DECLARE_TEST(AppCacheDatabaseTest, OnlineWhiteListRecords);
+FORWARD_DECLARE_TEST(AppCacheDatabaseTest, OnlineSafeListRecords);
 FORWARD_DECLARE_TEST(AppCacheDatabaseTest, ReCreate);
 FORWARD_DECLARE_TEST(AppCacheDatabaseTest, DeletableResponseIds);
 FORWARD_DECLARE_TEST(AppCacheDatabaseTest, OriginUsage);
@@ -116,8 +116,8 @@ class CONTENT_EXPORT AppCacheDatabase {
 
   using NamespaceRecordVector = std::vector<NamespaceRecord>;
 
-  struct OnlineWhiteListRecord {
-    OnlineWhiteListRecord() : cache_id(0) {}
+  struct OnlineSafeListRecord {
+    OnlineSafeListRecord() : cache_id(0) {}
 
     int64_t cache_id;
     GURL namespace_url;
@@ -195,12 +195,12 @@ class CONTENT_EXPORT AppCacheDatabase {
   bool InsertNamespace(const NamespaceRecord* record);
   bool DeleteNamespacesForCache(int64_t cache_id);
 
-  bool FindOnlineWhiteListForCache(int64_t cache_id,
-                                   std::vector<OnlineWhiteListRecord>* records);
-  bool InsertOnlineWhiteList(const OnlineWhiteListRecord* record);
-  bool InsertOnlineWhiteListRecords(
-      const std::vector<OnlineWhiteListRecord>& records);
-  bool DeleteOnlineWhiteListForCache(int64_t cache_id);
+  bool FindOnlineSafeListForCache(int64_t cache_id,
+                                  std::vector<OnlineSafeListRecord>* records);
+  bool InsertOnlineSafeList(const OnlineSafeListRecord* record);
+  bool InsertOnlineSafeListRecords(
+      const std::vector<OnlineSafeListRecord>& records);
+  bool DeleteOnlineSafeListForCache(int64_t cache_id);
 
   bool GetDeletableResponseIds(std::vector<int64_t>* response_ids,
                                int64_t max_rowid,
@@ -238,8 +238,8 @@ class CONTENT_EXPORT AppCacheDatabase {
       NamespaceRecordVector* fallbacks);
   void ReadNamespaceRecord(
       const sql::Statement* statement, NamespaceRecord* record);
-  void ReadOnlineWhiteListRecord(
-      const sql::Statement& statement, OnlineWhiteListRecord* record);
+  void ReadOnlineSafeListRecord(const sql::Statement& statement,
+                                OnlineSafeListRecord* record);
 
   // Database creation
   bool LazyOpen(bool create_if_needed);
@@ -278,7 +278,7 @@ class CONTENT_EXPORT AppCacheDatabase {
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheDatabaseTest, LazyOpen);
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheDatabaseTest, ExperimentalFlags);
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheDatabaseTest,
-                           OnlineWhiteListRecords);
+                           OnlineSafeListRecords);
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheDatabaseTest, ReCreate);
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheDatabaseTest, DeletableResponseIds);
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheDatabaseTest, OriginUsage);
diff --git a/chromium/content/browser/appcache/appcache_database_unittest.cc b/chromium/content/browser/appcache/appcache_database_unittest.cc
index e842db8b39f..ca5712bc5b1 100644
--- a/chromium/content/browser/appcache/appcache_database_unittest.cc
+++ b/chromium/content/browser/appcache/appcache_database_unittest.cc
@@ -671,7 +671,7 @@ TEST_F(AppCacheDatabaseTest, NamespaceRecords) {
   ASSERT_TRUE(expecter.SawExpectedErrors());
 }
 
-TEST_F(AppCacheDatabaseTest, OnlineWhiteListRecords) {
+TEST_F(AppCacheDatabaseTest, OnlineSafeListRecords) {
   const base::FilePath kEmptyPath;
   AppCacheDatabase db(kEmptyPath);
   EXPECT_TRUE(db.LazyOpen(true));
@@ -680,22 +680,22 @@ TEST_F(AppCacheDatabaseTest, OnlineWhiteListRecords) {
   const GURL kFooNameSpace2("http://foo/namespace2");
   const GURL kBarNameSpace1("http://bar/namespace1");
 
-  const AppCacheDatabase::OnlineWhiteListRecord kZeroRecord;
-  AppCacheDatabase::OnlineWhiteListRecord record;
-  std::vector<AppCacheDatabase::OnlineWhiteListRecord> records;
+  const AppCacheDatabase::OnlineSafeListRecord kZeroRecord;
+  AppCacheDatabase::OnlineSafeListRecord record;
+  std::vector<AppCacheDatabase::OnlineSafeListRecord> records;
 
   // Behavior with an empty table
-  EXPECT_TRUE(db.FindOnlineWhiteListForCache(1, &records));
+  EXPECT_TRUE(db.FindOnlineSafeListForCache(1, &records));
   EXPECT_TRUE(records.empty());
-  EXPECT_TRUE(db.DeleteOnlineWhiteListForCache(1));
+  EXPECT_TRUE(db.DeleteOnlineSafeListForCache(1));
 
   record.cache_id = 1;
   record.namespace_url = kFooNameSpace1;
-  EXPECT_TRUE(db.InsertOnlineWhiteList(&record));
+  EXPECT_TRUE(db.InsertOnlineSafeList(&record));
   record.namespace_url = kFooNameSpace2;
-  EXPECT_TRUE(db.InsertOnlineWhiteList(&record));
+  EXPECT_TRUE(db.InsertOnlineSafeList(&record));
   records.clear();
-  EXPECT_TRUE(db.FindOnlineWhiteListForCache(1, &records));
+  EXPECT_TRUE(db.FindOnlineSafeListForCache(1, &records));
   EXPECT_EQ(2U, records.size());
   EXPECT_EQ(1, records[0].cache_id);
   EXPECT_EQ(kFooNameSpace1, records[0].namespace_url);
@@ -704,14 +704,14 @@ TEST_F(AppCacheDatabaseTest, OnlineWhiteListRecords) {
 
   record.cache_id = 2;
   record.namespace_url = kBarNameSpace1;
-  EXPECT_TRUE(db.InsertOnlineWhiteList(&record));
+  EXPECT_TRUE(db.InsertOnlineSafeList(&record));
   records.clear();
-  EXPECT_TRUE(db.FindOnlineWhiteListForCache(2, &records));
+  EXPECT_TRUE(db.FindOnlineSafeListForCache(2, &records));
   EXPECT_EQ(1U, records.size());
 
-  EXPECT_TRUE(db.DeleteOnlineWhiteListForCache(1));
+  EXPECT_TRUE(db.DeleteOnlineSafeListForCache(1));
   records.clear();
-  EXPECT_TRUE(db.FindOnlineWhiteListForCache(1, &records));
+  EXPECT_TRUE(db.FindOnlineSafeListForCache(1, &records));
   EXPECT_TRUE(records.empty());
 }
 
diff --git a/chromium/content/browser/appcache/appcache_disk_cache_unittest.cc b/chromium/content/browser/appcache/appcache_disk_cache_unittest.cc
index 9fab9f1bf29..e797fbb420f 100644
--- a/chromium/content/browser/appcache/appcache_disk_cache_unittest.cc
+++ b/chromium/content/browser/appcache/appcache_disk_cache_unittest.cc
@@ -78,7 +78,7 @@ TEST_F(AppCacheDiskCacheTest, DisablePriorToInitCompletion) {
   // Ensure the directory can be deleted at this point.
   EXPECT_TRUE(base::DirectoryExists(directory_.GetPath()));
   EXPECT_FALSE(base::IsDirectoryEmpty(directory_.GetPath()));
-  EXPECT_TRUE(base::DeleteFileRecursively(directory_.GetPath()));
+  EXPECT_TRUE(base::DeletePathRecursively(directory_.GetPath()));
   EXPECT_FALSE(base::DirectoryExists(directory_.GetPath()));
 }
 
@@ -99,7 +99,7 @@ TEST_F(AppCacheDiskCacheTest, DisableAfterInitted) {
   // Ensure the directory can be deleted at this point.
   EXPECT_TRUE(base::DirectoryExists(directory_.GetPath()));
   EXPECT_FALSE(base::IsDirectoryEmpty(directory_.GetPath()));
-  EXPECT_TRUE(base::DeleteFileRecursively(directory_.GetPath()));
+  EXPECT_TRUE(base::DeletePathRecursively(directory_.GetPath()));
   EXPECT_FALSE(base::DirectoryExists(directory_.GetPath()));
 
   // Methods should return immediately when disabled and not invoke
@@ -165,7 +165,7 @@ TEST_F(AppCacheDiskCacheTest, DISABLED_DisableWithEntriesOpen) {
   // Ensure the directory can be deleted at this point.
   EXPECT_TRUE(base::DirectoryExists(directory_.GetPath()));
   EXPECT_FALSE(base::IsDirectoryEmpty(directory_.GetPath()));
-  EXPECT_TRUE(base::DeleteFileRecursively(directory_.GetPath()));
+  EXPECT_TRUE(base::DeletePathRecursively(directory_.GetPath()));
   EXPECT_FALSE(base::DirectoryExists(directory_.GetPath()));
 
   disk_cache.reset(nullptr);
@@ -198,7 +198,7 @@ TEST_F(AppCacheDiskCacheTest, CleanupCallback) {
   // Ensure the directory can be deleted at this point.
   EXPECT_TRUE(base::DirectoryExists(directory_.GetPath()));
   EXPECT_FALSE(base::IsDirectoryEmpty(directory_.GetPath()));
-  EXPECT_TRUE(base::DeleteFileRecursively(directory_.GetPath()));
+  EXPECT_TRUE(base::DeletePathRecursively(directory_.GetPath()));
   EXPECT_FALSE(base::DirectoryExists(directory_.GetPath()));
 }
 
diff --git a/chromium/content/browser/appcache/appcache_fuzzer.cc b/chromium/content/browser/appcache/appcache_fuzzer.cc
index 41f600ff0d8..73ba9d1f436 100644
--- a/chromium/content/browser/appcache/appcache_fuzzer.cc
+++ b/chromium/content/browser/appcache/appcache_fuzzer.cc
@@ -5,6 +5,7 @@
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/command_line.h"
 #include "base/i18n/icu_util.h"
 #include "base/macros.h"
 #include "base/no_destructor.h"
diff --git a/chromium/content/browser/appcache/appcache_host.cc b/chromium/content/browser/appcache/appcache_host.cc
index 91d1cc04c0d..2c3ecbebf97 100644
--- a/chromium/content/browser/appcache/appcache_host.cc
+++ b/chromium/content/browser/appcache/appcache_host.cc
@@ -24,7 +24,6 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/url_constants.h"
-#include "net/url_request/url_request.h"
 #include "services/network/public/mojom/url_loader_factory.mojom.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "third_party/blink/public/mojom/appcache/appcache.mojom.h"
diff --git a/chromium/content/browser/appcache/appcache_host_unittest.cc b/chromium/content/browser/appcache/appcache_host_unittest.cc
index cb357740862..1710931698d 100644
--- a/chromium/content/browser/appcache/appcache_host_unittest.cc
+++ b/chromium/content/browser/appcache/appcache_host_unittest.cc
@@ -27,7 +27,6 @@
 #include "content/test/test_web_contents.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/test_support/test_utils.h"
-#include "net/url_request/url_request.h"
 #include "storage/browser/quota/quota_client_type.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
diff --git a/chromium/content/browser/appcache/appcache_internals_ui.cc b/chromium/content/browser/appcache/appcache_internals_ui.cc
index ab51766fd69..49d40dc0113 100644
--- a/chromium/content/browser/appcache/appcache_internals_ui.cc
+++ b/chromium/content/browser/appcache/appcache_internals_ui.cc
@@ -34,6 +34,7 @@
 #include "services/network/public/mojom/content_security_policy.mojom.h"
 #include "third_party/blink/public/mojom/appcache/appcache.mojom.h"
 #include "third_party/blink/public/mojom/appcache/appcache_info.mojom.h"
+#include "ui/base/text/bytes_formatting.h"
 
 namespace content {
 
@@ -62,101 +63,93 @@ bool SortByResourceUrl(const blink::mojom::AppCacheResourceInfo& lhs,
   return lhs.url.spec() < rhs.url.spec();
 }
 
-std::unique_ptr<base::DictionaryValue> GetDictionaryValueForResponseEnquiry(
+base::Value GetDictionaryValueForResponseEnquiry(
     const content::AppCacheInternalsUI::ProxyResponseEnquiry&
         response_enquiry) {
-  auto dict_value = std::make_unique<base::DictionaryValue>();
-  dict_value->SetString("manifestURL", response_enquiry.manifest_url);
-  dict_value->SetString("groupId",
-                        base::NumberToString(response_enquiry.group_id));
-  dict_value->SetString("responseId",
-                        base::NumberToString(response_enquiry.response_id));
-  return dict_value;
+  base::Value dict(base::Value::Type::DICTIONARY);
+  dict.SetStringKey("manifestURL", response_enquiry.manifest_url);
+  dict.SetStringKey("groupId", base::NumberToString(response_enquiry.group_id));
+  dict.SetStringKey("responseId",
+                    base::NumberToString(response_enquiry.response_id));
+  return dict;
 }
 
-std::unique_ptr<base::DictionaryValue> GetDictionaryValueForAppCacheInfo(
+base::Value GetDictionaryValueForAppCacheInfo(
     const blink::mojom::AppCacheInfo& appcache_info) {
-  auto dict_value = std::make_unique<base::DictionaryValue>();
-  dict_value->SetString("manifestURL", appcache_info.manifest_url.spec());
-  dict_value->SetDouble("creationTime", appcache_info.creation_time.ToJsTime());
-  dict_value->SetDouble("lastUpdateTime",
-                        appcache_info.last_update_time.ToJsTime());
-  dict_value->SetDouble("lastAccessTime",
-                        appcache_info.last_access_time.ToJsTime());
-  dict_value->SetDouble("tokenExpires", appcache_info.token_expires.ToJsTime());
-  dict_value->SetString("responseSizes",
-                        base::UTF16ToUTF8(base::FormatBytesUnlocalized(
-                            appcache_info.response_sizes)));
-  dict_value->SetString("paddingSizes",
-                        base::UTF16ToUTF8(base::FormatBytesUnlocalized(
-                            appcache_info.padding_sizes)));
-  dict_value->SetString(
-      "totalSize",
-      base::UTF16ToUTF8(base::FormatBytesUnlocalized(
-          appcache_info.response_sizes + appcache_info.padding_sizes)));
-  dict_value->SetString("groupId",
-                        base::NumberToString(appcache_info.group_id));
-
-  dict_value->SetString(
+  base::Value dict(base::Value::Type::DICTIONARY);
+  dict.SetStringKey("manifestURL", appcache_info.manifest_url.spec());
+  dict.SetDoubleKey("creationTime", appcache_info.creation_time.ToJsTime());
+  dict.SetDoubleKey("lastUpdateTime",
+                    appcache_info.last_update_time.ToJsTime());
+  dict.SetDoubleKey("lastAccessTime",
+                    appcache_info.last_access_time.ToJsTime());
+  dict.SetDoubleKey("tokenExpires", appcache_info.token_expires.ToJsTime());
+  dict.SetStringKey("responseSizes",
+                    ui::FormatBytes(appcache_info.response_sizes));
+  dict.SetStringKey("paddingSizes",
+                    ui::FormatBytes(appcache_info.padding_sizes));
+  dict.SetStringKey("totalSize", ui::FormatBytes(appcache_info.response_sizes +
+                                                 appcache_info.padding_sizes));
+  dict.SetStringKey("groupId", base::NumberToString(appcache_info.group_id));
+
+  dict.SetStringKey(
       "manifestParserVersion",
       base::NumberToString(appcache_info.manifest_parser_version));
-  dict_value->SetString("manifestScope", appcache_info.manifest_scope);
+  dict.SetStringKey("manifestScope", appcache_info.manifest_scope);
 
-  return dict_value;
+  return dict;
 }
 
-std::unique_ptr<base::ListValue> GetListValueForAppCacheInfoVector(
+base::Value GetListValueForAppCacheInfoVector(
     const std::vector<blink::mojom::AppCacheInfo> appcache_info_vector) {
-  auto list = std::make_unique<base::ListValue>();
+  base::Value list(base::Value::Type::LIST);
   for (const blink::mojom::AppCacheInfo& info : appcache_info_vector)
-    list->Append(GetDictionaryValueForAppCacheInfo(info));
+    list.Append(GetDictionaryValueForAppCacheInfo(info));
   return list;
 }
 
-std::unique_ptr<base::ListValue> GetListValueFromAppCacheInfoCollection(
+base::Value GetListValueFromAppCacheInfoCollection(
     AppCacheInfoCollection* appcache_collection) {
-  auto list = std::make_unique<base::ListValue>();
+  base::Value list(base::Value::Type::LIST);
   for (const auto& key_value : appcache_collection->infos_by_origin) {
-    auto dict = std::make_unique<base::DictionaryValue>();
+    base::Value dict(base::Value::Type::DICTIONARY);
     // Use GURL::spec() to keep consistency with previous version
-    dict->SetString("originURL", key_value.first.GetURL().spec());
-    dict->Set("manifests", GetListValueForAppCacheInfoVector(key_value.second));
-    list->Append(std::move(dict));
+    dict.SetStringKey("originURL", key_value.first.GetURL().spec());
+    dict.SetKey("manifests",
+                GetListValueForAppCacheInfoVector(key_value.second));
+    list.Append(std::move(dict));
   }
   return list;
 }
 
-std::unique_ptr<base::DictionaryValue>
-GetDictionaryValueForAppCacheResourceInfo(
+base::Value GetDictionaryValueForAppCacheResourceInfo(
     const blink::mojom::AppCacheResourceInfo& resource_info) {
-  auto dict = std::make_unique<base::DictionaryValue>();
-  dict->SetString("url", resource_info.url.spec());
-  dict->SetString("responseSize",
-                  base::UTF16ToUTF8(base::FormatBytesUnlocalized(
-                      resource_info.response_size)));
-  dict->SetString("paddingSize", base::UTF16ToUTF8(base::FormatBytesUnlocalized(
-                                     resource_info.padding_size)));
-  dict->SetString("totalSize", base::UTF16ToUTF8(base::FormatBytesUnlocalized(
-                                   resource_info.response_size +
-                                   resource_info.padding_size)));
-  dict->SetString("responseId",
-                  base::NumberToString(resource_info.response_id));
-  dict->SetBoolean("isExplicit", resource_info.is_explicit);
-  dict->SetBoolean("isManifest", resource_info.is_manifest);
-  dict->SetBoolean("isMaster", resource_info.is_master);
-  dict->SetBoolean("isFallback", resource_info.is_fallback);
-  dict->SetBoolean("isIntercept", resource_info.is_intercept);
-  dict->SetBoolean("isForeign", resource_info.is_foreign);
+  base::Value dict(base::Value::Type::DICTIONARY);
+  dict.SetStringKey("url", resource_info.url.spec());
+  dict.SetStringKey("responseSize",
+                    ui::FormatBytes(resource_info.response_size));
+  dict.SetStringKey("paddingSize", ui::FormatBytes(resource_info.padding_size));
+  dict.SetStringKey("totalSize", ui::FormatBytes(resource_info.response_size +
+                                                 resource_info.padding_size));
+  dict.SetStringKey("responseId",
+                    base::NumberToString(resource_info.response_id));
+  dict.SetBoolKey("isExplicit", resource_info.is_explicit);
+  dict.SetBoolKey("isManifest", resource_info.is_manifest);
+  dict.SetBoolKey("isMaster", resource_info.is_master);
+  dict.SetBoolKey("isFallback", resource_info.is_fallback);
+  dict.SetBoolKey("isIntercept", resource_info.is_intercept);
+  dict.SetBoolKey("isForeign", resource_info.is_foreign);
 
   return dict;
 }
 
-std::unique_ptr<base::ListValue> GetListValueForAppCacheResourceInfoVector(
+base::Value GetListValueForAppCacheResourceInfoVector(
     std::vector<blink::mojom::AppCacheResourceInfo>* resource_info_vector) {
-  auto list = std::make_unique<base::ListValue>();
+  base::Value list(base::Value::Type::LIST);
   for (const blink::mojom::AppCacheResourceInfo& res_info :
-       *resource_info_vector)
-    list->Append(GetDictionaryValueForAppCacheResourceInfo(res_info));
+       *resource_info_vector) {
+    list.Append(GetDictionaryValueForAppCacheResourceInfo(res_info));
+  }
   return list;
 }
 
@@ -365,6 +358,7 @@ AppCacheInternalsUI::AppCacheInternalsUI(WebUI* web_ui)
   source->OverrideContentSecurityPolicy(
       network::mojom::CSPDirectiveName::ScriptSrc,
       "script-src chrome://resources 'self' 'unsafe-eval';");
+  source->DisableTrustedTypesCSP();
 
   source->UseStringsJs();
   source->AddResourcePath("appcache_internals.js", IDR_APPCACHE_INTERNALS_JS);
@@ -388,8 +382,10 @@ void AppCacheInternalsUI::CreateProxyForPartition(
     StoragePartition* storage_partition) {
   auto proxy = base::MakeRefCounted<Proxy>(weak_ptr_factory_.GetWeakPtr(),
                                            storage_partition->GetPath());
-  proxy->Initialize(static_cast<StoragePartitionImpl*>(storage_partition)
-                        ->GetAppCacheService());
+  auto* appcache_service = static_cast<StoragePartitionImpl*>(storage_partition)
+                               ->GetAppCacheService();
+  if (appcache_service)
+    proxy->Initialize(appcache_service);
   appcache_proxies_.emplace_back(std::move(proxy));
 }
 
@@ -443,7 +439,7 @@ void AppCacheInternalsUI::OnAllAppCacheInfoReady(
       kFunctionOnAllAppCacheInfoReady,
       base::Value(partition_path.AsUTF8Unsafe()),
       base::Value(incognito_path_prefix + partition_path.AsUTF8Unsafe()),
-      *GetListValueFromAppCacheInfoCollection(collection.get()));
+      GetListValueFromAppCacheInfoCollection(collection.get()));
 }
 
 void AppCacheInternalsUI::OnAppCacheInfoDeleted(
@@ -465,7 +461,7 @@ void AppCacheInternalsUI::OnAppCacheDetailsReady(
     web_ui()->CallJavascriptFunctionUnsafe(
         kFunctionOnAppCacheDetailsReady, base::Value(manifest_url),
         base::Value(partition_path.AsUTF8Unsafe()),
-        *GetListValueForAppCacheResourceInfoVector(resource_info_vector.get()));
+        GetListValueForAppCacheResourceInfoVector(resource_info_vector.get()));
   } else {
     web_ui()->CallJavascriptFunctionUnsafe(
         kFunctionOnAppCacheDetailsReady, base::Value(manifest_url),
@@ -504,7 +500,7 @@ void AppCacheInternalsUI::OnFileDetailsReady(
   hex_dump.append("</pre>");
   web_ui()->CallJavascriptFunctionUnsafe(
       kFunctionOnFileDetailsReady,
-      *GetDictionaryValueForResponseEnquiry(response_enquiry),
+      GetDictionaryValueForResponseEnquiry(response_enquiry),
       base::Value(headers), base::Value(hex_dump));
 }
 
@@ -513,7 +509,7 @@ void AppCacheInternalsUI::OnFileDetailsFailed(
     int net_result_code) {
   web_ui()->CallJavascriptFunctionUnsafe(
       kFunctionOnFileDetailsFailed,
-      *GetDictionaryValueForResponseEnquiry(response_enquiry),
+      GetDictionaryValueForResponseEnquiry(response_enquiry),
       base::Value(net_result_code));
 }
 
diff --git a/chromium/content/browser/appcache/appcache_manifest_parser.cc b/chromium/content/browser/appcache/appcache_manifest_parser.cc
index 34496153913..eddc081832f 100644
--- a/chromium/content/browser/appcache/appcache_manifest_parser.cc
+++ b/chromium/content/browser/appcache/appcache_manifest_parser.cc
@@ -40,6 +40,7 @@
 #include "base/metrics/histogram_functions.h"
 #include "base/notreached.h"
 #include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/appcache/appcache.h"
 #include "third_party/blink/public/common/origin_trials/trial_token.h"
@@ -217,8 +218,7 @@ GURL ParseUrlToken(base::StringPiece url_token, const GURL& manifest_url) {
 }
 
 bool IsUrlWithinScope(const GURL& url, const GURL& scope) {
-  return base::StartsWith(url.spec(), scope.spec(),
-                          base::CompareCase::SENSITIVE);
+  return base::StartsWith(url.spec(), scope.spec());
 }
 
 // Records UMA metrics for parsing one AppCache manifest.
@@ -316,10 +316,10 @@ bool ParseManifest(const GURL& manifest_url,
 
   DCHECK(manifest.explicit_urls.empty());
   DCHECK(manifest.fallback_namespaces.empty());
-  DCHECK(manifest.online_whitelist_namespaces.empty());
+  DCHECK(manifest.online_safelist_namespaces.empty());
   DCHECK_EQ(manifest.parser_version, -1);
   DCHECK_EQ(manifest.scope, "");
-  DCHECK(!manifest.online_whitelist_all);
+  DCHECK(!manifest.online_safelist_all);
   DCHECK(!manifest.did_ignore_intercept_namespaces);
   DCHECK(!manifest.did_ignore_fallback_namespaces);
 
@@ -344,16 +344,16 @@ bool ParseManifest(const GURL& manifest_url,
 
   // Discard a leading UTF-8 Byte-Order-Mark (BOM) (0xEF, 0xBB, 0xBF);
   static constexpr base::StringPiece kUtf8Bom("\xEF\xBB\xBF");
-  if (data.starts_with(kUtf8Bom))
+  if (base::StartsWith(data, kUtf8Bom))
     data = data.substr(kUtf8Bom.length());
 
   // The manifest has to start with a well-defined signature.
   static constexpr base::StringPiece kSignature("CACHE MANIFEST");
   static constexpr base::StringPiece kChromiumSignature(
       "CHROMIUM CACHE MANIFEST");
-  if (data.starts_with(kSignature)) {
+  if (base::StartsWith(data, kSignature)) {
     data = data.substr(kSignature.length());
-  } else if (data.starts_with(kChromiumSignature)) {
+  } else if (base::StartsWith(data, kChromiumSignature)) {
     // Chrome recognizes a separate signature, CHROMIUM CACHE MANIFEST. This was
     // built so that manifests that use the Chrome-only feature
     // CHROMIUM-INTERCEPT will be ignored by other browsers.
@@ -427,7 +427,7 @@ bool ParseManifest(const GURL& manifest_url,
 
     static constexpr base::StringPiece kOnlineSafelistWildcard("*");
     if (mode == Mode::kOnlineSafelist && line == kOnlineSafelistWildcard) {
-      manifest.online_whitelist_all = true;
+      manifest.online_safelist_all = true;
       continue;
     }
 
@@ -484,7 +484,7 @@ bool ParseManifest(const GURL& manifest_url,
         continue;
       }
 
-      manifest.online_whitelist_namespaces.emplace_back(
+      manifest.online_safelist_namespaces.emplace_back(
           AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, namespace_url, GURL()));
       continue;
     }
diff --git a/chromium/content/browser/appcache/appcache_manifest_parser.h b/chromium/content/browser/appcache/appcache_manifest_parser.h
index 5efca31b74f..6a2837626aa 100644
--- a/chromium/content/browser/appcache/appcache_manifest_parser.h
+++ b/chromium/content/browser/appcache/appcache_manifest_parser.h
@@ -51,14 +51,14 @@ struct CONTENT_EXPORT AppCacheManifest {
   std::unordered_set<std::string> explicit_urls;
   std::vector<AppCacheNamespace> intercept_namespaces;
   std::vector<AppCacheNamespace> fallback_namespaces;
-  std::vector<AppCacheNamespace> online_whitelist_namespaces;
+  std::vector<AppCacheNamespace> online_safelist_namespaces;
   // Stores the version of the manifest parser used to interpret a given
   // AppCache manifest.
   int parser_version = -1;
   // Stores the scope used to validate resource overrides specified in a given
   // manifest, if |scope_checks_enabled| is true.
   std::string scope;
-  bool online_whitelist_all = false;
+  bool online_safelist_all = false;
   bool did_ignore_intercept_namespaces = false;
   bool did_ignore_fallback_namespaces = false;
   base::Time token_expires;
diff --git a/chromium/content/browser/appcache/appcache_manifest_parser_unittest.cc b/chromium/content/browser/appcache/appcache_manifest_parser_unittest.cc
index cf9f81d69ea..a66003ef4d4 100644
--- a/chromium/content/browser/appcache/appcache_manifest_parser_unittest.cc
+++ b/chromium/content/browser/appcache/appcache_manifest_parser_unittest.cc
@@ -157,8 +157,8 @@ TEST_F(AppCacheManifestParserTest, NoManifestUrl) {
                              manifest));
   EXPECT_TRUE(manifest.explicit_urls.empty());
   EXPECT_TRUE(manifest.fallback_namespaces.empty());
-  EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
-  EXPECT_FALSE(manifest.online_whitelist_all);
+  EXPECT_TRUE(manifest.online_safelist_namespaces.empty());
+  EXPECT_FALSE(manifest.online_safelist_all);
   EXPECT_EQ(manifest.parser_version, -1);
 }
 
@@ -176,8 +176,8 @@ TEST_F(AppCacheManifestParserTest, NoManifestScope) {
                              manifest));
   EXPECT_TRUE(manifest.explicit_urls.empty());
   EXPECT_TRUE(manifest.fallback_namespaces.empty());
-  EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
-  EXPECT_FALSE(manifest.online_whitelist_all);
+  EXPECT_TRUE(manifest.online_safelist_namespaces.empty());
+  EXPECT_FALSE(manifest.online_safelist_all);
   EXPECT_EQ(manifest.parser_version, -1);
 }
 
@@ -195,8 +195,8 @@ TEST_F(AppCacheManifestParserTest, NoManifestUrlAndScope) {
                              manifest));
   EXPECT_TRUE(manifest.explicit_urls.empty());
   EXPECT_TRUE(manifest.fallback_namespaces.empty());
-  EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
-  EXPECT_FALSE(manifest.online_whitelist_all);
+  EXPECT_TRUE(manifest.online_safelist_namespaces.empty());
+  EXPECT_FALSE(manifest.online_safelist_all);
   EXPECT_EQ(manifest.parser_version, -1);
 }
 
@@ -215,8 +215,8 @@ TEST_F(AppCacheManifestParserTest, SimpleManifest) {
   const size_t kExpected = 2;
   EXPECT_EQ(manifest.explicit_urls.size(), kExpected);
   EXPECT_TRUE(manifest.fallback_namespaces.empty());
-  EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
-  EXPECT_FALSE(manifest.online_whitelist_all);
+  EXPECT_TRUE(manifest.online_safelist_namespaces.empty());
+  EXPECT_FALSE(manifest.online_safelist_all);
   EXPECT_EQ(manifest.parser_version, 2);
 }
 
@@ -245,8 +245,8 @@ TEST_F(AppCacheManifestParserTest, ExplicitUrls) {
                             PARSE_MANIFEST_ALLOWING_DANGEROUS_FEATURES,
                             manifest));
   EXPECT_TRUE(manifest.fallback_namespaces.empty());
-  EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
-  EXPECT_FALSE(manifest.online_whitelist_all);
+  EXPECT_TRUE(manifest.online_safelist_namespaces.empty());
+  EXPECT_FALSE(manifest.online_safelist_all);
   EXPECT_FALSE(manifest.did_ignore_intercept_namespaces);
   EXPECT_FALSE(manifest.did_ignore_fallback_namespaces);
   EXPECT_EQ(manifest.parser_version, 2);
@@ -267,8 +267,8 @@ TEST_F(AppCacheManifestParserTest, ExplicitUrls) {
   EXPECT_TRUE(ParseManifest(kUrl, kScope, kData.c_str(), kData.length(),
                             PARSE_MANIFEST_PER_STANDARD, manifest));
   EXPECT_TRUE(manifest.fallback_namespaces.empty());
-  EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
-  EXPECT_FALSE(manifest.online_whitelist_all);
+  EXPECT_TRUE(manifest.online_safelist_namespaces.empty());
+  EXPECT_FALSE(manifest.online_safelist_all);
   EXPECT_FALSE(manifest.did_ignore_intercept_namespaces);
   EXPECT_FALSE(manifest.did_ignore_fallback_namespaces);
 
@@ -283,7 +283,7 @@ TEST_F(AppCacheManifestParserTest, ExplicitUrls) {
   EXPECT_TRUE(urls.find("http://www.foo.com/*") != urls.end());
 }
 
-TEST_F(AppCacheManifestParserTest, WhitelistUrls) {
+TEST_F(AppCacheManifestParserTest, SafelistUrls) {
   AppCacheManifest manifest;
   const GURL kUrl("http://www.bar.com");
   const std::string kScope = kUrl.GetWithoutFilename().path();
@@ -310,12 +310,12 @@ TEST_F(AppCacheManifestParserTest, WhitelistUrls) {
   EXPECT_TRUE(manifest.explicit_urls.empty());
   EXPECT_TRUE(manifest.fallback_namespaces.empty());
   EXPECT_TRUE(manifest.intercept_namespaces.empty());
-  EXPECT_FALSE(manifest.online_whitelist_all);
+  EXPECT_FALSE(manifest.online_safelist_all);
   EXPECT_FALSE(manifest.did_ignore_intercept_namespaces);
   EXPECT_FALSE(manifest.did_ignore_fallback_namespaces);
 
   const std::vector<AppCacheNamespace>& online =
-      manifest.online_whitelist_namespaces;
+      manifest.online_safelist_namespaces;
   const size_t kExpected = 6;
   ASSERT_EQ(kExpected, online.size());
   EXPECT_EQ(APPCACHE_NETWORK_NAMESPACE, online[0].type);
@@ -359,8 +359,8 @@ TEST_F(AppCacheManifestParserTest, FallbackUrls) {
                             PARSE_MANIFEST_ALLOWING_DANGEROUS_FEATURES,
                             manifest));
   EXPECT_TRUE(manifest.explicit_urls.empty());
-  EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
-  EXPECT_FALSE(manifest.online_whitelist_all);
+  EXPECT_TRUE(manifest.online_safelist_namespaces.empty());
+  EXPECT_FALSE(manifest.online_safelist_all);
   EXPECT_FALSE(manifest.did_ignore_intercept_namespaces);
   EXPECT_FALSE(manifest.did_ignore_fallback_namespaces);
 
@@ -421,8 +421,8 @@ TEST_F(AppCacheManifestParserTest, FallbackUrlsWithPort) {
                             PARSE_MANIFEST_ALLOWING_DANGEROUS_FEATURES,
                             manifest));
   EXPECT_TRUE(manifest.explicit_urls.empty());
-  EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
-  EXPECT_FALSE(manifest.online_whitelist_all);
+  EXPECT_TRUE(manifest.online_safelist_namespaces.empty());
+  EXPECT_FALSE(manifest.online_safelist_all);
 
   const std::vector<AppCacheNamespace>& fallbacks =
       manifest.fallback_namespaces;
@@ -474,8 +474,8 @@ TEST_F(AppCacheManifestParserTest, InterceptUrls) {
                             manifest));
   EXPECT_TRUE(manifest.fallback_namespaces.empty());
   EXPECT_TRUE(manifest.explicit_urls.empty());
-  EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
-  EXPECT_FALSE(manifest.online_whitelist_all);
+  EXPECT_TRUE(manifest.online_safelist_namespaces.empty());
+  EXPECT_FALSE(manifest.online_safelist_all);
   EXPECT_FALSE(manifest.did_ignore_intercept_namespaces);
   EXPECT_FALSE(manifest.did_ignore_fallback_namespaces);
 
@@ -505,9 +505,9 @@ TEST_F(AppCacheManifestParserTest, InterceptUrls) {
                             PARSE_MANIFEST_PER_STANDARD, manifest));
   EXPECT_TRUE(manifest.fallback_namespaces.empty());
   EXPECT_TRUE(manifest.explicit_urls.empty());
-  EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
+  EXPECT_TRUE(manifest.online_safelist_namespaces.empty());
   EXPECT_TRUE(manifest.intercept_namespaces.empty());
-  EXPECT_FALSE(manifest.online_whitelist_all);
+  EXPECT_FALSE(manifest.online_safelist_all);
   EXPECT_TRUE(manifest.did_ignore_intercept_namespaces);
   EXPECT_FALSE(manifest.did_ignore_fallback_namespaces);
 }
@@ -516,29 +516,30 @@ TEST_F(AppCacheManifestParserTest, ComboUrls) {
   AppCacheManifest manifest;
   const GURL kUrl("http://combo.com:42");
   const std::string kScope = kUrl.GetWithoutFilename().path();
-  const std::string kData("CACHE MANIFEST\r"
-    "relative/explicit-1\r"
-    "# some comment\r"
-    "http://combo.com:99/explicit-2#strip\r"
-    "NETWORK:\r"
-    "http://combo.com/whitelist-1\r"
-    "HTTP://www.diff.com/whitelist-2#strip\r"
-    "*\r"
-    "CACHE:\n\r"
-    "http://www.diff.com/explicit-3\r"
-    "FALLBACK:\r"
-    "http://combo.com:42/fallback-1 http://combo.com:42/fallback-1b\r"
-    "relative/fallback-2 relative/fallback-2b\r"
-    "UNKNOWN:\r\n"
-    "http://combo.com/ignoreme\r"
-    "relative/still-ignored\r"
-    "NETWORK:\r\n"
-    "relative/whitelist-3#strip\r"
-    "http://combo.com:99/whitelist-4\r");
+  const std::string kData(
+      "CACHE MANIFEST\r"
+      "relative/explicit-1\r"
+      "# some comment\r"
+      "http://combo.com:99/explicit-2#strip\r"
+      "NETWORK:\r"
+      "http://combo.com/safelist-1\r"
+      "HTTP://www.diff.com/safelist-2#strip\r"
+      "*\r"
+      "CACHE:\n\r"
+      "http://www.diff.com/explicit-3\r"
+      "FALLBACK:\r"
+      "http://combo.com:42/fallback-1 http://combo.com:42/fallback-1b\r"
+      "relative/fallback-2 relative/fallback-2b\r"
+      "UNKNOWN:\r\n"
+      "http://combo.com/ignoreme\r"
+      "relative/still-ignored\r"
+      "NETWORK:\r\n"
+      "relative/safelist-3#strip\r"
+      "http://combo.com:99/safelist-4\r");
   EXPECT_TRUE(ParseManifest(kUrl, kScope, kData.c_str(), kData.length(),
                             PARSE_MANIFEST_ALLOWING_DANGEROUS_FEATURES,
                             manifest));
-  EXPECT_TRUE(manifest.online_whitelist_all);
+  EXPECT_TRUE(manifest.online_safelist_all);
 
   std::unordered_set<std::string> urls = manifest.explicit_urls;
   size_t expected = 3;
@@ -549,17 +550,14 @@ TEST_F(AppCacheManifestParserTest, ComboUrls) {
   EXPECT_TRUE(urls.find("http://www.diff.com/explicit-3") != urls.end());
 
   const std::vector<AppCacheNamespace>& online =
-      manifest.online_whitelist_namespaces;
+      manifest.online_safelist_namespaces;
   expected = 4;
   ASSERT_EQ(expected, online.size());
-  EXPECT_EQ(GURL("http://combo.com/whitelist-1"),
-                 online[0].namespace_url);
-  EXPECT_EQ(GURL("http://www.diff.com/whitelist-2"),
-                 online[1].namespace_url);
-  EXPECT_EQ(GURL("http://combo.com:42/relative/whitelist-3"),
-                 online[2].namespace_url);
-  EXPECT_EQ(GURL("http://combo.com:99/whitelist-4"),
-                 online[3].namespace_url);
+  EXPECT_EQ(GURL("http://combo.com/safelist-1"), online[0].namespace_url);
+  EXPECT_EQ(GURL("http://www.diff.com/safelist-2"), online[1].namespace_url);
+  EXPECT_EQ(GURL("http://combo.com:42/relative/safelist-3"),
+            online[2].namespace_url);
+  EXPECT_EQ(GURL("http://combo.com:99/safelist-4"), online[3].namespace_url);
 
   const std::vector<AppCacheNamespace>& fallbacks =
       manifest.fallback_namespaces;
@@ -625,7 +623,7 @@ TEST_F(AppCacheManifestParserTest, DifferentOriginUrlWithSecureScheme) {
                             PARSE_MANIFEST_ALLOWING_DANGEROUS_FEATURES,
                             manifest));
   EXPECT_TRUE(manifest.fallback_namespaces.empty());
-  EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
+  EXPECT_TRUE(manifest.online_safelist_namespaces.empty());
 
   std::unordered_set<std::string> urls = manifest.explicit_urls;
   const size_t kExpected = 3;
diff --git a/chromium/content/browser/appcache/appcache_quota_client.cc b/chromium/content/browser/appcache/appcache_quota_client.cc
index e428255be48..c299e8fdc08 100644
--- a/chromium/content/browser/appcache/appcache_quota_client.cc
+++ b/chromium/content/browser/appcache/appcache_quota_client.cc
@@ -69,7 +69,7 @@ void AppCacheQuotaClient::OnQuotaManagerDestroyed() {
 
 void AppCacheQuotaClient::GetOriginUsage(const url::Origin& origin,
                                          StorageType type,
-                                         GetUsageCallback callback) {
+                                         GetOriginUsageCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
   DCHECK(!callback.is_null());
@@ -106,8 +106,9 @@ void AppCacheQuotaClient::GetOriginUsage(const url::Origin& origin,
       std::move(callback));
 }
 
-void AppCacheQuotaClient::GetOriginsForType(StorageType type,
-                                            GetOriginsCallback callback) {
+void AppCacheQuotaClient::GetOriginsForType(
+    StorageType type,
+    GetOriginsForTypeCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
   DCHECK(!callback.is_null());
@@ -115,15 +116,16 @@ void AppCacheQuotaClient::GetOriginsForType(StorageType type,
   GetOriginsHelper(std::string(), std::move(callback));
 }
 
-void AppCacheQuotaClient::GetOriginsForHost(StorageType type,
-                                            const std::string& host,
-                                            GetOriginsCallback callback) {
+void AppCacheQuotaClient::GetOriginsForHost(
+    StorageType type,
+    const std::string& host,
+    GetOriginsForHostCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
   DCHECK(!callback.is_null());
 
   if (host.empty()) {
-    std::move(callback).Run(std::set<url::Origin>());
+    std::move(callback).Run(std::vector<url::Origin>());
     return;
   }
   GetOriginsHelper(host, std::move(callback));
@@ -131,7 +133,7 @@ void AppCacheQuotaClient::GetOriginsForHost(StorageType type,
 
 void AppCacheQuotaClient::DeleteOriginData(const url::Origin& origin,
                                            StorageType type,
-                                           DeletionCallback callback) {
+                                           DeleteOriginDataCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
   DCHECK(!callback.is_null());
@@ -183,11 +185,11 @@ void AppCacheQuotaClient::DidDeleteAppCachesForOrigin(int rv) {
 }
 
 void AppCacheQuotaClient::GetOriginsHelper(const std::string& opt_host,
-                                           GetOriginsCallback callback) {
+                                           GetOriginsForTypeCallback callback) {
   DCHECK(!callback.is_null());
 
   if (service_is_destroyed_) {
-    std::move(callback).Run(std::set<url::Origin>());
+    std::move(callback).Run(std::vector<url::Origin>());
     return;
   }
 
@@ -203,13 +205,13 @@ void AppCacheQuotaClient::GetOriginsHelper(const std::string& opt_host,
       base::BindOnce(
           [](base::WeakPtr<AppCacheServiceImpl> service,
              const std::string& opt_host) {
-            std::set<url::Origin> origins;
+            std::vector<url::Origin> origins;
             if (!service)
               return origins;
 
             for (const auto& pair : service->storage()->usage_map()) {
               if (opt_host.empty() || pair.first.host() == opt_host)
-                origins.insert(pair.first);
+                origins.push_back(pair.first);
             }
             return origins;
           },
diff --git a/chromium/content/browser/appcache/appcache_quota_client.h b/chromium/content/browser/appcache/appcache_quota_client.h
index 9a1206391e1..1f1a4c91cb6 100644
--- a/chromium/content/browser/appcache/appcache_quota_client.h
+++ b/chromium/content/browser/appcache/appcache_quota_client.h
@@ -43,17 +43,17 @@ class AppCacheQuotaClient : public storage::QuotaClient {
   void OnQuotaManagerDestroyed() override;
   void GetOriginUsage(const url::Origin& origin,
                       blink::mojom::StorageType type,
-                      GetUsageCallback callback) override;
+                      GetOriginUsageCallback callback) override;
   void GetOriginsForType(blink::mojom::StorageType type,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForTypeCallback callback) override;
   void GetOriginsForHost(blink::mojom::StorageType type,
                          const std::string& host,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForHostCallback callback) override;
   void DeleteOriginData(const url::Origin& origin,
                         blink::mojom::StorageType type,
-                        DeletionCallback callback) override;
+                        DeleteOriginDataCallback callback) override;
   void PerformStorageCleanup(blink::mojom::StorageType type,
-                             base::OnceClosure callback) override;
+                             PerformStorageCleanupCallback callback) override;
 
  private:
   friend class content::AppCacheQuotaClientTest;
@@ -64,7 +64,7 @@ class AppCacheQuotaClient : public storage::QuotaClient {
 
   void DidDeleteAppCachesForOrigin(int rv);
   void GetOriginsHelper(const std::string& opt_host,
-                        GetOriginsCallback callback);
+                        GetOriginsForTypeCallback callback);
   void ProcessPendingRequests();
   void DeletePendingRequests();
   net::CancelableCompletionRepeatingCallback* GetServiceDeleteCallback();
@@ -80,7 +80,7 @@ class AppCacheQuotaClient : public storage::QuotaClient {
 
   // And once it's ready, we can only handle one delete request at a time,
   // so we queue up additional requests while one is in already in progress.
-  DeletionCallback current_delete_request_callback_;
+  DeleteOriginDataCallback current_delete_request_callback_;
   std::unique_ptr<net::CancelableCompletionRepeatingCallback>
       service_delete_callback_;
 
diff --git a/chromium/content/browser/appcache/appcache_quota_client_unittest.cc b/chromium/content/browser/appcache/appcache_quota_client_unittest.cc
index e639074d050..8fb9746f6bc 100644
--- a/chromium/content/browser/appcache/appcache_quota_client_unittest.cc
+++ b/chromium/content/browser/appcache/appcache_quota_client_unittest.cc
@@ -4,16 +4,23 @@
 
 #include <stdint.h>
 
-#include <map>
-#include <set>
+#include <utility>
+#include <vector>
 
 #include "base/bind.h"
+#include "base/memory/scoped_refptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "content/browser/appcache/appcache_quota_client.h"
 #include "content/browser/appcache/mock_appcache_service.h"
 #include "content/public/test/browser_task_environment.h"
 #include "net/base/net_errors.h"
+#include "storage/browser/quota/quota_client.h"
+#include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
+#include "url/gurl.h"
+#include "url/origin.h"
 
 namespace content {
 
@@ -32,12 +39,7 @@ class AppCacheQuotaClientTest : public testing::Test {
   AppCacheQuotaClientTest()
       : kOriginA(url::Origin::Create(GURL("http://host"))),
         kOriginB(url::Origin::Create(GURL("http://host:8000"))),
-        kOriginOther(url::Origin::Create(GURL("http://other"))),
-        usage_(0),
-        delete_status_(blink::mojom::QuotaStatusCode::kUnknown),
-        num_get_origin_usage_completions_(0),
-        num_get_origins_completions_(0),
-        num_delete_origins_completions_(0) {}
+        kOriginOther(url::Origin::Create(GURL("http://other"))) {}
 
   int64_t GetOriginUsage(scoped_refptr<storage::QuotaClient> client,
                          const url::Origin& origin,
@@ -48,7 +50,7 @@ class AppCacheQuotaClientTest : public testing::Test {
     return usage_;
   }
 
-  const std::set<url::Origin>& GetOriginsForType(
+  const std::vector<url::Origin>& GetOriginsForType(
       scoped_refptr<storage::QuotaClient> client,
       StorageType type) {
     origins_.clear();
@@ -57,7 +59,7 @@ class AppCacheQuotaClientTest : public testing::Test {
     return origins_;
   }
 
-  const std::set<url::Origin>& GetOriginsForHost(
+  const std::vector<url::Origin>& GetOriginsForHost(
       scoped_refptr<storage::QuotaClient> client,
       StorageType type,
       const std::string& host) {
@@ -144,7 +146,7 @@ class AppCacheQuotaClientTest : public testing::Test {
     usage_ = usage;
   }
 
-  void OnGetOriginsComplete(const std::set<url::Origin>& origins) {
+  void OnGetOriginsComplete(const std::vector<url::Origin>& origins) {
     ++num_get_origins_completions_;
     origins_ = origins;
   }
@@ -155,12 +157,13 @@ class AppCacheQuotaClientTest : public testing::Test {
   }
 
   BrowserTaskEnvironment task_environment_;
-  int64_t usage_;
-  std::set<url::Origin> origins_;
-  blink::mojom::QuotaStatusCode delete_status_;
-  int num_get_origin_usage_completions_;
-  int num_get_origins_completions_;
-  int num_delete_origins_completions_;
+  int64_t usage_ = 0;
+  std::vector<url::Origin> origins_;
+  blink::mojom::QuotaStatusCode delete_status_ =
+      blink::mojom::QuotaStatusCode::kUnknown;
+  int num_get_origin_usage_completions_ = 0;
+  int num_get_origins_completions_ = 0;
+  int num_delete_origins_completions_ = 0;
   MockAppCacheService mock_service_;
   base::WeakPtrFactory<AppCacheQuotaClientTest> weak_factory_{this};
 };
@@ -233,7 +236,7 @@ TEST_F(AppCacheQuotaClientTest, GetOriginsForHost) {
   EXPECT_EQ(kOriginA.host(), kOriginB.host());
   EXPECT_NE(kOriginA.host(), kOriginOther.host());
 
-  std::set<url::Origin> origins =
+  std::vector<url::Origin> origins =
       GetOriginsForHost(client, kTemp, kOriginA.host());
   EXPECT_TRUE(origins.empty());
 
@@ -243,12 +246,12 @@ TEST_F(AppCacheQuotaClientTest, GetOriginsForHost) {
 
   origins = GetOriginsForHost(client, kTemp, kOriginA.host());
   EXPECT_EQ(2ul, origins.size());
-  EXPECT_TRUE(origins.find(kOriginA) != origins.end());
-  EXPECT_TRUE(origins.find(kOriginB) != origins.end());
+  EXPECT_THAT(origins, testing::Contains(kOriginA));
+  EXPECT_THAT(origins, testing::Contains(kOriginB));
 
   origins = GetOriginsForHost(client, kTemp, kOriginOther.host());
   EXPECT_EQ(1ul, origins.size());
-  EXPECT_TRUE(origins.find(kOriginOther) != origins.end());
+  EXPECT_THAT(origins, testing::Contains(kOriginOther));
 
   Call_NotifyAppCacheDestroyed(client);
   Call_OnQuotaManagerDestroyed(client);
@@ -263,10 +266,10 @@ TEST_F(AppCacheQuotaClientTest, GetOriginsForType) {
   SetUsageMapEntry(kOriginA, 1000);
   SetUsageMapEntry(kOriginB, 10);
 
-  std::set<url::Origin> origins = GetOriginsForType(client, kTemp);
+  std::vector<url::Origin> origins = GetOriginsForType(client, kTemp);
   EXPECT_EQ(2ul, origins.size());
-  EXPECT_TRUE(origins.find(kOriginA) != origins.end());
-  EXPECT_TRUE(origins.find(kOriginB) != origins.end());
+  EXPECT_THAT(origins, testing::Contains(kOriginA));
+  EXPECT_THAT(origins, testing::Contains(kOriginB));
 
   Call_NotifyAppCacheDestroyed(client);
   Call_OnQuotaManagerDestroyed(client);
@@ -325,7 +328,7 @@ TEST_F(AppCacheQuotaClientTest, PendingRequests) {
   // They should be serviced in order requested.
   EXPECT_EQ(10, usage_);
   EXPECT_EQ(1ul, origins_.size());
-  EXPECT_TRUE(origins_.find(kOriginOther) != origins_.end());
+  EXPECT_THAT(origins_, testing::Contains(kOriginOther));
 
   Call_NotifyAppCacheDestroyed(client);
   Call_OnQuotaManagerDestroyed(client);
diff --git a/chromium/content/browser/appcache/appcache_request.cc b/chromium/content/browser/appcache/appcache_request.cc
index a19a46c184f..25a6739136d 100644
--- a/chromium/content/browser/appcache/appcache_request.cc
+++ b/chromium/content/browser/appcache/appcache_request.cc
@@ -8,7 +8,6 @@
 #include "net/base/isolation_info.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/redirect_util.h"
-#include "net/url_request/url_request.h"
 #include "url/origin.h"
 
 namespace content {
diff --git a/chromium/content/browser/appcache/appcache_storage_impl.cc b/chromium/content/browser/appcache/appcache_storage_impl.cc
index 9cd7edd52c2..ab93994d13d 100644
--- a/chromium/content/browser/appcache/appcache_storage_impl.cc
+++ b/chromium/content/browser/appcache/appcache_storage_impl.cc
@@ -68,13 +68,12 @@ bool DeleteGroupAndRelatedRecords(
   if (database->FindCacheForGroup(group_id, &cache_record)) {
     database->FindResponseIdsForCacheAsVector(cache_record.cache_id,
                                               deletable_response_ids);
-    success =
-        database->DeleteGroup(group_id) &&
-        database->DeleteCache(cache_record.cache_id) &&
-        database->DeleteEntriesForCache(cache_record.cache_id) &&
-        database->DeleteNamespacesForCache(cache_record.cache_id) &&
-        database->DeleteOnlineWhiteListForCache(cache_record.cache_id) &&
-        database->InsertDeletableResponseIds(*deletable_response_ids);
+    success = database->DeleteGroup(group_id) &&
+              database->DeleteCache(cache_record.cache_id) &&
+              database->DeleteEntriesForCache(cache_record.cache_id) &&
+              database->DeleteNamespacesForCache(cache_record.cache_id) &&
+              database->DeleteOnlineSafeListForCache(cache_record.cache_id) &&
+              database->InsertDeletableResponseIds(*deletable_response_ids);
   } else {
     NOTREACHED() << "A existing group without a cache is unexpected";
     success = database->DeleteGroup(group_id);
@@ -278,7 +277,7 @@ void AppCacheStorageImpl::InitTask::Run() {
   if (!db_file_path_.empty() &&
       !base::PathExists(db_file_path_) &&
       base::DirectoryExists(disk_cache_directory_)) {
-    base::DeleteFileRecursively(disk_cache_directory_);
+    base::DeletePathRecursively(disk_cache_directory_);
     if (base::DirectoryExists(disk_cache_directory_)) {
       database_->Disable();  // This triggers OnFatalError handling.
       return;
@@ -415,18 +414,17 @@ class AppCacheStorageImpl::StoreOrLoadTask : public DatabaseTask {
       intercept_namespace_records_;
   std::vector<AppCacheDatabase::NamespaceRecord>
       fallback_namespace_records_;
-  std::vector<AppCacheDatabase::OnlineWhiteListRecord>
-      online_whitelist_records_;
+  std::vector<AppCacheDatabase::OnlineSafeListRecord> online_safelist_records_;
 };
 
 bool AppCacheStorageImpl::StoreOrLoadTask::FindRelatedCacheRecords(
     int64_t cache_id) {
   return database_->FindEntriesForCache(cache_id, &entry_records_) &&
-         database_->FindNamespacesForCache(
-             cache_id, &intercept_namespace_records_,
-             &fallback_namespace_records_) &&
-         database_->FindOnlineWhiteListForCache(
-             cache_id, &online_whitelist_records_);
+         database_->FindNamespacesForCache(cache_id,
+                                           &intercept_namespace_records_,
+                                           &fallback_namespace_records_) &&
+         database_->FindOnlineSafeListForCache(cache_id,
+                                               &online_safelist_records_);
 }
 
 void AppCacheStorageImpl::StoreOrLoadTask::CreateCacheAndGroupFromRecords(
@@ -449,10 +447,8 @@ void AppCacheStorageImpl::StoreOrLoadTask::CreateCacheAndGroupFromRecords(
 
   *cache = base::MakeRefCounted<AppCache>(storage_, cache_record_.cache_id);
   cache->get()->InitializeWithDatabaseRecords(
-      cache_record_, entry_records_,
-      intercept_namespace_records_,
-      fallback_namespace_records_,
-      online_whitelist_records_);
+      cache_record_, entry_records_, intercept_namespace_records_,
+      fallback_namespace_records_, online_safelist_records_);
   cache->get()->set_complete(true);
 
   *group = storage_->working_set_.GetGroup(group_record_.manifest_url);
@@ -663,11 +659,8 @@ AppCacheStorageImpl::StoreGroupAndCacheTask::StoreGroupAndCacheTask(
   group_record_.first_evictable_error_time =
       group->first_evictable_error_time();
   newest_cache->ToDatabaseRecords(
-      group,
-      &cache_record_, &entry_records_,
-      &intercept_namespace_records_,
-      &fallback_namespace_records_,
-      &online_whitelist_records_);
+      group, &cache_record_, &entry_records_, &intercept_namespace_records_,
+      &fallback_namespace_records_, &online_safelist_records_);
 }
 
 void AppCacheStorageImpl::StoreGroupAndCacheTask::GetQuotaThenSchedule() {
@@ -751,21 +744,19 @@ void AppCacheStorageImpl::StoreGroupAndCacheTask::Run() {
           database_->DeleteCache(cache.cache_id) &&
           database_->DeleteEntriesForCache(cache.cache_id) &&
           database_->DeleteNamespacesForCache(cache.cache_id) &&
-          database_->DeleteOnlineWhiteListForCache(cache.cache_id) &&
+          database_->DeleteOnlineSafeListForCache(cache.cache_id) &&
           database_->InsertDeletableResponseIds(newly_deletable_response_ids_);
-          // TODO(michaeln): store group_id too with deletable ids
+      // TODO(michaeln): store group_id too with deletable ids
     } else {
       NOTREACHED() << "A existing group without a cache is unexpected";
     }
   }
 
-  success_ =
-      success_ &&
-      database_->InsertCache(&cache_record_) &&
-      database_->InsertEntryRecords(entry_records_) &&
-      database_->InsertNamespaceRecords(intercept_namespace_records_) &&
-      database_->InsertNamespaceRecords(fallback_namespace_records_) &&
-      database_->InsertOnlineWhiteListRecords(online_whitelist_records_);
+  success_ = success_ && database_->InsertCache(&cache_record_) &&
+             database_->InsertEntryRecords(entry_records_) &&
+             database_->InsertNamespaceRecords(intercept_namespace_records_) &&
+             database_->InsertNamespaceRecords(fallback_namespace_records_) &&
+             database_->InsertOnlineSafeListRecords(online_safelist_records_);
 
   if (!success_)
     return;
@@ -873,21 +864,20 @@ class NetworkNamespaceHelper {
   }
 
   bool IsInNetworkNamespace(const GURL& url, int64_t cache_id) {
-    std::pair<WhiteListMap::iterator, bool> result = namespaces_map_.insert(
-        WhiteListMap::value_type(cache_id, std::vector<AppCacheNamespace>()));
+    std::pair<SafeListMap::iterator, bool> result = namespaces_map_.insert(
+        SafeListMap::value_type(cache_id, std::vector<AppCacheNamespace>()));
     if (result.second)
-      GetOnlineWhiteListForCache(cache_id, &result.first->second);
+      GetOnlineSafeListForCache(cache_id, &result.first->second);
     return AppCache::FindNamespace(result.first->second, url) != nullptr;
   }
 
  private:
-  void GetOnlineWhiteListForCache(int64_t cache_id,
-                                  std::vector<AppCacheNamespace>* namespaces) {
+  void GetOnlineSafeListForCache(int64_t cache_id,
+                                 std::vector<AppCacheNamespace>* namespaces) {
     DCHECK(namespaces && namespaces->empty());
-    using WhiteListVector =
-        std::vector<AppCacheDatabase::OnlineWhiteListRecord>;
-    WhiteListVector records;
-    if (!database_->FindOnlineWhiteListForCache(cache_id, &records))
+    using SafeListVector = std::vector<AppCacheDatabase::OnlineSafeListRecord>;
+    SafeListVector records;
+    if (!database_->FindOnlineSafeListForCache(cache_id, &records))
       return;
 
     for (const auto& record : records) {
@@ -897,8 +887,8 @@ class NetworkNamespaceHelper {
   }
 
   // Key is cache id
-  using WhiteListMap = std::map<int64_t, std::vector<AppCacheNamespace>>;
-  WhiteListMap namespaces_map_;
+  using SafeListMap = std::map<int64_t, std::vector<AppCacheNamespace>>;
+  SafeListMap namespaces_map_;
   AppCacheDatabase* const database_;
 };
 
diff --git a/chromium/content/browser/appcache/appcache_storage_impl_unittest.cc b/chromium/content/browser/appcache/appcache_storage_impl_unittest.cc
index 455c1422d58..1d5e3d9d64a 100644
--- a/chromium/content/browser/appcache/appcache_storage_impl_unittest.cc
+++ b/chromium/content/browser/appcache/appcache_storage_impl_unittest.cc
@@ -812,10 +812,10 @@ class AppCacheStorageImplTest : public testing::Test {
     fallback_namespace_record.origin = url::Origin::Create(kManifestUrl);
     EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
 
-    AppCacheDatabase::OnlineWhiteListRecord online_whitelist_record;
-    online_whitelist_record.cache_id = 1;
-    online_whitelist_record.namespace_url = kOnlineNamespace;
-    EXPECT_TRUE(database()->InsertOnlineWhiteList(&online_whitelist_record));
+    AppCacheDatabase::OnlineSafeListRecord online_safelist_record;
+    online_safelist_record.cache_id = 1;
+    online_safelist_record.namespace_url = kOnlineNamespace;
+    EXPECT_TRUE(database()->InsertOnlineSafeList(&online_safelist_record));
 
     // Conduct the test.
     storage()->MakeGroupObsolete(group_.get(), delegate(), 0);
@@ -843,9 +843,9 @@ class AppCacheStorageImplTest : public testing::Test {
     database()->FindNamespacesForCache(1, &intercept_records,
                                        &fallback_records);
     EXPECT_TRUE(fallback_records.empty());
-    std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelist_records;
-    database()->FindOnlineWhiteListForCache(1, &whitelist_records);
-    EXPECT_TRUE(whitelist_records.empty());
+    std::vector<AppCacheDatabase::OnlineSafeListRecord> safelist_records;
+    database()->FindOnlineSafeListForCache(1, &safelist_records);
+    EXPECT_TRUE(safelist_records.empty());
 
     // Verify quota bookkeeping
     EXPECT_TRUE(storage()->usage_map_.empty());
@@ -1045,17 +1045,17 @@ class AppCacheStorageImplTest : public testing::Test {
     MakeCacheAndGroup(kManifestUrl, 2, 1, valid_token_expires(), true);
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::FALLBACK, 1));
     cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, 2));
-    cache_->fallback_namespaces_.push_back(AppCacheNamespace(
-        APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespace2, kEntryUrl2));
-    cache_->fallback_namespaces_.push_back(AppCacheNamespace(
-        APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl));
+    cache_->fallback_namespaces_.emplace_back(APPCACHE_FALLBACK_NAMESPACE,
+                                              kFallbackNamespace2, kEntryUrl2);
+    cache_->fallback_namespaces_.emplace_back(APPCACHE_FALLBACK_NAMESPACE,
+                                              kFallbackNamespace, kEntryUrl);
     AppCacheDatabase::CacheRecord cache_record;
     std::vector<AppCacheDatabase::EntryRecord> entries;
     std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
     std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
-    std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
+    std::vector<AppCacheDatabase::OnlineSafeListRecord> safelists;
     cache_->ToDatabaseRecords(group_.get(), &cache_record, &entries,
-                              &intercepts, &fallbacks, &whitelists);
+                              &intercepts, &fallbacks, &safelists);
 
     for (const auto& entry : entries) {
       // MakeCacheAndGroup has inserted the default entry record already.
@@ -1064,7 +1064,7 @@ class AppCacheStorageImplTest : public testing::Test {
     }
 
     EXPECT_TRUE(database()->InsertNamespaceRecords(fallbacks));
-    EXPECT_TRUE(database()->InsertOnlineWhiteListRecords(whitelists));
+    EXPECT_TRUE(database()->InsertOnlineSafeListRecords(safelists));
     if (drop_from_working_set) {
       EXPECT_TRUE(cache_->HasOneRef());
       cache_ = nullptr;
@@ -1107,17 +1107,17 @@ class AppCacheStorageImplTest : public testing::Test {
     MakeCacheAndGroup(kManifestUrl, 2, 1, invalid_token_expires(), true);
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::FALLBACK, 1));
     cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, 2));
-    cache_->fallback_namespaces_.push_back(AppCacheNamespace(
-        APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespace2, kEntryUrl2));
-    cache_->fallback_namespaces_.push_back(AppCacheNamespace(
-        APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl));
+    cache_->fallback_namespaces_.emplace_back(APPCACHE_FALLBACK_NAMESPACE,
+                                              kFallbackNamespace2, kEntryUrl2);
+    cache_->fallback_namespaces_.emplace_back(APPCACHE_FALLBACK_NAMESPACE,
+                                              kFallbackNamespace, kEntryUrl);
     AppCacheDatabase::CacheRecord cache_record;
     std::vector<AppCacheDatabase::EntryRecord> entries;
     std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
     std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
-    std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
+    std::vector<AppCacheDatabase::OnlineSafeListRecord> safelists;
     cache_->ToDatabaseRecords(group_.get(), &cache_record, &entries,
-                              &intercepts, &fallbacks, &whitelists);
+                              &intercepts, &fallbacks, &safelists);
 
     for (const auto& entry : entries) {
       // MakeCacheAndGroup has inserted the default entry record already.
@@ -1129,7 +1129,7 @@ class AppCacheStorageImplTest : public testing::Test {
     group_ = nullptr;
 
     EXPECT_TRUE(database()->InsertNamespaceRecords(fallbacks));
-    EXPECT_TRUE(database()->InsertOnlineWhiteListRecords(whitelists));
+    EXPECT_TRUE(database()->InsertOnlineSafeListRecords(safelists));
 
     // Conduct the test. Although the test url is in both fallback namespace
     // urls, it will match neither of them because its group does not have a
@@ -1175,17 +1175,17 @@ class AppCacheStorageImplTest : public testing::Test {
     MakeCacheAndGroup(kManifestUrl, 2, 1, token_expires, true);
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::INTERCEPT, 1));
     cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::INTERCEPT, 2));
-    cache_->intercept_namespaces_.push_back(AppCacheNamespace(
-        APPCACHE_INTERCEPT_NAMESPACE, kInterceptNamespace2, kEntryUrl2));
-    cache_->intercept_namespaces_.push_back(AppCacheNamespace(
-        APPCACHE_INTERCEPT_NAMESPACE, kInterceptNamespace, kEntryUrl));
+    cache_->intercept_namespaces_.emplace_back(
+        APPCACHE_INTERCEPT_NAMESPACE, kInterceptNamespace2, kEntryUrl2);
+    cache_->intercept_namespaces_.emplace_back(APPCACHE_INTERCEPT_NAMESPACE,
+                                               kInterceptNamespace, kEntryUrl);
     AppCacheDatabase::CacheRecord cache_record;
     std::vector<AppCacheDatabase::EntryRecord> entries;
     std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
     std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
-    std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
+    std::vector<AppCacheDatabase::OnlineSafeListRecord> safelists;
     cache_->ToDatabaseRecords(group_.get(), &cache_record, &entries,
-                              &intercepts, &fallbacks, &whitelists);
+                              &intercepts, &fallbacks, &safelists);
 
     for (const auto& entry : entries) {
       // MakeCacheAndGroup has inserted  the default entry record already
@@ -1194,7 +1194,7 @@ class AppCacheStorageImplTest : public testing::Test {
     }
 
     EXPECT_TRUE(database()->InsertNamespaceRecords(intercepts));
-    EXPECT_TRUE(database()->InsertOnlineWhiteListRecords(whitelists));
+    EXPECT_TRUE(database()->InsertOnlineSafeListRecords(safelists));
     if (drop_from_working_set) {
       EXPECT_TRUE(cache_->HasOneRef());
       cache_ = nullptr;
@@ -1277,8 +1277,8 @@ class AppCacheStorageImplTest : public testing::Test {
     fallback_namespace_record.namespace_.namespace_url = kFallbackNamespace;
     fallback_namespace_record.origin = url::Origin::Create(manifest_url);
     EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
-    cache_->fallback_namespaces_.push_back(AppCacheNamespace(
-        APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl2));
+    cache_->fallback_namespaces_.emplace_back(APPCACHE_FALLBACK_NAMESPACE,
+                                              kFallbackNamespace, kEntryUrl2);
   }
 
   void Verify_FindMainResponseWithMultipleHits() {
@@ -1389,12 +1389,12 @@ class AppCacheStorageImplTest : public testing::Test {
         kEntryUrl,
         AppCacheEntry(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN, 1));
     cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, 2));
-    cache_->fallback_namespaces_.push_back(AppCacheNamespace(
-        APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl2));
-    cache_->online_whitelist_namespaces_.push_back(AppCacheNamespace(
-        APPCACHE_NETWORK_NAMESPACE, kOnlineNamespace, GURL()));
-    cache_->online_whitelist_namespaces_.push_back(AppCacheNamespace(
-        APPCACHE_NETWORK_NAMESPACE, kOnlineNamespaceWithinFallback, GURL()));
+    cache_->fallback_namespaces_.emplace_back(APPCACHE_FALLBACK_NAMESPACE,
+                                              kFallbackNamespace, kEntryUrl2);
+    cache_->online_safelist_namespaces_.emplace_back(APPCACHE_NETWORK_NAMESPACE,
+                                                     kOnlineNamespace, GURL());
+    cache_->online_safelist_namespaces_.emplace_back(
+        APPCACHE_NETWORK_NAMESPACE, kOnlineNamespaceWithinFallback, GURL());
 
     AppCacheDatabase::EntryRecord entry_record;
     entry_record.cache_id = 1;
@@ -1402,19 +1402,19 @@ class AppCacheStorageImplTest : public testing::Test {
     entry_record.flags = AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN;
     entry_record.response_id = 1;
     EXPECT_TRUE(database()->InsertEntry(&entry_record));
-    AppCacheDatabase::OnlineWhiteListRecord whitelist_record;
-    whitelist_record.cache_id = 1;
-    whitelist_record.namespace_url = kOnlineNamespace;
-    EXPECT_TRUE(database()->InsertOnlineWhiteList(&whitelist_record));
+    AppCacheDatabase::OnlineSafeListRecord safelist_record;
+    safelist_record.cache_id = 1;
+    safelist_record.namespace_url = kOnlineNamespace;
+    EXPECT_TRUE(database()->InsertOnlineSafeList(&safelist_record));
     AppCacheDatabase::NamespaceRecord fallback_namespace_record;
     fallback_namespace_record.cache_id = 1;
     fallback_namespace_record.namespace_.target_url = kEntryUrl2;
     fallback_namespace_record.namespace_.namespace_url = kFallbackNamespace;
     fallback_namespace_record.origin = url::Origin::Create(kManifestUrl);
     EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
-    whitelist_record.cache_id = 1;
-    whitelist_record.namespace_url = kOnlineNamespaceWithinFallback;
-    EXPECT_TRUE(database()->InsertOnlineWhiteList(&whitelist_record));
+    safelist_record.cache_id = 1;
+    safelist_record.namespace_url = kOnlineNamespaceWithinFallback;
+    EXPECT_TRUE(database()->InsertOnlineSafeList(&safelist_record));
     if (drop_from_working_set) {
       cache_ = nullptr;
       group_ = nullptr;
@@ -1485,7 +1485,7 @@ class AppCacheStorageImplTest : public testing::Test {
 
   class MockAppCacheFrontend : public blink::mojom::AppCacheFrontend {
    public:
-    MockAppCacheFrontend() : error_event_was_raised_(false) {}
+    MockAppCacheFrontend() = default;
 
     void CacheSelected(blink::mojom::AppCacheInfoPtr info) override {}
     void EventRaised(blink::mojom::AppCacheEventID event_id) override {}
@@ -1502,7 +1502,7 @@ class AppCacheStorageImplTest : public testing::Test {
         mojo::PendingRemote<network::mojom::URLLoaderFactory>
             url_loader_factory) override {}
 
-    bool error_event_was_raised_;
+    bool error_event_was_raised_ = false;
   };
 
   enum ReinitTestCase {
diff --git a/chromium/content/browser/appcache/appcache_subresource_url_factory.cc b/chromium/content/browser/appcache/appcache_subresource_url_factory.cc
index 29e1451a99f..b6213030fbc 100644
--- a/chromium/content/browser/appcache/appcache_subresource_url_factory.cc
+++ b/chromium/content/browser/appcache/appcache_subresource_url_factory.cc
@@ -22,7 +22,6 @@
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
-#include "net/url_request/url_request.h"
 #include "services/network/public/cpp/request_mode.h"
 #include "services/network/public/cpp/resource_request.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
diff --git a/chromium/content/browser/appcache/appcache_unittest.cc b/chromium/content/browser/appcache/appcache_unittest.cc
index 19753c49ffd..be3c40c8fe7 100644
--- a/chromium/content/browser/appcache/appcache_unittest.cc
+++ b/chromium/content/browser/appcache/appcache_unittest.cc
@@ -118,8 +118,8 @@ TEST_F(AppCacheTest, InitializeWithManifest) {
 
   auto cache = base::MakeRefCounted<AppCache>(service.storage(), 1234);
   EXPECT_TRUE(cache->fallback_namespaces_.empty());
-  EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
-  EXPECT_FALSE(cache->online_whitelist_all_);
+  EXPECT_TRUE(cache->online_safelist_namespaces_.empty());
+  EXPECT_FALSE(cache->online_safelist_all_);
 
   AppCacheManifest manifest;
   manifest.explicit_urls.insert("http://one.com");
@@ -127,11 +127,11 @@ TEST_F(AppCacheTest, InitializeWithManifest) {
   manifest.fallback_namespaces.push_back(
       AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, GURL("http://fb1.com"),
                         GURL("http://fbone.com")));
-  manifest.online_whitelist_namespaces.push_back(AppCacheNamespace(
+  manifest.online_safelist_namespaces.push_back(AppCacheNamespace(
       APPCACHE_NETWORK_NAMESPACE, GURL("http://w1.com"), GURL()));
-  manifest.online_whitelist_namespaces.push_back(AppCacheNamespace(
+  manifest.online_safelist_namespaces.push_back(AppCacheNamespace(
       APPCACHE_NETWORK_NAMESPACE, GURL("http://w2.com"), GURL()));
-  manifest.online_whitelist_all = true;
+  manifest.online_safelist_all = true;
 
   cache->InitializeWithManifest(&manifest);
   const std::vector<AppCacheNamespace>& fallbacks =
@@ -140,18 +140,18 @@ TEST_F(AppCacheTest, InitializeWithManifest) {
   EXPECT_EQ(expected, fallbacks.size());
   EXPECT_EQ(GURL("http://fb1.com"), fallbacks[0].namespace_url);
   EXPECT_EQ(GURL("http://fbone.com"), fallbacks[0].target_url);
-  const std::vector<AppCacheNamespace>& whitelist =
-      cache->online_whitelist_namespaces_;
+  const std::vector<AppCacheNamespace>& safelist =
+      cache->online_safelist_namespaces_;
   expected = 2;
-  EXPECT_EQ(expected, whitelist.size());
-  EXPECT_EQ(GURL("http://w1.com"), whitelist[0].namespace_url);
-  EXPECT_EQ(GURL("http://w2.com"), whitelist[1].namespace_url);
-  EXPECT_TRUE(cache->online_whitelist_all_);
+  EXPECT_EQ(expected, safelist.size());
+  EXPECT_EQ(GURL("http://w1.com"), safelist[0].namespace_url);
+  EXPECT_EQ(GURL("http://w2.com"), safelist[1].namespace_url);
+  EXPECT_TRUE(cache->online_safelist_all_);
 
   // Ensure collections in manifest were taken over by the cache rather than
   // copied.
   EXPECT_TRUE(manifest.fallback_namespaces.empty());
-  EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
+  EXPECT_TRUE(manifest.online_safelist_namespaces.empty());
 }
 
 TEST_F(AppCacheTest, FindResponseForRequest) {
@@ -185,9 +185,9 @@ TEST_F(AppCacheTest, FindResponseForRequest) {
   const int64_t kInterceptResponseId = 6;
 
   AppCacheManifest manifest;
-  manifest.online_whitelist_namespaces.push_back(AppCacheNamespace(
+  manifest.online_safelist_namespaces.push_back(AppCacheNamespace(
       APPCACHE_NETWORK_NAMESPACE, kOnlineNamespaceUrl, GURL()));
-  manifest.online_whitelist_namespaces.push_back(
+  manifest.online_safelist_namespaces.push_back(
       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE,
                         kOnlineNamespaceWithinOtherNamespaces, GURL()));
   manifest.fallback_namespaces.push_back(AppCacheNamespace(
@@ -371,8 +371,8 @@ TEST_F(AppCacheTest, ToFromDatabaseRecords) {
   const std::string kManifestScope = kManifestUrl.GetWithoutFilename().path();
   const GURL kInterceptUrl("http://foo.com/intercept.html");
   const GURL kFallbackUrl("http://foo.com/fallback.html");
-  const GURL kPatternWhitelistUrl("http://foo.com/patternwhitelist*");
-  const GURL kWhitelistUrl("http://foo.com/whitelist");
+  const GURL kPatternSafelistUrl("http://foo.com/patternsafelist*");
+  const GURL kSafelistUrl("http://foo.com/safelist");
   const std::string kData(
       "CACHE MANIFEST\r"
       "CHROMIUM-INTERCEPT:\r"
@@ -380,8 +380,8 @@ TEST_F(AppCacheTest, ToFromDatabaseRecords) {
       "FALLBACK:\r"
       "/ /fallback.html\r"
       "NETWORK:\r"
-      "/patternwhitelist* isPattern\r"
-      "/whitelist\r"
+      "/patternsafelist* isPattern\r"
+      "/safelist\r"
       "*\r");
 
   MockAppCacheService service;
@@ -394,13 +394,12 @@ TEST_F(AppCacheTest, ToFromDatabaseRecords) {
                     PARSE_MANIFEST_ALLOWING_DANGEROUS_FEATURES, manifest));
   cache->InitializeWithManifest(&manifest);
   EXPECT_EQ(APPCACHE_NETWORK_NAMESPACE,
-            cache->online_whitelist_namespaces_[0].type);
-  EXPECT_EQ(kPatternWhitelistUrl,
-            cache->online_whitelist_namespaces_[0].namespace_url);
+            cache->online_safelist_namespaces_[0].type);
+  EXPECT_EQ(kPatternSafelistUrl,
+            cache->online_safelist_namespaces_[0].namespace_url);
   EXPECT_EQ(APPCACHE_NETWORK_NAMESPACE,
-            cache->online_whitelist_namespaces_[1].type);
-  EXPECT_EQ(kWhitelistUrl,
-            cache->online_whitelist_namespaces_[1].namespace_url);
+            cache->online_safelist_namespaces_[1].type);
+  EXPECT_EQ(kSafelistUrl, cache->online_safelist_namespaces_[1].namespace_url);
   cache->AddEntry(kManifestUrl, AppCacheEntry(AppCacheEntry::MANIFEST,
                                               /*response_id=*/1,
                                               /*response_size=*/1000,
@@ -419,13 +418,9 @@ TEST_F(AppCacheTest, ToFromDatabaseRecords) {
   std::vector<AppCacheDatabase::EntryRecord> entries;
   std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
   std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
-  std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
-  cache->ToDatabaseRecords(group.get(),
-                           &cache_record,
-                           &entries,
-                           &intercepts,
-                           &fallbacks,
-                           &whitelists);
+  std::vector<AppCacheDatabase::OnlineSafeListRecord> safelists;
+  cache->ToDatabaseRecords(group.get(), &cache_record, &entries, &intercepts,
+                           &fallbacks, &safelists);
   EXPECT_EQ(kCacheId, cache_record.cache_id);
   EXPECT_EQ(kGroupId, cache_record.group_id);
   EXPECT_TRUE(cache_record.online_wildcard);
@@ -434,15 +429,14 @@ TEST_F(AppCacheTest, ToFromDatabaseRecords) {
   EXPECT_EQ(3u, entries.size());
   EXPECT_EQ(1u, intercepts.size());
   EXPECT_EQ(1u, fallbacks.size());
-  EXPECT_EQ(2u, whitelists.size());
+  EXPECT_EQ(2u, safelists.size());
   cache = nullptr;
 
   // Create a new AppCache and populate it with those records and verify.
   cache = base::MakeRefCounted<AppCache>(service.storage(), kCacheId);
-  cache->InitializeWithDatabaseRecords(
-      cache_record, entries, intercepts,
-      fallbacks, whitelists);
-  EXPECT_TRUE(cache->online_whitelist_all_);
+  cache->InitializeWithDatabaseRecords(cache_record, entries, intercepts,
+                                       fallbacks, safelists);
+  EXPECT_TRUE(cache->online_safelist_all_);
   EXPECT_EQ(3u, cache->entries().size());
   EXPECT_TRUE(cache->GetEntry(kManifestUrl));
   EXPECT_TRUE(cache->GetEntry(kInterceptUrl));
@@ -454,13 +448,12 @@ TEST_F(AppCacheTest, ToFromDatabaseRecords) {
   EXPECT_EQ(1000 + 10000 + 100000, cache->cache_size());
   EXPECT_EQ(0 + 10 + 100, cache->padding_size());
   EXPECT_EQ(APPCACHE_NETWORK_NAMESPACE,
-            cache->online_whitelist_namespaces_[0].type);
-  EXPECT_EQ(kPatternWhitelistUrl,
-            cache->online_whitelist_namespaces_[0].namespace_url);
+            cache->online_safelist_namespaces_[0].type);
+  EXPECT_EQ(kPatternSafelistUrl,
+            cache->online_safelist_namespaces_[0].namespace_url);
   EXPECT_EQ(APPCACHE_NETWORK_NAMESPACE,
-            cache->online_whitelist_namespaces_[1].type);
-  EXPECT_EQ(kWhitelistUrl,
-            cache->online_whitelist_namespaces_[1].namespace_url);
+            cache->online_safelist_namespaces_[1].type);
+  EXPECT_EQ(kSafelistUrl, cache->online_safelist_namespaces_[1].namespace_url);
 }
 
 TEST_F(AppCacheTest, IsNamespaceMatch) {
diff --git a/chromium/content/browser/appcache/appcache_update_job.cc b/chromium/content/browser/appcache/appcache_update_job.cc
index ed937c17e3e..54b3a0a67b3 100644
--- a/chromium/content/browser/appcache/appcache_update_job.cc
+++ b/chromium/content/browser/appcache/appcache_update_job.cc
@@ -26,6 +26,7 @@
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
+#include "net/http/http_request_headers.h"
 #include "storage/browser/quota/padding_key.h"
 #include "third_party/blink/public/common/features.h"
 #include "third_party/blink/public/mojom/appcache/appcache.mojom.h"
@@ -42,6 +43,7 @@ const size_t kMaxConcurrentUrlFetches = 2;
 enum class ResourceCheck {
   kValid,
   kInvalid,
+  kCorrupt,
 };
 
 std::string FormatUrlErrorMessage(
@@ -153,6 +155,10 @@ ResourceCheck CanUseExistingResource(
 
   if (found_corruption) {
     update_metrics.IncrementExistingResourceCorrupt();
+    if (base::FeatureList::IsEnabled(kAppCacheCorruptionRecoveryFeature)) {
+      update_metrics.IncrementExistingResourceCorruptionRecovery();
+      return ResourceCheck::kCorrupt;
+    }
   } else {
     update_metrics.IncrementExistingResourceNotCorrupt();
   }
@@ -196,14 +202,17 @@ int64_t ComputeAppCacheResponsePadding(const GURL& response_url,
   if (response_url.GetOrigin() == manifest_url.GetOrigin())
     return 0;
 
-  return storage::ComputeResponsePadding(response_url.spec(),
-                                         storage::GetDefaultPaddingKey(),
-                                         /*has_metadata=*/false,
-                                         /*loaded_with_credentials=*/false);
+  return storage::ComputeResponsePadding(
+      response_url.spec(), storage::GetDefaultPaddingKey(),
+      /*has_metadata=*/false, /*loaded_with_credentials=*/false,
+      net::HttpRequestHeaders::kGetMethod);
 }
 
 }  // namespace
 
+const base::Feature kAppCacheCorruptionRecoveryFeature{
+    "AppCacheCorruptionRecovery", base::FEATURE_DISABLED_BY_DEFAULT};
+
 const base::Feature kAppCacheUpdateResourceOn304Feature{
     "AppCacheUpdateResourceOn304", base::FEATURE_DISABLED_BY_DEFAULT};
 
@@ -1621,7 +1630,14 @@ void AppCacheUpdateJob::OnResponseInfoLoaded(
     LoadFromNewestCacheFailed(url, nullptr);  // no response found
   } else {
     ResourceCheck result = CanUseExistingResource(http_info, update_metrics_);
-    if (result == ResourceCheck::kInvalid) {
+    if (result == ResourceCheck::kCorrupt) {
+      // A corrupt resource was found.  In this case, we want to cause the next
+      // fetch attempt for this resource to be issued without conditional
+      // headers so a 200 OK response is the only result.  We do that by not
+      // passing along |response_info| here.  This case can only occur when the
+      // AppCacheCorruptionRecovery feature is enabled.
+      LoadFromNewestCacheFailed(url, nullptr);
+    } else if (result == ResourceCheck::kInvalid) {
       // An invalid resource was found, but we may want to add conditional
       // headers that could result in a 304 NOT MODIFIED response.
       LoadFromNewestCacheFailed(url, response_info);
diff --git a/chromium/content/browser/appcache/appcache_update_job.h b/chromium/content/browser/appcache/appcache_update_job.h
index 9909165d0f9..b673e2557b9 100644
--- a/chromium/content/browser/appcache/appcache_update_job.h
+++ b/chromium/content/browser/appcache/appcache_update_job.h
@@ -30,10 +30,13 @@
 #include "content/common/appcache_interfaces.h"
 #include "content/common/content_export.h"
 #include "net/http/http_response_headers.h"
-#include "net/url_request/url_request.h"
 #include "third_party/blink/public/mojom/appcache/appcache.mojom.h"
 #include "url/gurl.h"
 
+namespace net {
+class IOBuffer;
+}
+
 namespace content {
 FORWARD_DECLARE_TEST(AppCacheGroupTest, QueueUpdate);
 class AppCacheGroupTest;
@@ -45,6 +48,7 @@ class AppCacheUpdateJobTest;
 class AppCacheResponseInfo;
 class HostNotifier;
 
+CONTENT_EXPORT extern const base::Feature kAppCacheCorruptionRecoveryFeature;
 CONTENT_EXPORT extern const base::Feature kAppCacheUpdateResourceOn304Feature;
 
 // Application cache Update algorithm and state.
diff --git a/chromium/content/browser/appcache/appcache_update_job_unittest.cc b/chromium/content/browser/appcache/appcache_update_job_unittest.cc
index ef7707b07a6..92246ea8ff1 100644
--- a/chromium/content/browser/appcache/appcache_update_job_unittest.cc
+++ b/chromium/content/browser/appcache/appcache_update_job_unittest.cc
@@ -113,6 +113,16 @@ const char kManifest1WithNotModifiedContents[] =
     "CACHE:\n"
     "notmodified\n";
 
+const char kManifest1WithMaybeModifiedContents[] =
+    "CACHE MANIFEST\n"
+    "explicit1\n"
+    "FALLBACK:\n"
+    "fallback1 fallback1a\n"
+    "NETWORK:\n"
+    "*\n"
+    "CACHE:\n"
+    "maybemodified\n";
+
 const char kExplicit1Contents[] = "explicit1";
 
 // By default, kManifest2Contents is served from a path in /files/, so any
@@ -273,6 +283,9 @@ class MockHttpServer {
     } else if (path == "/files/manifest1-with-notmodified") {
       (*headers) = std::string(manifest_headers, base::size(manifest_headers));
       (*body) = kManifest1WithNotModifiedContents;
+    } else if (path == "/files/manifest1-with-maybemodified") {
+      (*headers) = std::string(manifest_headers, base::size(manifest_headers));
+      (*body) = kManifest1WithMaybeModifiedContents;
     } else if (path == "/files/manifest-fb-404") {
       (*headers) = std::string(manifest_headers, base::size(manifest_headers));
       (*body) =
@@ -313,6 +326,13 @@ class MockHttpServer {
           "CACHE MANIFEST\n"
           "CHROMIUM-INTERCEPT:\n"
           "intercept1 return intercept1a\n";
+    } else if (path == "/files/maybemodified") {
+      (*headers) =
+          std::string(not_modified_headers, base::size(not_modified_headers));
+      (*body) = "maybemodified";
+    } else if (path == "/files/modified") {
+      (*headers) = std::string(ok_headers, base::size(ok_headers));
+      (*body) = "modified";
     } else if (path == "/files/notmodified") {
       (*headers) =
           std::string(not_modified_headers, base::size(not_modified_headers));
@@ -690,9 +710,7 @@ class AppCacheUpdateJobTest : public testing::Test,
         interceptor_(
             base::BindRepeating(&AppCacheUpdateJobTest::InterceptRequest,
                                 base::Unretained(this))),
-        process_id_(123),
-        weak_partition_factory_(static_cast<StoragePartitionImpl*>(
-            BrowserContext::GetDefaultStoragePartition(&browser_context_))) {
+        process_id_(123) {
     appcache_require_origin_trial_feature_.InitAndDisableFeature(
         blink::features::kAppCacheRequireOriginTrial);
   }
@@ -711,12 +729,24 @@ class AppCacheUpdateJobTest : public testing::Test,
     if (it != http_headers_request_test_jobs_.end())
       it->second->ValidateExtraHeaders(url_request.headers);
 
+    // Copy the URL so we can optionally override it under certain conditions.
+    GURL requested_url = url_request.url;
+
+    // If "files/maybemodified" is requested without a conditional header,
+    // treat the request as if it's a request for "files/modified".  The
+    // result will be a 200 OK response (rather than maybemodified's normal
+    // 304 response).
+    if (requested_url.path() == "/files/maybemodified" &&
+        !url_request.headers.HasHeader("If-Modified-Since")) {
+      requested_url = GURL("http://mockhost/files/modified");
+    }
+
     std::string headers;
     std::string body;
-    if (RetryRequestTestJob::IsRetryUrl(url_request.url)) {
-      RetryRequestTestJob::GetResponseForURL(url_request.url, &headers, &body);
+    if (RetryRequestTestJob::IsRetryUrl(requested_url)) {
+      RetryRequestTestJob::GetResponseForURL(requested_url, &headers, &body);
     } else {
-      MockHttpServer::GetMockResponse(url_request.url.path(), &headers, &body);
+      MockHttpServer::GetMockResponse(requested_url.path(), &headers, &body);
     }
 
     net::HttpResponseInfo info;
@@ -747,13 +777,23 @@ class AppCacheUpdateJobTest : public testing::Test,
   }
 
   void SetUp() override {
+    browser_context_ = std::make_unique<content::TestBrowserContext>();
+    weak_partition_factory_ =
+        std::make_unique<base::WeakPtrFactory<StoragePartitionImpl>>(
+            static_cast<StoragePartitionImpl*>(
+                BrowserContext::GetDefaultStoragePartition(
+                    browser_context_.get())));
+
     ChildProcessSecurityPolicyImpl::GetInstance()->Add(process_id_,
-                                                       &browser_context_);
+                                                       browser_context_.get());
     blink::TrialTokenValidator::SetOriginTrialPolicyGetter(base::BindRepeating(
         []() -> blink::OriginTrialPolicy* { return &g_origin_trial_policy; }));
   }
 
   void TearDown() override {
+    weak_partition_factory_.reset();
+    browser_context_.reset();
+
     ChildProcessSecurityPolicyImpl::GetInstance()->Remove(process_id_);
   }
   // Use a separate IO thread to run a test. Thread will be destroyed
@@ -3818,14 +3858,10 @@ class AppCacheUpdateJobTest : public testing::Test,
   }
 
   void RequestResponseTimesAreModifiedTest() {
-    base::test::ScopedFeatureList f;
-    f.InitAndEnableFeature(kAppCacheUpdateResourceOn304Feature);
     RequestResponseTimesModified(/*feature_enabled=*/true);
   }
 
   void RequestResponseTimesAreNotModifiedTest() {
-    base::test::ScopedFeatureList f;
-    f.InitAndDisableFeature(kAppCacheUpdateResourceOn304Feature);
     RequestResponseTimesModified(/*feature_enabled=*/false);
   }
 
@@ -3974,6 +4010,173 @@ class AppCacheUpdateJobTest : public testing::Test,
     // Continues async in |TestComplete|.
   }
 
+  void RequestResponseTimesCorruptionFixedTest() {
+    RequestResponseTimesCorruption(/*expect_modified=*/true);
+  }
+
+  void RequestResponseTimesCorruptionNotFixedTest() {
+    RequestResponseTimesCorruption(/*expect_modified=*/false);
+  }
+
+  void RequestResponseTimesCorruption(bool expect_modified) {
+    MakeService();
+    group_ = base::MakeRefCounted<AppCacheGroup>(
+        service_->storage(),
+        MockHttpServer::GetMockUrl("files/manifest1-with-maybemodified"), 111);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
+    group_->update_job_ = update;
+
+    // Create a cache without a manifest entry.  The manifest entry will be
+    // added later.
+    AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), -1);
+    MockFrontend* frontend = MakeMockFrontend();
+    AppCacheHost* host = MakeHost(frontend);
+    host->AssociateCompleteCache(cache);
+
+    // Set up checks for when update job finishes.
+    do_checks_after_update_finished_ = true;
+    expect_group_obsolete_ = false;
+    expect_group_has_cache_ = true;
+    tested_manifest_ = MANIFEST1_WITH_MAYBEMODIFIED;
+    if (!expect_modified) {
+      expect_old_cache_ = cache;
+    }
+    frontend->AddExpectedEvent(
+        blink::mojom::AppCacheEventID::APPCACHE_CHECKING_EVENT);
+    frontend->AddExpectedEvent(
+        blink::mojom::AppCacheEventID::APPCACHE_DOWNLOADING_EVENT);
+    frontend->AddExpectedEvent(
+        blink::mojom::AppCacheEventID::APPCACHE_PROGRESS_EVENT);
+    frontend->AddExpectedEvent(
+        blink::mojom::AppCacheEventID::APPCACHE_PROGRESS_EVENT);
+    frontend->AddExpectedEvent(
+        blink::mojom::AppCacheEventID::APPCACHE_PROGRESS_EVENT);
+    frontend->AddExpectedEvent(
+        blink::mojom::AppCacheEventID::APPCACHE_PROGRESS_EVENT);  // final
+    frontend->AddExpectedEvent(
+        blink::mojom::AppCacheEventID::APPCACHE_UPDATE_READY_EVENT);
+
+    AppCacheCacheTestHelper::CacheEntries cache_entries;
+
+    // Add cache entry for manifest.
+    // Seed storage with expected manifest response info that will cause
+    // an If-Modified-Since header to be put in the manifest fetch request.
+    {
+      const char data[] =
+          "HTTP/1.1 200 OK\0"
+          "Last-Modified: Sat, 29 Oct 2019 19:43:31 GMT\0";
+      scoped_refptr<net::HttpResponseHeaders> headers =
+          base::MakeRefCounted<net::HttpResponseHeaders>(
+              std::string(data, base::size(data)));
+      std::unique_ptr<net::HttpResponseInfo> response_info =
+          std::make_unique<net::HttpResponseInfo>();
+      response_info->headers = std::move(headers);
+      response_info->request_time = base::Time::Now() - kOneYear;
+      response_info->response_time = base::Time::Now() - kOneYear;
+      AppCacheCacheTestHelper::AddCacheEntry(
+          &cache_entries, group_->manifest_url(), AppCacheEntry::EXPLICIT,
+          /*expect_if_modified_since=*/std::string(),
+          /*expect_if_none_match=*/std::string(), /*headers_allowed=*/true,
+          std::move(response_info), kManifest1WithMaybeModifiedContents);
+    }
+
+    // Add cache entry for maybemodified.
+    // Seed storage with expected cache response info that will cause
+    // an If-Modified-Since header to be put in the fetch request.
+    {
+      const char data[] =
+          "HTTP/1.1 200 OK\0"
+          "Last-Modified: Sat, 29 Oct 2019 19:43:31 GMT\0";
+      scoped_refptr<net::HttpResponseHeaders> headers =
+          base::MakeRefCounted<net::HttpResponseHeaders>(
+              std::string(data, base::size(data)));
+      std::unique_ptr<net::HttpResponseInfo> response_info =
+          std::make_unique<net::HttpResponseInfo>();
+      response_info->headers = std::move(headers);
+      CHECK_EQ(response_info->request_time, base::Time());
+      CHECK_EQ(response_info->response_time, base::Time());
+      std::string expect_if_modified_since;
+      if (!expect_modified) {
+        expect_if_modified_since = "Sat, 29 Oct 2019 19:43:31 GMT";
+      }
+      AppCacheCacheTestHelper::AddCacheEntry(
+          &cache_entries, MockHttpServer::GetMockUrl("files/maybemodified"),
+          AppCacheEntry::EXPLICIT,
+          /*expect_if_modified_since=*/expect_if_modified_since,
+          /*expect_if_none_match=*/std::string(), /*headers_allowed=*/true,
+          std::move(response_info), /*body=*/"cached-maybemodified");
+    }
+
+    // Add all header checks from |cache_entries|.
+    for (auto& it : cache_entries) {
+      http_headers_request_test_jobs_.emplace(
+          it.first,
+          std::make_unique<HttpHeadersRequestTestJob>(
+              it.second->expect_if_modified_since,
+              it.second->expect_if_none_match, it.second->headers_allowed));
+    }
+
+    cache_helper_ = std::make_unique<AppCacheCacheTestHelper>(
+        service_.get(), group_->manifest_url(), cache, std::move(cache_entries),
+        base::BindOnce(
+            &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
+            base::Unretained(this)));
+    cache_helper_->Write();
+
+    post_update_finished_cb_ = base::BindOnce(
+        &AppCacheUpdateJobTest::RequestResponseTimesCorruptionUpdateFinished,
+        base::Unretained(this), expect_modified);
+
+    // Start update after data write completes asynchronously.
+    // After update is finished, continues async in
+    // |RequestResponseTimesCorruptionUpdateFinished|.
+  }
+
+  void RequestResponseTimesCorruptionUpdateFinished(bool expect_modified) {
+    // After cache write was complete, we note that we expect an item to be
+    // copied for the not modified case.
+    if (!expect_modified) {
+      expect_response_ids_.insert(std::map<GURL, int64_t>::value_type(
+          MockHttpServer::GetMockUrl("files/maybemodified"),
+          expect_old_cache_
+              ->GetEntry(MockHttpServer::GetMockUrl("files/maybemodified"))
+              ->response_id()));  // copied
+    }
+    ASSERT_NE(group_->newest_complete_cache(), cache_helper_->write_cache());
+    ASSERT_NE(group_->newest_complete_cache(), nullptr);
+    cache_helper_->PrepareForRead(
+        group_->newest_complete_cache(),
+        base::BindOnce(
+            &AppCacheUpdateJobTest::RequestResponseTimesCorruptionReadFinished,
+            base::Unretained(this), expect_modified));
+    cache_helper_->Read();
+    // Continues async in |RequestResponseTimesCorruptionReadFinished|.
+  }
+
+  void RequestResponseTimesCorruptionReadFinished(bool expect_modified) {
+    std::string resource_name;
+    resource_name = "files/maybemodified";
+    auto it = cache_helper_->read_cache_entries().find(
+        MockHttpServer::GetMockUrl(resource_name));
+    ASSERT_NE(it, cache_helper_->read_cache_entries().end());
+    if (expect_modified) {
+      // Verify that the cache body on the entry matches the expected mock
+      // return body.
+      CHECK_EQ(it->second->body, "modified");
+      CHECK_GT(it->second->response_info->request_time,
+               base::Time::Now() - kOneHour);
+      CHECK_GT(it->second->response_info->response_time,
+               base::Time::Now() - kOneHour);
+    } else {
+      CHECK_EQ(it->second->body, "cached-maybemodified");
+      CHECK_EQ(it->second->response_info->request_time, base::Time());
+      CHECK_EQ(it->second->response_info->response_time, base::Time());
+    }
+    TriggerTestComplete();
+    // Continues async in |TestComplete|.
+  }
+
   void IfNoneMatchRefetchTest() {
     MakeService();
     group_ = base::MakeRefCounted<AppCacheGroup>(
@@ -4242,7 +4445,7 @@ class AppCacheUpdateJobTest : public testing::Test,
 
   void MakeService() {
     service_ = std::make_unique<MockAppCacheService>(
-        weak_partition_factory_.GetWeakPtr());
+        weak_partition_factory_->GetWeakPtr());
   }
 
   AppCache* MakeCacheForGroup(int64_t cache_id, int64_t manifest_response_id) {
@@ -4422,7 +4625,10 @@ class AppCacheUpdateJobTest : public testing::Test,
           VerifyManifest1(cache);
           break;
         case MANIFEST1_WITH_NOTMODIFIED:
-          VerifyManifest1WithNotmodified(cache);
+          VerifyManifest1WithNotModified(cache);
+          break;
+        case MANIFEST1_WITH_MAYBEMODIFIED:
+          VerifyManifest1WithMaybeModified(cache);
           break;
         case MANIFEST2_WITH_ROOT_SCOPE:
           VerifyManifest2WithRootScope(cache);
@@ -4492,13 +4698,13 @@ class AppCacheUpdateJobTest : public testing::Test,
                           MockHttpServer::GetMockUrl("files/fallback1"),
                           MockHttpServer::GetMockUrl("files/fallback1a")));
 
-    EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
-    EXPECT_TRUE(cache->online_whitelist_all_);
+    EXPECT_TRUE(cache->online_safelist_namespaces_.empty());
+    EXPECT_TRUE(cache->online_safelist_all_);
 
     EXPECT_TRUE(cache->update_time_ > base::Time());
   }
 
-  void VerifyManifest1WithNotmodified(AppCache* cache) {
+  void VerifyManifest1WithNotModified(AppCache* cache) {
     size_t expected = 4 + expect_extra_entries_.size();
     EXPECT_EQ(expected, cache->entries().size());
     const char* kManifestPath = tested_manifest_path_override_
@@ -4508,6 +4714,9 @@ class AppCacheUpdateJobTest : public testing::Test,
         cache->GetEntry(MockHttpServer::GetMockUrl(kManifestPath));
     ASSERT_TRUE(entry);
     EXPECT_EQ(AppCacheEntry::MANIFEST, entry->types());
+    entry = cache->GetEntry(MockHttpServer::GetMockUrl("files/notmodified"));
+    ASSERT_TRUE(entry);
+    EXPECT_TRUE(entry->IsExplicit());
     entry = cache->GetEntry(MockHttpServer::GetMockUrl("files/explicit1"));
     ASSERT_TRUE(entry);
     EXPECT_TRUE(entry->IsExplicit());
@@ -4529,8 +4738,48 @@ class AppCacheUpdateJobTest : public testing::Test,
                           MockHttpServer::GetMockUrl("files/fallback1"),
                           MockHttpServer::GetMockUrl("files/fallback1a")));
 
-    EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
-    EXPECT_TRUE(cache->online_whitelist_all_);
+    EXPECT_TRUE(cache->online_safelist_namespaces_.empty());
+    EXPECT_TRUE(cache->online_safelist_all_);
+
+    EXPECT_TRUE(cache->update_time_ > base::Time());
+  }
+
+  void VerifyManifest1WithMaybeModified(AppCache* cache) {
+    size_t expected = 4 + expect_extra_entries_.size();
+    EXPECT_EQ(expected, cache->entries().size());
+    const char* kManifestPath = tested_manifest_path_override_
+                                    ? tested_manifest_path_override_
+                                    : "files/manifest1-with-maybemodified";
+    AppCacheEntry* entry =
+        cache->GetEntry(MockHttpServer::GetMockUrl(kManifestPath));
+    ASSERT_TRUE(entry);
+    EXPECT_EQ(AppCacheEntry::MANIFEST, entry->types());
+    entry = cache->GetEntry(MockHttpServer::GetMockUrl("files/maybemodified"));
+    ASSERT_TRUE(entry);
+    EXPECT_TRUE(entry->IsExplicit());
+    entry = cache->GetEntry(MockHttpServer::GetMockUrl("files/explicit1"));
+    ASSERT_TRUE(entry);
+    EXPECT_TRUE(entry->IsExplicit());
+    entry = cache->GetEntry(MockHttpServer::GetMockUrl("files/fallback1a"));
+    ASSERT_TRUE(entry);
+    EXPECT_EQ(AppCacheEntry::FALLBACK, entry->types());
+
+    for (const auto& pair : expect_extra_entries_) {
+      entry = cache->GetEntry(pair.first);
+      ASSERT_TRUE(entry);
+      EXPECT_EQ(pair.second.types(), entry->types());
+    }
+
+    expected = 1;
+    ASSERT_EQ(expected, cache->fallback_namespaces_.size());
+    EXPECT_TRUE(
+        cache->fallback_namespaces_[0] ==
+        AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE,
+                          MockHttpServer::GetMockUrl("files/fallback1"),
+                          MockHttpServer::GetMockUrl("files/fallback1a")));
+
+    EXPECT_TRUE(cache->online_safelist_namespaces_.empty());
+    EXPECT_TRUE(cache->online_safelist_all_);
 
     EXPECT_TRUE(cache->update_time_ > base::Time());
   }
@@ -4580,8 +4829,8 @@ class AppCacheUpdateJobTest : public testing::Test,
                           MockHttpServer::GetMockUrl("bar/fallback2"),
                           MockHttpServer::GetMockUrl("files/fallback2a")));
 
-    EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
-    EXPECT_TRUE(cache->online_whitelist_all_);
+    EXPECT_TRUE(cache->online_safelist_namespaces_.empty());
+    EXPECT_TRUE(cache->online_safelist_all_);
 
     EXPECT_TRUE(cache->update_time_ > base::Time());
   }
@@ -4621,8 +4870,8 @@ class AppCacheUpdateJobTest : public testing::Test,
                           MockHttpServer::GetMockUrl("files/fallback1"),
                           MockHttpServer::GetMockUrl("files/fallback1a")));
 
-    EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
-    EXPECT_TRUE(cache->online_whitelist_all_);
+    EXPECT_TRUE(cache->online_safelist_namespaces_.empty());
+    EXPECT_TRUE(cache->online_safelist_all_);
 
     EXPECT_TRUE(cache->update_time_ > base::Time());
   }
@@ -4649,12 +4898,12 @@ class AppCacheUpdateJobTest : public testing::Test,
                           MockHttpServer::GetMockUrl("files/fallback1"),
                           MockHttpServer::GetMockUrl("files/explicit1")));
 
-    EXPECT_EQ(expected, cache->online_whitelist_namespaces_.size());
-    EXPECT_TRUE(cache->online_whitelist_namespaces_[0] ==
+    EXPECT_EQ(expected, cache->online_safelist_namespaces_.size());
+    EXPECT_TRUE(cache->online_safelist_namespaces_[0] ==
                 AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE,
                                   MockHttpServer::GetMockUrl("files/online1"),
                                   GURL()));
-    EXPECT_FALSE(cache->online_whitelist_all_);
+    EXPECT_FALSE(cache->online_safelist_all_);
 
     EXPECT_TRUE(cache->update_time_ > base::Time());
   }
@@ -4671,8 +4920,8 @@ class AppCacheUpdateJobTest : public testing::Test,
     EXPECT_EQ(AppCacheEntry::MANIFEST, entry->types());
 
     EXPECT_TRUE(cache->fallback_namespaces_.empty());
-    EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
-    EXPECT_FALSE(cache->online_whitelist_all_);
+    EXPECT_TRUE(cache->online_safelist_namespaces_.empty());
+    EXPECT_FALSE(cache->online_safelist_all_);
 
     EXPECT_TRUE(cache->update_time_ > base::Time());
   }
@@ -4690,8 +4939,8 @@ class AppCacheUpdateJobTest : public testing::Test,
     EXPECT_TRUE(entry->has_response_id());
 
     EXPECT_TRUE(cache->fallback_namespaces_.empty());
-    EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
-    EXPECT_FALSE(cache->online_whitelist_all_);
+    EXPECT_TRUE(cache->online_safelist_namespaces_.empty());
+    EXPECT_FALSE(cache->online_safelist_all_);
 
     EXPECT_TRUE(cache->update_time_ > base::Time());
   }
@@ -4714,8 +4963,8 @@ class AppCacheUpdateJobTest : public testing::Test,
     EXPECT_TRUE(entry->has_response_id());
 
     EXPECT_TRUE(cache->fallback_namespaces_.empty());
-    EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
-    EXPECT_FALSE(cache->online_whitelist_all_);
+    EXPECT_TRUE(cache->online_safelist_namespaces_.empty());
+    EXPECT_FALSE(cache->online_safelist_all_);
 
     EXPECT_TRUE(cache->update_time_ > base::Time());
   }
@@ -4852,8 +5101,8 @@ class AppCacheUpdateJobTest : public testing::Test,
     EXPECT_EQ(expected_size, cache->entries().size());
 
     // Verify basic cache details.
-    EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
-    EXPECT_FALSE(cache->online_whitelist_all_);
+    EXPECT_TRUE(cache->online_safelist_namespaces_.empty());
+    EXPECT_FALSE(cache->online_safelist_all_);
     EXPECT_TRUE(cache->update_time_ > base::Time());
 
     // Verify manifest.
@@ -4890,6 +5139,7 @@ class AppCacheUpdateJobTest : public testing::Test,
   enum TestedManifest {
     NONE,
     MANIFEST1,
+    MANIFEST1_WITH_MAYBEMODIFIED,
     MANIFEST1_WITH_NOTMODIFIED,
     MANIFEST2_WITH_ROOT_SCOPE,
     MANIFEST2_WITH_FILES_SCOPE,
@@ -5094,7 +5344,6 @@ class AppCacheUpdateJobTest : public testing::Test,
   AppCache::EntryMap expect_extra_entries_;
   std::map<GURL, int64_t> expect_response_ids_;
 
-  content::TestBrowserContext browser_context_;
   URLLoaderInterceptor interceptor_;
   const int process_id_;
   std::map<GURL, std::unique_ptr<HttpHeadersRequestTestJob>>
@@ -5102,7 +5351,68 @@ class AppCacheUpdateJobTest : public testing::Test,
 
   base::test::ScopedFeatureList appcache_require_origin_trial_feature_;
 
-  base::WeakPtrFactory<StoragePartitionImpl> weak_partition_factory_;
+  // Lazily create these to avoid data races in the FeatureList between
+  // service workers (reading) and appcache tests (writing).
+  std::unique_ptr<content::TestBrowserContext> browser_context_;
+  std::unique_ptr<base::WeakPtrFactory<StoragePartitionImpl>>
+      weak_partition_factory_;
+};
+
+class AppCacheUpdateJobOriginTrialTest : public AppCacheUpdateJobTest {
+ public:
+  AppCacheUpdateJobOriginTrialTest() {
+    scoped_feature_list_.InitAndEnableFeature(
+        blink::features::kAppCacheRequireOriginTrial);
+  }
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
+};
+
+class AppCacheUpdateJobUpdateOn304Test : public AppCacheUpdateJobTest {
+ public:
+  AppCacheUpdateJobUpdateOn304Test() {
+    scoped_feature_list_.InitAndEnableFeature(
+        kAppCacheUpdateResourceOn304Feature);
+  }
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
+};
+
+class AppCacheUpdateJobNoUpdateOn304Test : public AppCacheUpdateJobTest {
+ public:
+  AppCacheUpdateJobNoUpdateOn304Test() {
+    scoped_feature_list_.InitAndDisableFeature(
+        kAppCacheUpdateResourceOn304Feature);
+  }
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
+};
+
+class AppCacheUpdateJobWithCorruptionRecoveryTest
+    : public AppCacheUpdateJobTest {
+ public:
+  AppCacheUpdateJobWithCorruptionRecoveryTest() {
+    scoped_feature_list_.InitAndEnableFeature(
+        kAppCacheCorruptionRecoveryFeature);
+  }
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
+};
+
+class AppCacheUpdateJobWithoutCorruptionRecoveryTest
+    : public AppCacheUpdateJobTest {
+ public:
+  AppCacheUpdateJobWithoutCorruptionRecoveryTest() {
+    scoped_feature_list_.InitAndDisableFeature(
+        kAppCacheCorruptionRecoveryFeature);
+  }
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
 };
 
 TEST_F(AppCacheUpdateJobTest, AlreadyChecking) {
@@ -5194,21 +5504,15 @@ TEST_F(AppCacheUpdateJobTest, ManifestMissingMimeTypeTest) {
   RunTestOnUIThread(&AppCacheUpdateJobTest::ManifestMissingMimeTypeTest);
 }
 
-TEST_F(AppCacheUpdateJobTest, ManifestNotFound) {
-  base::test::ScopedFeatureList f;
-  f.InitAndEnableFeature(blink::features::kAppCacheRequireOriginTrial);
+TEST_F(AppCacheUpdateJobOriginTrialTest, ManifestNotFound) {
   RunTestOnUIThread(&AppCacheUpdateJobTest::ManifestNotFoundTest);
 }
 
-TEST_F(AppCacheUpdateJobTest, ManifestGoneFetch) {
-  base::test::ScopedFeatureList f;
-  f.InitAndEnableFeature(blink::features::kAppCacheRequireOriginTrial);
+TEST_F(AppCacheUpdateJobOriginTrialTest, ManifestGoneFetch) {
   RunTestOnUIThread(&AppCacheUpdateJobTest::ManifestGoneFetchTest);
 }
 
-TEST_F(AppCacheUpdateJobTest, ManifestGoneUpgrade) {
-  base::test::ScopedFeatureList f;
-  f.InitAndEnableFeature(blink::features::kAppCacheRequireOriginTrial);
+TEST_F(AppCacheUpdateJobOriginTrialTest, ManifestGoneUpgrade) {
   RunTestOnUIThread(&AppCacheUpdateJobTest::ManifestGoneUpgradeTest);
 }
 
@@ -5414,9 +5718,7 @@ TEST_F(AppCacheUpdateJobTest, UpgradeFailStoreNewestCache) {
   RunTestOnUIThread(&AppCacheUpdateJobTest::UpgradeFailStoreNewestCacheTest);
 }
 
-TEST_F(AppCacheUpdateJobTest, UpgradeFailMakeGroupObsolete) {
-  base::test::ScopedFeatureList f;
-  f.InitAndEnableFeature(blink::features::kAppCacheRequireOriginTrial);
+TEST_F(AppCacheUpdateJobOriginTrialTest, UpgradeFailMakeGroupObsolete) {
   RunTestOnUIThread(&AppCacheUpdateJobTest::UpgradeFailMakeGroupObsoleteTest);
 }
 
@@ -5508,16 +5810,28 @@ TEST_F(AppCacheUpdateJobTest, RequestResponseTimesAreSet) {
   RunTestOnUIThread(&AppCacheUpdateJobTest::RequestResponseTimesAreSetTest);
 }
 
-TEST_F(AppCacheUpdateJobTest, RequestResponseTimesAreModified) {
+TEST_F(AppCacheUpdateJobUpdateOn304Test, RequestResponseTimesAreModified) {
   RunTestOnUIThread(
       &AppCacheUpdateJobTest::RequestResponseTimesAreModifiedTest);
 }
 
-TEST_F(AppCacheUpdateJobTest, RequestResponseTimesAreNotModified) {
+TEST_F(AppCacheUpdateJobNoUpdateOn304Test, RequestResponseTimesAreNotModified) {
   RunTestOnUIThread(
       &AppCacheUpdateJobTest::RequestResponseTimesAreNotModifiedTest);
 }
 
+TEST_F(AppCacheUpdateJobWithCorruptionRecoveryTest,
+       RequestResponseTimesCorruptionFixed) {
+  RunTestOnUIThread(
+      &AppCacheUpdateJobTest::RequestResponseTimesCorruptionFixedTest);
+}
+
+TEST_F(AppCacheUpdateJobWithoutCorruptionRecoveryTest,
+       RequestResponseTimesCorruptionNotFixed) {
+  RunTestOnUIThread(
+      &AppCacheUpdateJobTest::RequestResponseTimesCorruptionNotFixedTest);
+}
+
 TEST_F(AppCacheUpdateJobTest, IfNoneMatchRefetch) {
   RunTestOnUIThread(&AppCacheUpdateJobTest::IfNoneMatchRefetchTest);
 }
@@ -5534,23 +5848,18 @@ TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnUIThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
-TEST_F(AppCacheUpdateJobTest, OriginTrialUpdateWithFeature) {
+TEST_F(AppCacheUpdateJobOriginTrialTest, OriginTrialUpdateWithFeature) {
   // Updating a manifest with a valid token should work
   // with or without the kAppCacheRequireOriginTrial feature.
-  base::test::ScopedFeatureList f;
-  f.InitAndEnableFeature(blink::features::kAppCacheRequireOriginTrial);
   RunTestOnUIThread(&AppCacheUpdateJobTest::OriginTrialUpdateTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, OriginTrialUpdateWithoutFeature) {
-  base::test::ScopedFeatureList f;
-  f.InitAndDisableFeature(blink::features::kAppCacheRequireOriginTrial);
+  // The default AppCacheUpdateJobTest disables the origin trial.
   RunTestOnUIThread(&AppCacheUpdateJobTest::OriginTrialUpdateTest);
 }
 
-TEST_F(AppCacheUpdateJobTest, OriginTrialRequiredNoToken) {
-  base::test::ScopedFeatureList f;
-  f.InitAndEnableFeature(blink::features::kAppCacheRequireOriginTrial);
+TEST_F(AppCacheUpdateJobOriginTrialTest, OriginTrialRequiredNoToken) {
   RunTestOnUIThread(&AppCacheUpdateJobTest::OriginTrialRequiredNoTokenTest);
 }
 
diff --git a/chromium/content/browser/appcache/appcache_update_metrics_recorder.cc b/chromium/content/browser/appcache/appcache_update_metrics_recorder.cc
index ce7a008ebbb..e8a141a8f95 100644
--- a/chromium/content/browser/appcache/appcache_update_metrics_recorder.cc
+++ b/chromium/content/browser/appcache/appcache_update_metrics_recorder.cc
@@ -34,6 +34,15 @@ void AppCacheUpdateMetricsRecorder::IncrementExistingResourceCorrupt() {
   existing_resource_corrupt_++;
 }
 
+void AppCacheUpdateMetricsRecorder::
+    IncrementExistingResourceCorruptionRecovery() {
+#if DCHECK_IS_ON()
+  DCHECK(!finalized_) << "UploadMetrics() already called";
+#endif  // DCHECK_IS_ON()
+
+  existing_resource_corruption_recovery_++;
+}
+
 void AppCacheUpdateMetricsRecorder::IncrementExistingResourceNotCorrupt() {
 #if DCHECK_IS_ON()
   DCHECK(!finalized_) << "UploadMetrics() already called";
@@ -88,6 +97,9 @@ void AppCacheUpdateMetricsRecorder::UploadMetrics() {
                                 existing_resource_check_, 50);
   base::UmaHistogramExactLinear("appcache.UpdateJob.ExistingResourceCorrupt",
                                 existing_resource_corrupt_, 50);
+  base::UmaHistogramExactLinear(
+      "appcache.UpdateJob.ExistingResourceCorruptionRecovery",
+      existing_resource_corruption_recovery_, 50);
   base::UmaHistogramExactLinear("appcache.UpdateJob.ExistingResourceNotCorrupt",
                                 existing_resource_not_corrupt_, 50);
   base::UmaHistogramExactLinear("appcache.UpdateJob.ExistingResourceReused",
diff --git a/chromium/content/browser/appcache/appcache_update_metrics_recorder.h b/chromium/content/browser/appcache/appcache_update_metrics_recorder.h
index 29f20cfe488..1f25fec47d9 100644
--- a/chromium/content/browser/appcache/appcache_update_metrics_recorder.h
+++ b/chromium/content/browser/appcache/appcache_update_metrics_recorder.h
@@ -37,6 +37,12 @@ class CONTENT_EXPORT AppCacheUpdateMetricsRecorder {
   // will not be detected/reported through this metric.
   void IncrementExistingResourceCorrupt();
 
+  // IncrementExistingResourceCorruptionRecovery() keeps track of the number of
+  // times we detected a corrupt resource and triggered corruption recovery.
+  // This will only occur when the corruption recovery feature is enabled in
+  // a given Chromium instance.
+  void IncrementExistingResourceCorruptionRecovery();
+
   // IncrementExistingResourceNotCorrupt() keeps track of the number of non-
   // corrupt resources that we've encountered.  Non-corrupt cache entries that
   // are present and haven't been read or haven't been checked to see if they
@@ -76,6 +82,7 @@ class CONTENT_EXPORT AppCacheUpdateMetricsRecorder {
   int existing_corruption_fixed_in_update_ = 0;
   int existing_resource_check_ = 0;
   int existing_resource_corrupt_ = 0;
+  int existing_resource_corruption_recovery_ = 0;
   int existing_resource_not_corrupt_ = 0;
   int existing_resource_reused_ = 0;
   int existing_vary_during_304_ = 0;
diff --git a/chromium/content/browser/appcache/appcache_update_url_loader_request.cc b/chromium/content/browser/appcache/appcache_update_url_loader_request.cc
index bd695913c5e..395580e8fe9 100644
--- a/chromium/content/browser/appcache/appcache_update_url_loader_request.cc
+++ b/chromium/content/browser/appcache/appcache_update_url_loader_request.cc
@@ -10,7 +10,6 @@
 #include "content/browser/storage_partition_impl.h"
 #include "net/base/ip_endpoint.h"
 #include "net/http/http_response_info.h"
-#include "net/url_request/url_request_context.h"
 
 namespace content {
 
diff --git a/chromium/content/browser/appcache/appcache_url_loader.cc b/chromium/content/browser/appcache/appcache_url_loader.cc
index a734156b49c..8a5c0906e58 100644
--- a/chromium/content/browser/appcache/appcache_url_loader.cc
+++ b/chromium/content/browser/appcache/appcache_url_loader.cc
@@ -380,14 +380,14 @@ void AppCacheURLLoader::NotifyCompleted(int error_code) {
 
   network::URLLoaderCompletionStatus status(error_code);
   if (!error_code) {
-    const net::HttpResponseInfo* http_info =
-        is_range_request() ? range_response_info_.get()
-                           : (info_ ? &info_->http_response_info() : nullptr);
+    const net::HttpResponseInfo* http_info = is_range_request()
+                                                 ? range_response_info_.get()
+                                                 : &info_->http_response_info();
     status.exists_in_cache = http_info->was_cached;
     status.completion_time = base::TimeTicks::Now();
     status.encoded_body_length =
         is_range_request() ? range_response_info_->headers->GetContentLength()
-                           : (info_ ? info_->response_data_size() : 0);
+                           : info_->response_data_size();
     status.decoded_body_length = status.encoded_body_length;
   }
   client_->OnComplete(status);
diff --git a/chromium/content/browser/appcache/chrome_appcache_service_unittest.cc b/chromium/content/browser/appcache/chrome_appcache_service_unittest.cc
index 7b52d3809e4..82bca20d8fa 100644
--- a/chromium/content/browser/appcache/chrome_appcache_service_unittest.cc
+++ b/chromium/content/browser/appcache/chrome_appcache_service_unittest.cc
@@ -22,7 +22,6 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/test_browser_context.h"
-#include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/test/mock_special_storage_policy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
diff --git a/chromium/content/browser/appcache/mock_appcache_storage_unittest.cc b/chromium/content/browser/appcache/mock_appcache_storage_unittest.cc
index a74291ea96e..b7938ac0cd4 100644
--- a/chromium/content/browser/appcache/mock_appcache_storage_unittest.cc
+++ b/chromium/content/browser/appcache/mock_appcache_storage_unittest.cc
@@ -589,7 +589,7 @@ TEST_F(MockAppCacheStorageTest, FindMainResponseExclusions) {
   const int64_t kResponseId = 1;
 
   AppCacheManifest manifest;
-  manifest.online_whitelist_namespaces.push_back(AppCacheNamespace(
+  manifest.online_safelist_namespaces.push_back(AppCacheNamespace(
       APPCACHE_NETWORK_NAMESPACE, kOnlineNamespaceUrl, GURL()));
   auto cache = base::MakeRefCounted<AppCache>(service.storage(), kCacheId);
   cache->InitializeWithManifest(&manifest);