Rename SkipServiceWorker to ServiceWorkerMode

third_party/WebKit/Source/core/loader/DocumentThreadableLoader.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 83 matching lines @@
     WeakPtrFactory<EmptyDataReader> m_factory;
   };
 
   std::unique_ptr<Reader> obtainReader(Client* client) override {
     return WTF::makeUnique<EmptyDataReader>(client);
   }
   const char* debugName() const override { return "EmptyDataHandle"; }
 };
 
 // No-CORS requests are allowed for all these contexts, and plugin contexts with
-// private permission when we set skipServiceWorker flag in PepperURLLoaderHost.
+// private permission when we set ServiceWorkerMode to None in
+// PepperURLLoaderHost.
 bool IsNoCORSAllowedContext(
     WebURLRequest::RequestContext context,
-    WebURLRequest::SkipServiceWorker skipServiceWorker) {
+    WebURLRequest::ServiceWorkerMode serviceWorkerMode) {
   switch (context) {
     case WebURLRequest::RequestContextAudio:
     case WebURLRequest::RequestContextVideo:
     case WebURLRequest::RequestContextObject:
     case WebURLRequest::RequestContextFavicon:
     case WebURLRequest::RequestContextImage:
     case WebURLRequest::RequestContextScript:
     case WebURLRequest::RequestContextWorker:
     case WebURLRequest::RequestContextSharedWorker:
       return true;
     case WebURLRequest::RequestContextPlugin:
-      return skipServiceWorker == WebURLRequest::SkipServiceWorker::All;
+      return serviceWorkerMode == WebURLRequest::ServiceWorkerMode::None;
     default:
       return false;
   }
 }
 
 }  // namespace
 
 // Max number of CORS redirects handled in DocumentThreadableLoader. Same number
 // as net/url_request/url_request.cc, and same number as
 // https://fetch.spec.whatwg.org/#concept-http-fetch, Step 4.
@@ skipping 111 matching lines @@
       case UseAccessControl:
         if (m_options.preflightPolicy == ForcePreflight) {
           newRequest.setFetchRequestMode(
               WebURLRequest::FetchRequestModeCORSWithForcedPreflight);
         } else {
           newRequest.setFetchRequestMode(WebURLRequest::FetchRequestModeCORS);
         }
         break;
       case AllowCrossOriginRequests:
         SECURITY_CHECK(IsNoCORSAllowedContext(m_requestContext,
-                                              request.skipServiceWorker()));
+                                              request.getServiceWorkerMode()));
         newRequest.setFetchRequestMode(WebURLRequest::FetchRequestModeNoCORS);
         break;
     }
     if (m_resourceLoaderOptions.allowCredentials == AllowStoredCredentials) {
       newRequest.setFetchCredentialsMode(
           WebURLRequest::FetchCredentialsModeInclude);
     } else {
       newRequest.setFetchCredentialsMode(
           WebURLRequest::FetchCredentialsModeSameOrigin);
     }
   }
 
   // We assume that ServiceWorker is skipped for sync requests and unsupported
   // protocol requests by content/ code.
   if (m_async &&
-      request.skipServiceWorker() == WebURLRequest::SkipServiceWorker::None &&
+      request.getServiceWorkerMode() == WebURLRequest::ServiceWorkerMode::All &&
       SchemeRegistry::shouldTreatURLSchemeAsAllowingServiceWorkers(
           request.url().protocol()) &&
       m_document->fetcher()->isControlledByServiceWorker()) {
     if (newRequest.fetchRequestMode() == WebURLRequest::FetchRequestModeCORS ||
         newRequest.fetchRequestMode() ==
             WebURLRequest::FetchRequestModeCORSWithForcedPreflight) {
       m_fallbackRequestForServiceWorker = ResourceRequest(request);
       // m_fallbackRequestForServiceWorker is used when a regular controlling
       // service worker doesn't handle a cross origin request. When this happens
       // we still want to give foreign fetch a chance to handle the request, so
       // only skip the controlling service worker for the fallback request. This
       // is currently safe because of http://crbug.com/604084 the
       // wasFallbackRequiredByServiceWorker flag is never set when foreign fetch
       // handled a request.
-      m_fallbackRequestForServiceWorker.setSkipServiceWorker(
-          WebURLRequest::SkipServiceWorker::Controlling);
+      m_fallbackRequestForServiceWorker.setServiceWorkerMode(
+          WebURLRequest::ServiceWorkerMode::Foreign);
     }
     loadRequest(newRequest, m_resourceLoaderOptions);
     return;
   }
 
   dispatchInitialRequest(newRequest);
 }
 
 void DocumentThreadableLoader::dispatchInitialRequest(
     const ResourceRequest& request) {
@@ skipping 73 matching lines @@
   // example, referrer. We need to accept them. For security, we must reject
   // forbidden headers/methods at the point we accept user's input. Not here.
   if (!request.isExternalRequest() &&
       ((m_options.preflightPolicy == ConsiderPreflight &&
         FetchUtils::isSimpleOrForbiddenRequest(request.httpMethod(),
                                                request.httpHeaderFields())) ||
        m_options.preflightPolicy == PreventPreflight)) {
     prepareCrossOriginRequest(crossOriginRequest);
     loadRequest(crossOriginRequest, crossOriginOptions);
   } else {
-    // Explicitly set the SkipServiceWorker flag here. Although the page is not
-    // controlled by a SW at this point, a new SW may be controlling the page
-    // when this request gets sent later. We should not send the actual request
-    // to the SW. https://crbug.com/604583
+    // Explicitly set the ServiceWorkerMode to None here. Although the page is
+    // not controlled by a SW at this point, a new SW may be controlling the
+    // page when this request gets sent later. We should not send the actual
+    // request to the SW. https://crbug.com/604583
     // Similarly we don't want any requests that could involve a CORS preflight
     // to get intercepted by a foreign fetch service worker, even if we have the
     // result of the preflight cached already. https://crbug.com/674370
-    crossOriginRequest.setSkipServiceWorker(
-        WebURLRequest::SkipServiceWorker::All);
+    crossOriginRequest.setServiceWorkerMode(
+        WebURLRequest::ServiceWorkerMode::None);
 
     bool shouldForcePreflight =
         request.isExternalRequest() ||
         InspectorInstrumentation::shouldForceCORSPreflight(m_document);
     bool canSkipPreflight =
         CrossOriginPreflightResultCache::shared().canSkipPreflight(
             getSecurityOrigin()->toString(), crossOriginRequest.url(),
             effectiveAllowCredentials(), crossOriginRequest.httpMethod(),
             crossOriginRequest.httpHeaderFields());
     if (canSkipPreflight && !shouldForcePreflight) {
@@ skipping 753 matching lines @@
 }
 
 DEFINE_TRACE(DocumentThreadableLoader) {
   visitor->trace(m_resource);
   visitor->trace(m_document);
   ThreadableLoader::trace(visitor);
   RawResourceClient::trace(visitor);
 }
 
 }  // namespace blink