DevTools: Rename InspectorInstrumentation:: namespace into probe::

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 176 matching lines @@
   // Setting an outgoing referer is only supported in the async code path.
   DCHECK(m_async || request.httpReferrer().isEmpty());
 
   m_sameOriginRequest =
       getSecurityOrigin()->canRequestNoSuborigin(request.url());
   m_requestContext = request.requestContext();
   m_redirectMode = request.fetchRedirectMode();
 
   if (!m_sameOriginRequest &&
       m_options.crossOriginRequestPolicy == DenyCrossOriginRequests) {
-    InspectorInstrumentation::
-        documentThreadableLoaderFailedToStartLoadingForClient(document(),
-                                                              m_client);
+    probe::documentThreadableLoaderFailedToStartLoadingForClient(document(),
+                                                                 m_client);
     ThreadableLoaderClient* client = m_client;
     clear();
     client->didFail(ResourceError(errorDomainBlinkInternal, 0,
                                   request.url().getString(),
                                   "Cross origin requests are not supported."));
     return;
   }
 
   m_requestStartedSeconds = monotonicallyIncreasingTime();
 
@@ skipping 111 matching lines @@
   DCHECK(m_options.crossOriginRequestPolicy == UseAccessControl ||
          request.isExternalRequest());
   DCHECK(m_client);
   DCHECK(!resource());
 
   // Cross-origin requests are only allowed certain registered schemes. We would
   // catch this when checking response headers later, but there is no reason to
   // send a request, preflighted or not, that's guaranteed to be denied.
   if (!SchemeRegistry::shouldTreatURLSchemeAsCORSEnabled(
           request.url().protocol())) {
-    InspectorInstrumentation::
-        documentThreadableLoaderFailedToStartLoadingForClient(document(),
-                                                              m_client);
+    probe::documentThreadableLoaderFailedToStartLoadingForClient(document(),
+                                                                 m_client);
     dispatchDidFailAccessControlCheck(ResourceError(
         errorDomainBlinkInternal, 0, request.url().getString(),
         "Cross origin requests are only supported for protocol schemes: " +
             SchemeRegistry::listOfCORSEnabledURLSchemes() + "."));
     return;
   }
 
   // Non-secure origins may not make "external requests":
   // https://mikewest.github.io/cors-rfc1918/#integration-fetch
   if (!m_loadingContext->isSecureContext() && request.isExternalRequest()) {
@@ skipping 37 matching lines @@
     // 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.setServiceWorkerMode(
         WebURLRequest::ServiceWorkerMode::None);
 
