DevTools: Rename InspectorInstrumentation:: namespace into probe::

third_party/WebKit/Source/core/xmlhttprequest/XMLHttpRequest.cpp

 /*
  *  Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
  *  Copyright (C) 2005-2007 Alexey Proskuryakov <ap@webkit.org>
  *  Copyright (C) 2007, 2008 Julien Chaffraix <jchaffraix@webkit.org>
  *  Copyright (C) 2008, 2011 Google Inc. All rights reserved.
  *  Copyright (C) 2012 Intel Corporation
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
@@ skipping 688 matching lines @@
     }
   }
 
   m_error = false;
   return true;
 }
 
 void XMLHttpRequest::send(
     const ArrayBufferOrArrayBufferViewOrBlobOrDocumentOrStringOrFormData& body,
     ExceptionState& exceptionState) {
-  InspectorInstrumentation::willSendXMLHttpOrFetchNetworkRequest(
-      getExecutionContext(), url());
+  probe::willSendXMLHttpOrFetchNetworkRequest(getExecutionContext(), url());
 
   if (body.isNull()) {
     send(String(), exceptionState);
     return;
   }
 
   if (body.isArrayBuffer()) {
     send(body.getAsArrayBuffer(), exceptionState);
     return;
   }
@@ skipping 208 matching lines @@
   DCHECK(getExecutionContext());
   ExecutionContext& executionContext = *getExecutionContext();
 
   m_sendFlag = true;
   // The presence of upload event listeners forces us to use preflighting
   // because POSTing to an URL that does not permit cross origin requests should
   // look exactly like POSTing to an URL that does not respond at all.
   // Also, only async requests support upload progress events.
   bool uploadEvents = false;
   if (m_async) {
-    InspectorInstrumentation::asyncTaskScheduled(
-        &executionContext, "XMLHttpRequest.send", this, true);
+    probe::asyncTaskScheduled(&executionContext, "XMLHttpRequest.send", this,
+                              true);
     dispatchProgressEvent(EventTypeNames::loadstart, 0, 0);
     // Event handler could have invalidated this send operation,
     // (re)setting the send flag and/or initiating another send
     // operation; leave quietly if so.
     if (!m_sendFlag || m_loader)
       return;
     if (httpBody && m_upload) {
       uploadEvents = m_upload->hasEventListeners();
       m_upload->dispatchEvent(
           ProgressEvent::create(EventTypeNames::loadstart, false, 0, 0));
@@ skipping 32 matching lines @@
   request.setRequestContext(WebURLRequest::RequestContextXMLHttpRequest);
   request.setFetchCredentialsMode(
       includeCredentials ? WebURLRequest::FetchCredentialsModeInclude
                          : WebURLRequest::FetchCredentialsModeSameOrigin);
   request.setServiceWorkerMode(m_isIsolatedWorld
                                    ? WebURLRequest::ServiceWorkerMode::None
                                    : WebURLRequest::ServiceWorkerMode::All);
   request.setExternalRequestStateFromRequestorAddressSpace(
       executionContext.securityContext().addressSpace());
 
-  InspectorInstrumentation::willLoadXHR(
-      &executionContext, this, this, m_method, m_url, m_async,
-      httpBody ? httpBody->deepCopy() : nullptr, m_requestHeaders,
-      includeCredentials);
+  probe::willLoadXHR(&executionContext, this, this, m_method, m_url, m_async,
+                     httpBody ? httpBody->deepCopy() : nullptr,
+                     m_requestHeaders, includeCredentials);
 
   if (httpBody) {
     DCHECK_NE(m_method, HTTPNames::GET);
     DCHECK_NE(m_method, HTTPNames::HEAD);
     request.setHTTPBody(std::move(httpBody));
   }
 
   if (m_requestHeaders.size() > 0)
     request.addHTTPHeaderFields(m_requestHeaders);
 
@@ skipping 80 matching lines @@
       DCHECK(!m_loader);
       handleRequestError(0, EventTypeNames::abort, receivedLength,
                          expectedLength);
     }
   }
   if (m_state == kDone)
     m_state = kUnsent;
 }
 
 void XMLHttpRequest::dispose() {
-  InspectorInstrumentation::detachClientRequest(getExecutionContext(), this);
+  probe::detachClientRequest(getExecutionContext(), this);
   m_progressEventThrottle->stop();
   internalAbort();
 }
 
 void XMLHttpRequest::clearVariablesForLoading() {
   if (m_blobLoader) {
     m_blobLoader->cancel();
     m_blobLoader = nullptr;
   }
 
@@ skipping 79 matching lines @@
                                            long long receivedLength,
                                            long long expectedLength) {
   bool lengthComputable =
       expectedLength > 0 && receivedLength <= expectedLength;
   unsigned long long loaded =
       receivedLength >= 0 ? static_cast<unsigned long long>(receivedLength) : 0;
   unsigned long long total =
       lengthComputable ? static_cast<unsigned long long>(expectedLength) : 0;
 
   ExecutionContext* context = getExecutionContext();
-  InspectorInstrumentation::AsyncTask asyncTask(context, this, m_async);
+  probe::AsyncTask asyncTask(context, this, m_async);
   m_progressEventThrottle->dispatchProgressEvent(type, lengthComputable, loaded,
                                                  total);
   if (m_async && type == EventTypeNames::loadend)
-    InspectorInstrumentation::asyncTaskCanceled(context, this);
+    probe::asyncTaskCanceled(context, this);
 }
 
 void XMLHttpRequest::dispatchProgressEventFromSnapshot(
     const AtomicString& type) {
   dispatchProgressEvent(type, m_receivedLength,
                         m_response.expectedContentLength());
 }
 
 void XMLHttpRequest::handleNetworkError() {
   NETWORK_DVLOG(1) << this << " handleNetworkError()";
@@ skipping 22 matching lines @@
   handleRequestError(AbortError, EventTypeNames::abort, receivedLength,
                      expectedLength);
 }
 
 void XMLHttpRequest::handleRequestError(ExceptionCode exceptionCode,
                                         const AtomicString& type,
                                         long long receivedLength,
                                         long long expectedLength) {
   NETWORK_DVLOG(1) << this << " handleRequestError()";
 
-  InspectorInstrumentation::didFailXHRLoading(getExecutionContext(), this, this,
-                                              m_method, m_url);
+  probe::didFailXHRLoading(getExecutionContext(), this, this, m_method, m_url);
 
   m_sendFlag = false;
   if (!m_async) {
     DCHECK(exceptionCode);
     m_state = kDone;
     m_exceptionCode = exceptionCode;
     return;
   }
 
   // With m_error set, the state change steps are minimal: any pending
@@ skipping 353 matching lines @@
 
   if (!m_responseDocument->wellFormed())
     m_responseDocument = nullptr;
 
   m_parsedResponse = true;
 
   endLoading();
 }
 
 void XMLHttpRequest::endLoading() {
-  InspectorInstrumentation::didFinishXHRLoading(getExecutionContext(), this,
-                                                this, m_method, m_url);
+  probe::didFinishXHRLoading(getExecutionContext(), this, this, m_method,
+                             m_url);
 
   if (m_loader) {
     // Set |m_error| in order to suppress the cancel notification (see
     // XMLHttpRequest::didFail).
     AutoReset<bool> scope(&m_error, true);
     m_loader.release()->cancel();
   }
 
   m_sendFlag = false;
   changeState(kDone);
@@ skipping 228 matching lines @@
   visitor->traceWrappers(m_responseDocument);
   visitor->traceWrappers(m_responseArrayBuffer);
   XMLHttpRequestEventTarget::traceWrappers(visitor);
 }
 
 std::ostream& operator<<(std::ostream& ostream, const XMLHttpRequest* xhr) {
   return ostream << "XMLHttpRequest " << static_cast<const void*>(xhr);
 }
 
 }  // namespace blink