Remove stale-while-revalidate from content and chrome

content/browser/loader/resource_dispatcher_host_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <stddef.h>
 
@@ skipping 26 matching lines @@
 #include "content/browser/appcache/appcache_navigation_handle_core.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/frame_host/navigation_request_info.h"
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/loader/async_resource_handler.h"
-#include "content/browser/loader/async_revalidation_manager.h"
 #include "content/browser/loader/detachable_resource_handler.h"
 #include "content/browser/loader/intercepting_resource_handler.h"
 #include "content/browser/loader/loader_delegate.h"
 #include "content/browser/loader/mime_sniffing_resource_handler.h"
 #include "content/browser/loader/mojo_async_resource_handler.h"
 #include "content/browser/loader/navigation_resource_handler.h"
 #include "content/browser/loader/navigation_resource_throttle.h"
 #include "content/browser/loader/navigation_url_loader_impl_core.h"
 #include "content/browser/loader/null_resource_controller.h"
 #include "content/browser/loader/power_save_block_resource_throttle.h"
@@ skipping 381 matching lines @@
   ANNOTATE_BENIGN_RACE(
       &last_user_gesture_time_,
       "We don't care about the precise value, see http://crbug.com/92889");
 
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&ResourceDispatcherHostImpl::OnInit,
                                      base::Unretained(this)));
 
   update_load_states_timer_.reset(new base::RepeatingTimer());
-
-  // stale-while-revalidate currently doesn't work with browser-side navigation.
-  // Only enable stale-while-revalidate if browser navigation is not enabled.
-  //
-  // TODO(ricea): Make stale-while-revalidate and browser-side navigation work
-  // together. Or disable stale-while-revalidate completely before browser-side
-  // navigation becomes the default. crbug.com/561610
-  if (!IsBrowserSideNavigationEnabled() &&
-      base::FeatureList::IsEnabled(features::kStaleWhileRevalidate)) {
-    async_revalidation_manager_.reset(new AsyncRevalidationManager);
-  }
 }
 
 ResourceDispatcherHostImpl::ResourceDispatcherHostImpl()
     : ResourceDispatcherHostImpl(CreateDownloadHandlerIntercept()) {}
 
 ResourceDispatcherHostImpl::~ResourceDispatcherHostImpl() {
   DCHECK(outstanding_requests_stats_map_.empty());
   DCHECK(g_resource_dispatcher_host);
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   g_resource_dispatcher_host = NULL;
@@ skipping 111 matching lines @@
         loader->GetRequestInfo()->IsDownload() ||
         loader->GetRequestInfo()->is_stream() ||
         (loader->GetRequestInfo()->detachable_handler() &&
          loader->GetRequestInfo()->detachable_handler()->is_detached()) ||
         loader->GetRequestInfo()->requester_info()->IsBrowserSideNavigation() ||
         loader->is_transferring());
   }
 #endif
 
   loaders_to_cancel.clear();
