Revert of Support "shouldResetAppCache" request parameter. (patchset #9 id:160001 of https://codereview.chromium.org/669133002/)

Reason for revert:
http://build.chromium.org/p/chromium.memory.fyi/builders/Windows%20Unit%20%28DrMemory%20full%29%20%283%29/builds/4099/steps/memory%20test%3A%20content/logs/stdio

Original issue's description:
> Support "shouldResetAppCache" request parameter.
>
> This patch pulls parameter value to AppCacheRequestHandler.
>
> When parameter value is true - cache corresponding to manifest_url is resetted.
>
> shouldResetAppCache parameter is set by DevTools when "Disable Cache" mode is on, to ensure that pages are reloaded from network.
>
> Blink patch: https://codereview.chromium.org/723113002
>
> BUG=256672
>
> Committed: https://crrev.com/fd1ed6c36a08666dea471546c6e63d92997e815f
> Cr-Commit-Position: refs/heads/master@{#305795}
>
> Committed: https://crrev.com/28fb659df8b0f6f8ed91a47b02c117e8ee76012e
> Cr-Commit-Position: refs/heads/master@{#305960}

TBR=michaeln@chromium.org,jam@chromium.org,dcheng@chromium.org
NOTREECHECKS=true
NOTRY=true
BUG=256672

Review URL: https://codereview.chromium.org/765703002

Cr-Commit-Position: refs/heads/master@{#305971}

14 files changed, 30 insertions, 78 deletions

diff --git a/content/browser/appcache/appcache_host.cc b/content/browser/appcache/appcache_host.cc
index 4ec19ff..52213a3 100644
--- a/content/browser/appcache/appcache_host.cc
+++ b/content/browser/appcache/appcache_host.cc
@@ -291,13 +291,11 @@ AppCacheHost* AppCacheHost::GetParentAppCacheHost() const {
 
 AppCacheRequestHandler* AppCacheHost::CreateRequestHandler(
     net::URLRequest* request,
-    ResourceType resource_type,
-    bool should_reset_appcache) {
+    ResourceType resource_type) {
   if (is_for_dedicated_worker()) {
     AppCacheHost* parent_host = GetParentAppCacheHost();
     if (parent_host)
-      return parent_host->CreateRequestHandler(
-          request, resource_type, should_reset_appcache);
+      return parent_host->CreateRequestHandler(request, resource_type);
     return NULL;
   }
 
@@ -305,14 +303,12 @@ AppCacheRequestHandler* AppCacheHost::CreateRequestHandler(
     // Store the first party origin so that it can be used later in SelectCache
     // for checking whether the creation of the appcache is allowed.
     first_party_url_ = request->first_party_for_cookies();
-    return new AppCacheRequestHandler(
-        this, resource_type, should_reset_appcache);
+    return new AppCacheRequestHandler(this, resource_type);
   }
 
   if ((associated_cache() && associated_cache()->is_complete()) ||
       is_selection_pending()) {
-    return new AppCacheRequestHandler(
-        this, resource_type, should_reset_appcache);
+    return new AppCacheRequestHandler(this, resource_type);
   }
   return NULL;
 }
diff --git a/content/browser/appcache/appcache_host.h b/content/browser/appcache/appcache_host.h
index 7525ea2..9f014fb 100644
--- a/content/browser/appcache/appcache_host.h
+++ b/content/browser/appcache/appcache_host.h
@@ -111,8 +111,7 @@ class CONTENT_EXPORT AppCacheHost
   // May return NULL if the request isn't subject to retrieval from an appache.
   AppCacheRequestHandler* CreateRequestHandler(
       net::URLRequest* request,
-      ResourceType resource_type,
-      bool should_reset_appcache);
+      ResourceType resource_type);
 
   // Support for devtools inspecting appcache resources.
   void GetResourceList(std::vector<AppCacheResourceInfo>* resource_infos);
diff --git a/content/browser/appcache/appcache_interceptor.cc b/content/browser/appcache/appcache_interceptor.cc
index 6cb66df..e0b5513 100644
--- a/content/browser/appcache/appcache_interceptor.cc
+++ b/content/browser/appcache/appcache_interceptor.cc
@@ -32,8 +32,7 @@ void AppCacheInterceptor::SetExtraRequestInfo(
     AppCacheServiceImpl* service,
     int process_id,
     int host_id,
-    ResourceType resource_type,
-    bool should_reset_appcache) {
+    ResourceType resource_type) {
   if (!service || (host_id == kAppCacheNoHostId))
     return;
 
@@ -49,7 +48,7 @@ void AppCacheInterceptor::SetExtraRequestInfo(
 
   // Create a handler for this request and associate it with the request.
   AppCacheRequestHandler* handler =
-      host->CreateRequestHandler(request, resource_type, should_reset_appcache);
+      host->CreateRequestHandler(request, resource_type);
   if (handler)
     SetHandler(request, handler);
 }
diff --git a/content/browser/appcache/appcache_interceptor.h b/content/browser/appcache/appcache_interceptor.h
index 50ba944..09fa576 100644
--- a/content/browser/appcache/appcache_interceptor.h
+++ b/content/browser/appcache/appcache_interceptor.h
@@ -29,8 +29,7 @@ class CONTENT_EXPORT AppCacheInterceptor : public net::URLRequestInterceptor {
                                   AppCacheServiceImpl* service,
                                   int process_id,
                                   int host_id,
-                                  ResourceType resource_type,
-                                  bool should_reset_appcache);
+                                  ResourceType resource_type);
 
   // May be called after response headers are complete to retrieve extra
   // info about the response.
diff --git a/content/browser/appcache/appcache_request_handler.cc b/content/browser/appcache/appcache_request_handler.cc
index 46344ae..a21337c 100644
--- a/content/browser/appcache/appcache_request_handler.cc
+++ b/content/browser/appcache/appcache_request_handler.cc
@@ -15,11 +15,9 @@
 namespace content {
 
 AppCacheRequestHandler::AppCacheRequestHandler(AppCacheHost* host,
-                                               ResourceType resource_type,
-                                               bool should_reset_appcache)
+                                               ResourceType resource_type)
     : host_(host),
       resource_type_(resource_type),
-      should_reset_appcache_(should_reset_appcache),
       is_waiting_for_cache_selection_(false),
       found_group_id_(0),
       found_cache_id_(0),
@@ -294,13 +292,6 @@ void AppCacheRequestHandler::OnMainResponseFound(
     return;
   }
 
-  if (should_reset_appcache_ && !manifest_url.is_empty()) {
-    host_->service()->DeleteAppCacheGroup(
-        manifest_url, net::CompletionCallback());
-    DeliverNetworkResponse();
-    return;
-  }
-
   if (IsResourceTypeFrame(resource_type_) && cache_id != kAppCacheNoCacheId) {
     // AppCacheHost loads and holds a reference to the main resource cache
     // for two reasons, firstly to preload the cache into the working set
diff --git a/content/browser/appcache/appcache_request_handler.h b/content/browser/appcache/appcache_request_handler.h
index 9c90b29..cf0297b 100644
--- a/content/browser/appcache/appcache_request_handler.h
+++ b/content/browser/appcache/appcache_request_handler.h
@@ -59,8 +59,7 @@ class CONTENT_EXPORT AppCacheRequestHandler
   friend class AppCacheHost;
 
   // Callers should use AppCacheHost::CreateRequestHandler.
-  AppCacheRequestHandler(AppCacheHost* host, ResourceType resource_type,
-                         bool should_reset_appcache);
+  AppCacheRequestHandler(AppCacheHost* host, ResourceType resource_type);
 
   // AppCacheHost::Observer override
   void OnDestructionImminent(AppCacheHost* host) override;
@@ -114,9 +113,6 @@ class CONTENT_EXPORT AppCacheRequestHandler
   // Frame vs subresource vs sharedworker loads are somewhat different.
   ResourceType resource_type_;
 
-  // True if corresponding AppCache group should be resetted before load.
-  bool should_reset_appcache_;
-
   // Subresource requests wait until after cache selection completes.
   bool is_waiting_for_cache_selection_;
 
diff --git a/content/browser/appcache/appcache_request_handler_unittest.cc b/content/browser/appcache/appcache_request_handler_unittest.cc
index ef02bcd..9543f7e 100644
--- a/content/browser/appcache/appcache_request_handler_unittest.cc
+++ b/content/browser/appcache/appcache_request_handler_unittest.cc
@@ -256,8 +256,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+                                               RESOURCE_TYPE_MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     job_ = handler_->MaybeLoadResource(request_.get(),
@@ -305,8 +304,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+                                               RESOURCE_TYPE_MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
@@ -355,8 +353,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+                                               RESOURCE_TYPE_MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
@@ -438,8 +435,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
         GURL("http://blah/fallback-override"), net::DEFAULT_PRIORITY,
         &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+                                               RESOURCE_TYPE_MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
@@ -492,8 +488,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+                                               RESOURCE_TYPE_SUB_RESOURCE));
 
     // We avoid creating handler when possible, sub-resource requests are not
     // subject to retrieval from an appcache when there's no associated cache.
@@ -512,8 +507,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+                                               RESOURCE_TYPE_SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
 
     job_ = handler_->MaybeLoadResource(request_.get(),
@@ -545,8 +539,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+                                               RESOURCE_TYPE_SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
     job_ = handler_->MaybeLoadResource(request_.get(),
                                        request_->context()->network_delegate());
@@ -581,8 +574,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+                                               RESOURCE_TYPE_SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
     job_ = handler_->MaybeLoadResource(request_.get(),
                                        request_->context()->network_delegate());
@@ -615,8 +607,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+                                               RESOURCE_TYPE_SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
     job_ = handler_->MaybeLoadResource(request_.get(),
                                        request_->context()->network_delegate());
@@ -650,8 +641,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+                                               RESOURCE_TYPE_SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
     job_ = handler_->MaybeLoadResource(request_.get(),
                                        request_->context()->network_delegate());
@@ -686,8 +676,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+                                               RESOURCE_TYPE_SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
     job_ = handler_->MaybeLoadResource(request_.get(),
                                        request_->context()->network_delegate());
@@ -717,8 +706,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+                                               RESOURCE_TYPE_SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
 
     backend_impl_->UnregisterHost(1);
@@ -745,8 +733,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+                                               RESOURCE_TYPE_SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
 
     job_ = handler_->MaybeLoadResource(request_.get(),
@@ -779,8 +766,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("ftp://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+                                               RESOURCE_TYPE_SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());  // we could redirect to http (conceivably)
 
     EXPECT_FALSE(handler_->MaybeLoadResource(
@@ -801,8 +787,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+                                               RESOURCE_TYPE_MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     job_ = handler_->MaybeLoadResource(request_.get(),
@@ -848,7 +833,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     AppCacheHost* worker_host = backend_impl_->GetHost(kWorkerHostId);
     worker_host->SelectCacheForWorker(kParentHostId, kMockProcessId);
     handler_.reset(worker_host->CreateRequestHandler(
-        request_.get(), RESOURCE_TYPE_SHARED_WORKER, false));
+        request_.get(), RESOURCE_TYPE_SHARED_WORKER));
     EXPECT_TRUE(handler_.get());
     // Verify that the handler is associated with the parent host.
     EXPECT_EQ(host_, handler_->host_);
@@ -861,7 +846,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     EXPECT_EQ(NULL, backend_impl_->GetHost(kNonExsitingHostId));
     worker_host->SelectCacheForWorker(kNonExsitingHostId, kMockProcessId);
     handler_.reset(worker_host->CreateRequestHandler(
-        request_.get(), RESOURCE_TYPE_SHARED_WORKER, false));
+        request_.get(), RESOURCE_TYPE_SHARED_WORKER));
     EXPECT_FALSE(handler_.get());
 
     TestFinished();
@@ -877,8 +862,7 @@ class AppCacheRequestHandlerTest : public testing::Test {
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_, NULL);
     handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+                                               RESOURCE_TYPE_MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_policy_->can_load_return_value_ = false;
diff --git a/content/browser/appcache/appcache_storage_impl_unittest.cc b/content/browser/appcache/appcache_storage_impl_unittest.cc
index cf779bb..a531bae 100644
--- a/content/browser/appcache/appcache_storage_impl_unittest.cc
+++ b/content/browser/appcache/appcache_storage_impl_unittest.cc
@@ -1775,8 +1775,7 @@ class AppCacheStorageImplTest : public testing::Test {
       AppCacheInterceptor::SetExtraRequestInfo(
           request_.get(), service_.get(),
           backend_->process_id(), host2->host_id(),
-          RESOURCE_TYPE_MAIN_FRAME,
-          false);
+          RESOURCE_TYPE_MAIN_FRAME);
       request_->Start();
     }
 
diff --git a/content/browser/loader/resource_dispatcher_host_impl.cc b/content/browser/loader/resource_dispatcher_host_impl.cc
index 38b28ac..a44d153 100644
--- a/content/browser/loader/resource_dispatcher_host_impl.cc
+++ b/content/browser/loader/resource_dispatcher_host_impl.cc
@@ -1269,8 +1269,7 @@ void ResourceDispatcherHostImpl::BeginRequest(
   // Have the appcache associate its extra info with the request.
   AppCacheInterceptor::SetExtraRequestInfo(
       new_request.get(), filter_->appcache_service(), child_id,
-      request_data.appcache_host_id, request_data.resource_type,
-      request_data.should_reset_appcache);
+      request_data.appcache_host_id, request_data.resource_type);
 
   scoped_ptr<ResourceHandler> handler(
        CreateResourceHandler(
diff --git a/content/browser/loader/resource_dispatcher_host_unittest.cc b/content/browser/loader/resource_dispatcher_host_unittest.cc
index 0e1c63d..3017086 100644
--- a/content/browser/loader/resource_dispatcher_host_unittest.cc
+++ b/content/browser/loader/resource_dispatcher_host_unittest.cc
@@ -139,7 +139,6 @@ static ResourceHostMsg_Request CreateResourceRequest(const char* method,
   request.request_context = 0;
   request.appcache_host_id = kAppCacheNoHostId;
   request.download_to_file = false;
-  request.should_reset_appcache = false;
   request.is_main_frame = true;
   request.parent_is_main_frame = false;
   request.parent_render_frame_id = -1;
diff --git a/content/child/request_info.h b/content/child/request_info.h
index b26e874..e66a26b 100644
--- a/content/child/request_info.h
+++ b/content/child/request_info.h
@@ -80,9 +80,6 @@ struct CONTENT_EXPORT RequestInfo {
   // True if the request should not be handled by the ServiceWorker.
   bool skip_service_worker;
 
-  // True if corresponding AppCache group should be resetted.
-  bool should_reset_appcache;
-
   // The request mode passed to the ServiceWorker.
   FetchRequestMode fetch_request_mode;
 
diff --git a/content/child/resource_dispatcher.cc b/content/child/resource_dispatcher.cc
index 316c609..7590b23 100644
--- a/content/child/resource_dispatcher.cc
+++ b/content/child/resource_dispatcher.cc
@@ -128,7 +128,6 @@ IPCResourceLoaderBridge::IPCResourceLoaderBridge(
   request_.download_to_file = request_info.download_to_file;
   request_.has_user_gesture = request_info.has_user_gesture;
   request_.skip_service_worker = request_info.skip_service_worker;
-  request_.should_reset_appcache = request_info.should_reset_appcache;
   request_.fetch_request_mode = request_info.fetch_request_mode;
   request_.fetch_credentials_mode = request_info.fetch_credentials_mode;
   request_.fetch_request_context_type = request_info.fetch_request_context_type;
diff --git a/content/child/web_url_loader_impl.cc b/content/child/web_url_loader_impl.cc
index 0ed7d5b..00fc99a 100644
--- a/content/child/web_url_loader_impl.cc
+++ b/content/child/web_url_loader_impl.cc
@@ -485,7 +485,6 @@ void WebURLLoaderImpl::Context::Start(const WebURLRequest& request,
   request_info.download_to_file = request.downloadToFile();
   request_info.has_user_gesture = request.hasUserGesture();
   request_info.skip_service_worker = request.skipServiceWorker();
-  request_info.should_reset_appcache = request.shouldResetAppCache();
   request_info.fetch_request_mode = GetFetchRequestMode(request);
   request_info.fetch_credentials_mode = GetFetchCredentialsMode(request);
   request_info.fetch_request_context_type = GetRequestContextType(request);
@@ -580,7 +579,6 @@ bool WebURLLoaderImpl::Context::OnReceivedRedirect(
   new_request.setRequestContext(request_.requestContext());
   new_request.setFrameType(request_.frameType());
   new_request.setSkipServiceWorker(request_.skipServiceWorker());
-  new_request.setShouldResetAppCache(request_.shouldResetAppCache());
   new_request.setFetchRequestMode(request_.fetchRequestMode());
   new_request.setFetchCredentialsMode(request_.fetchCredentialsMode());
 
diff --git a/content/common/resource_messages.h b/content/common/resource_messages.h
index 3abea07..e35a88e 100644
--- a/content/common/resource_messages.h
+++ b/content/common/resource_messages.h
@@ -194,9 +194,6 @@ IPC_STRUCT_BEGIN(ResourceHostMsg_Request)
   // or kAppCacheNoHostId.
   IPC_STRUCT_MEMBER(int, appcache_host_id)
 
-  // True if corresponding AppCache group should be resetted.
-  IPC_STRUCT_MEMBER(bool, should_reset_appcache)
-
   // Indicates which frame (or worker context) the request is being loaded into,
   // or kInvalidServiceWorkerProviderId.
   IPC_STRUCT_MEMBER(int, service_worker_provider_id)