-    bool shouldForcePreflight =
-        request.isExternalRequest() ||
-        InspectorInstrumentation::shouldForceCORSPreflight(document());
+    bool shouldForcePreflight = request.isExternalRequest() ||
+                                probe::shouldForceCORSPreflight(document());
     bool canSkipPreflight =
         CrossOriginPreflightResultCache::shared().canSkipPreflight(
             getSecurityOrigin()->toString(), crossOriginRequest.url(),
             effectiveAllowCredentials(), crossOriginRequest.httpMethod(),
             crossOriginRequest.httpHeaderFields());
     if (canSkipPreflight && !shouldForcePreflight) {
       prepareCrossOriginRequest(crossOriginRequest);
       loadRequest(crossOriginRequest, crossOriginOptions);
     } else {
       ResourceRequest preflightRequest =
@@ skipping 145 matching lines @@
   if (m_corsRedirectLimit <= 0) {
     ThreadableLoaderClient* client = m_client;
     clear();
     client->didFailRedirectCheck();
     return false;
   }
 
   --m_corsRedirectLimit;
 
   if (document() && document()->frame()) {
-    InspectorInstrumentation::didReceiveCORSRedirectResponse(
+    probe::didReceiveCORSRedirectResponse(
         document()->frame(), resource->identifier(),
         document()->frame()->loader().documentLoader(), redirectResponse,
         resource);
   }
 
   String accessControlErrorDescription;
 
   CrossOriginAccessControl::RedirectStatus redirectStatus =
       CrossOriginAccessControl::checkRedirectLocation(request.url());
   bool allowRedirect =
@@ skipping 202 matching lines @@
 void DocumentThreadableLoader::reportResponseReceived(
     unsigned long identifier,
     const ResourceResponse& response) {
   LocalFrame* frame = document() ? document()->frame() : nullptr;
   if (!frame)
     return;
   TRACE_EVENT1(
       "devtools.timeline", "ResourceReceiveResponse", "data",
       InspectorReceiveResponseEvent::data(identifier, frame, response));
   DocumentLoader* loader = frame->loader().documentLoader();
-  InspectorInstrumentation::didReceiveResourceResponse(
-      frame, identifier, loader, response, resource());
+  probe::didReceiveResourceResponse(frame, identifier, loader, response,
+                                    resource());
   frame->console().reportResourceResponseReceived(loader, identifier, response);
 }
 
 void DocumentThreadableLoader::handleResponse(
     unsigned long identifier,
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   DCHECK(m_client);
 
   if (!m_actualRequest.isNull()) {
@@ skipping 213 matching lines @@
   ResourceFetcher* fetcher = m_loadingContext->getResourceFetcher();
   if (request.requestContext() == WebURLRequest::RequestContextVideo ||
       request.requestContext() == WebURLRequest::RequestContextAudio)
     setResource(RawResource::fetchMedia(newRequest, fetcher));
   else if (request.requestContext() == WebURLRequest::RequestContextManifest)
     setResource(RawResource::fetchManifest(newRequest, fetcher));
   else
     setResource(RawResource::fetch(newRequest, fetcher));
 
   if (!resource()) {
-    InspectorInstrumentation::
-        documentThreadableLoaderFailedToStartLoadingForClient(document(),
-                                                              m_client);
+    probe::documentThreadableLoaderFailedToStartLoadingForClient(document(),
+                                                                 m_client);
     ThreadableLoaderClient* client = m_client;
     clear();
     // setResource() might call notifyFinished() and thus clear()
     // synchronously, and in such cases ThreadableLoaderClient is already
     // notified and |client| is null.
     if (!client)
       return;
     client->didFail(ResourceError(errorDomainBlinkInternal, 0,
                                   request.url().getString(),
                                   "Failed to start loading."));
     return;
   }
 
   if (resource()->isLoading()) {
     unsigned long identifier = resource()->identifier();
-    InspectorInstrumentation::documentThreadableLoaderStartedLoadingForClient(
+    probe::documentThreadableLoaderStartedLoadingForClient(
         document(), identifier, m_client);
   } else {
-    InspectorInstrumentation::
-        documentThreadableLoaderFailedToStartLoadingForClient(document(),
-                                                              m_client);
+    probe::documentThreadableLoaderFailedToStartLoadingForClient(document(),
+                                                                 m_client);
   }
 }
 
 void DocumentThreadableLoader::loadRequestSync(
     const ResourceRequest& request,
     ResourceLoaderOptions resourceLoaderOptions) {
   FetchRequest fetchRequest(request, m_options.initiator,
                             resourceLoaderOptions);
   if (m_options.crossOriginRequestPolicy == AllowCrossOriginRequests)
     fetchRequest.setOriginRestriction(FetchRequest::NoOriginRestriction);
   Resource* resource = RawResource::fetchSynchronously(
       fetchRequest, m_loadingContext->getResourceFetcher());
   ResourceResponse response =
       resource ? resource->response() : ResourceResponse();
   unsigned long identifier = resource
                                  ? resource->identifier()
                                  : std::numeric_limits<unsigned long>::max();
   ResourceError error = resource ? resource->resourceError() : ResourceError();
 
-  InspectorInstrumentation::documentThreadableLoaderStartedLoadingForClient(
-      document(), identifier, m_client);
+  probe::documentThreadableLoaderStartedLoadingForClient(document(), identifier,
+                                                         m_client);
   ThreadableLoaderClient* client = m_client;
 
   if (!resource) {
     m_client = nullptr;
     client->didFail(error);
     return;
   }
 
   const KURL& requestURL = request.url();
 
@@ skipping 81 matching lines @@
 }
 
 DEFINE_TRACE(DocumentThreadableLoader) {
   visitor->trace(m_resource);
   visitor->trace(m_loadingContext);
   ThreadableLoader::trace(visitor);
   RawResourceClient::trace(visitor);
 }
 
 }  // namespace blink