-
-  if (async_revalidation_manager_) {
-    // Cancelling async revalidations should not result in the creation of new
-    // requests. Do it before the CHECKs to ensure this does not happen.
-    async_revalidation_manager_->CancelAsyncRevalidationsForResourceContext(
-        context);
-  }
 }
 
 void ResourceDispatcherHostImpl::ClearLoginDelegateForRequest(
     net::URLRequest* request) {
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
   if (info) {
     ResourceLoader* loader = GetLoader(info->GetGlobalRequestID());
     if (loader)
       loader->ClearLoginDelegate();
   }
@@ skipping 122 matching lines @@
 void ResourceDispatcherHostImpl::DidReceiveRedirect(
     ResourceLoader* loader,
     const GURL& new_url,
     ResourceResponse* response) {
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
   if (delegate_) {
     delegate_->OnRequestRedirected(
         new_url, loader->request(), info->GetContext(), response);
   }
 
-  net::URLRequest* request = loader->request();
-  if (request->response_info().async_revalidation_required) {
-    // Async revalidation is only supported for the first redirect leg.
-    DCHECK_EQ(request->url_chain().size(), 1u);
-    DCHECK(async_revalidation_manager_);
-
-    async_revalidation_manager_->BeginAsyncRevalidation(request,
-                                                        scheduler_.get());
-  }
-
-  // Remove the LOAD_SUPPORT_ASYNC_REVALIDATION flag if it is present.
-  // It is difficult to create a URLRequest with the correct flags and headers
-  // for redirect legs other than the first one. Since stale-while-revalidate in
-  // combination with redirects isn't needed for experimental use, punt on it
-  // for now.
-  // TODO(ricea): Fix this before launching the feature.
-  if (request->load_flags() & net::LOAD_SUPPORT_ASYNC_REVALIDATION) {
-    int new_load_flags =
-        request->load_flags() & ~net::LOAD_SUPPORT_ASYNC_REVALIDATION;
-    request->SetLoadFlags(new_load_flags);
-  }
-
   // Don't notify WebContents observers for requests known to be
   // downloads; they aren't really associated with the Webcontents.
   // Note that not all downloads are known before content sniffing.
   if (info->IsDownload())
     return;
 
   // Notify the observers on the UI thread.
+  net::URLRequest* request = loader->request();
   std::unique_ptr<ResourceRedirectDetails> detail(new ResourceRedirectDetails(
       loader->request(),
       !!request->ssl_info().cert,
       new_url));
   loader_delegate_->DidGetRedirectForResourceRequest(
       info->GetWebContentsGetterForRequest(), std::move(detail));
 }
 
 void ResourceDispatcherHostImpl::DidReceiveResponse(
     ResourceLoader* loader,
     ResourceResponse* response) {
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
   net::URLRequest* request = loader->request();
   if (request->was_fetched_via_proxy() &&
       request->was_fetched_via_spdy() &&
       request->url().SchemeIs(url::kHttpScheme)) {
     scheduler_->OnReceivedSpdyProxiedHttpResponse(
         info->GetChildID(), info->GetRouteID());
   }
 
-  if (request->response_info().async_revalidation_required) {
-    DCHECK(async_revalidation_manager_);
-    async_revalidation_manager_->BeginAsyncRevalidation(request,
-                                                        scheduler_.get());
-  }
-
   ProcessRequestForLinkHeaders(request);
 
   if (delegate_)
     delegate_->OnResponseStarted(request, info->GetContext(), response);
 
   // Don't notify WebContents observers for requests known to be
   // downloads; they aren't really associated with the Webcontents.
   // Note that not all downloads are known before content sniffing.
   if (info->IsDownload())
     return;
@@ skipping 675 matching lines @@
     // Only block image loads, as the attack applies largely to the "src"
     // property of the <img> tag. It is common for web properties to allow
     // untrusted values for <img src>; this is considered a fair thing for an
     // HTML sanitizer to do. Conversely, any HTML sanitizer that didn't
     // filter sources for <script>, <link>, <embed>, <object>, <iframe> tags
     // would be considered vulnerable in and of itself.
     do_not_prompt_for_login = true;
     load_flags |= net::LOAD_DO_NOT_USE_EMBEDDED_IDENTITY;
   }
 
-  bool support_async_revalidation =
-      !is_sync_load && async_revalidation_manager_ &&
-      AsyncRevalidationManager::QualifiesForAsyncRevalidation(request_data);
-
-  if (support_async_revalidation)
-    load_flags |= net::LOAD_SUPPORT_ASYNC_REVALIDATION;
-
   // Sync loads should have maximum priority and should be the only
   // requets that have the ignore limits flag set.
   if (is_sync_load) {
     DCHECK_EQ(request_data.priority, net::MAXIMUM_PRIORITY);
     DCHECK_NE(load_flags & net::LOAD_IGNORE_LIMITS, 0);
   } else {
     DCHECK_EQ(load_flags & net::LOAD_IGNORE_LIMITS, 0);
   }
   new_request->SetLoadFlags(load_flags);
 
   // Make extra info and read footer (contains request ID).
   ResourceRequestInfoImpl* extra_info = new ResourceRequestInfoImpl(
       requester_info, route_id,
       -1,  // frame_tree_node_id
       request_data.origin_pid, request_id, request_data.render_frame_id,
       request_data.is_main_frame, request_data.parent_is_main_frame,
       request_data.resource_type, request_data.transition_type,
       request_data.should_replace_current_entry,
       false,  // is download
       false,  // is stream
       allow_download, request_data.has_user_gesture,
       request_data.enable_load_timing, request_data.enable_upload_progress,
       do_not_prompt_for_login, request_data.referrer_policy,
       request_data.visibility_state, resource_context, report_raw_headers,
       !is_sync_load,
       GetPreviewsState(request_data.previews_state, delegate_, *new_request,
                        resource_context,
                        request_data.resource_type == RESOURCE_TYPE_MAIN_FRAME),
-      support_async_revalidation ? request_data.headers : std::string(),
       request_data.request_body, request_data.initiated_in_secure_context);
   // Request takes ownership.
   extra_info->AssociateWithRequest(new_request.get());
 
   if (new_request->url().SchemeIs(url::kBlobScheme)) {
     // Hang on to a reference to ensure the blob is not released prior
     // to the job being started.
     storage::BlobProtocolHandler::SetRequestedBlobDataHandle(
         new_request.get(), requester_info->blob_storage_context()
                                ->context()
@@ skipping 293 matching lines @@
       download,  // allow_download
       false,     // has_user_gesture
       false,     // enable_load_timing
       false,     // enable_upload_progress
       false,     // do_not_prompt_for_login
       blink::WebReferrerPolicyDefault, blink::WebPageVisibilityStateVisible,
       context,
       false,           // report_raw_headers
       true,            // is_async
       previews_state,  // previews_state
-      std::string(),   // original_headers
       nullptr,         // body
       false);          // initiated_in_secure_context
 }
 
 void ResourceDispatcherHostImpl::OnRenderViewHostCreated(int child_id,
                                                          int route_id) {
   scheduler_->OnClientCreated(child_id, route_id);
 }
 
 void ResourceDispatcherHostImpl::OnRenderViewHostDeleted(int child_id,
@@ skipping 346 matching lines @@
       false,  // is stream
       info.common_params.allow_download, info.begin_params.has_user_gesture,
       true,   // enable_load_timing
       false,  // enable_upload_progress
       false,  // do_not_prompt_for_login
       info.common_params.referrer.policy, info.page_visibility_state,
       resource_context, info.report_raw_headers,
       true,  // is_async
       GetPreviewsState(info.common_params.previews_state, delegate_,
                        *new_request, resource_context, info.is_main_frame),
-      // The original_headers field is for stale-while-revalidate but the
-      // feature doesn't work with PlzNavigate, so it's just a placeholder
-      // here.
-      // TODO(ricea): Make the feature work with stale-while-revalidate
-      // and clean this up.
-      std::string(),  // original_headers
       info.common_params.post_data,
       // TODO(mek): Currently initiated_in_secure_context is only used for
       // subresource requests, so it doesn't matter what value it gets here.
       // If in the future this changes this should be updated to somehow get a
       // meaningful value.
       false);  // initiated_in_secure_context
   extra_info->set_navigation_ui_data(std::move(navigation_ui_data));
 
   // Request takes ownership.
   extra_info->AssociateWithRequest(new_request.get());
@@ skipping 33 matching lines @@
       info.begin_params.mixed_content_context_type,
       appcache_handle_core ? appcache_handle_core->GetAppCacheService()
                            : nullptr,
       -1,  // child_id
       -1,  // route_id
       std::move(handler));
 
   BeginRequestInternal(std::move(new_request), std::move(handler));
 }
 
-void ResourceDispatcherHostImpl::EnableStaleWhileRevalidateForTesting() {
-  if (!async_revalidation_manager_)
-    async_revalidation_manager_.reset(new AsyncRevalidationManager);
-}
-
 void ResourceDispatcherHostImpl::SetLoaderDelegate(
     LoaderDelegate* loader_delegate) {
   loader_delegate_ = loader_delegate;
 }
 
 void ResourceDispatcherHostImpl::OnRenderFrameDeleted(
     const GlobalFrameRoutingId& global_routing_id) {
   CancelRequestsForRoute(global_routing_id);
 }
 
@@ skipping 512 matching lines @@
                                  &throttles);
     if (!throttles.empty()) {
       handler.reset(new ThrottlingResourceHandler(std::move(handler), request,
                                                   std::move(throttles)));
     }
   }
   return handler;
 }
 
 }  // namespace content