DevTools: Rename InspectorInstrumentation:: namespace into probe::

third_party/WebKit/Source/modules/fetch/FetchManager.cpp

 // Copyright 2014 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.
 
 #include "modules/fetch/FetchManager.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ThrowException.h"
@@ skipping 543 matching lines @@
 void FetchManager::Loader::loadSucceeded() {
   ASSERT(!m_failed);
 
   m_finished = true;
 
   if (document() && document()->frame() && document()->frame()->page() &&
       FetchUtils::isOkStatus(m_responseHttpStatusCode)) {
     document()->frame()->page()->chromeClient().ajaxSucceeded(
         document()->frame());
   }
-  InspectorInstrumentation::didFinishFetch(m_executionContext, this,
-                                           m_request->method(),
-                                           m_request->url().getString());
+  probe::didFinishFetch(m_executionContext, this, m_request->method(),
+                        m_request->url().getString());
   notifyFinished();
 }
 
 void FetchManager::Loader::start() {
   // "1. If |request|'s url contains a Known HSTS Host, modify it per the
   // requirements of the 'URI [sic] Loading and Port Mapping' chapter of HTTP
   // Strict Transport Security."
   // FIXME: Implement this.
 
   // "2. If |request|'s referrer is not none, set |request|'s referrer to the
@@ skipping 92 matching lines @@
 
   // "- Otherwise
   //     Set |request|'s response tainting to |CORS|."
   m_request->setResponseTainting(FetchRequestData::CORSTainting);
   // "The result of performing an HTTP fetch using |request| with the
   // |CORS flag| set."
   performHTTPFetch(true, false);
 }
 
 void FetchManager::Loader::dispose() {
-  InspectorInstrumentation::detachClientRequest(m_executionContext, this);
+  probe::detachClientRequest(m_executionContext, this);
   // Prevent notification
   m_fetchManager = nullptr;
   if (m_loader) {
     m_loader->cancel();
     m_loader = nullptr;
   }
   m_executionContext = nullptr;
 }
 
 void FetchManager::Loader::performBasicFetch() {
@@ skipping 141 matching lines @@
     case WebURLRequest::FetchRequestModeCORSWithForcedPreflight:
       threadableLoaderOptions.crossOriginRequestPolicy = UseAccessControl;
       break;
     case WebURLRequest::FetchRequestModeNavigate:
       // Using DenyCrossOriginRequests here to reduce the security risk.
       // "navigate" request is only available in ServiceWorker.
       threadableLoaderOptions.crossOriginRequestPolicy =
           DenyCrossOriginRequests;
       break;
   }
-  InspectorInstrumentation::willStartFetch(m_executionContext, this);
+  probe::willStartFetch(m_executionContext, this);
   m_loader =
       ThreadableLoader::create(*m_executionContext, this,
                                threadableLoaderOptions, resourceLoaderOptions);
   m_loader->start(request);
 }
 
 // performDataFetch() is almost the same as performHTTPFetch(), except for:
 // - We set AllowCrossOriginRequests to allow requests to data: URLs in
 //   'same-origin' mode.
 // - We reject non-GET method.
@@ skipping 12 matching lines @@
   resourceLoaderOptions.dataBufferingPolicy = DoNotBufferData;
   resourceLoaderOptions.securityOrigin = m_request->origin().get();
 
   ThreadableLoaderOptions threadableLoaderOptions;
   threadableLoaderOptions.contentSecurityPolicyEnforcement =
       ContentSecurityPolicy::shouldBypassMainWorld(m_executionContext)
           ? DoNotEnforceContentSecurityPolicy
           : EnforceContentSecurityPolicy;
   threadableLoaderOptions.crossOriginRequestPolicy = AllowCrossOriginRequests;
 
-  InspectorInstrumentation::willStartFetch(m_executionContext, this);
+  probe::willStartFetch(m_executionContext, this);
   m_loader =
       ThreadableLoader::create(*m_executionContext, this,
                                threadableLoaderOptions, resourceLoaderOptions);
   m_loader->start(request);
 }
 
 void FetchManager::Loader::failed(const String& message) {
   if (m_failed || m_finished)
     return;
   m_failed = true;
   if (m_executionContext->isContextDestroyed())
     return;
   if (!message.isEmpty())
     m_executionContext->addConsoleMessage(
         ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
   if (m_resolver) {
     ScriptState* state = m_resolver->getScriptState();
     ScriptState::Scope scope(state);
     m_resolver->reject(
         V8ThrowException::createTypeError(state->isolate(), "Failed to fetch"));
   }
-  InspectorInstrumentation::didFailFetch(m_executionContext, this);
+  probe::didFailFetch(m_executionContext, this);
   notifyFinished();
 }
 
 void FetchManager::Loader::notifyFinished() {
   if (m_fetchManager)
     m_fetchManager->onLoaderFinished(this);
 }
 
 FetchManager* FetchManager::create(ExecutionContext* executionContext) {
   return new FetchManager(executionContext);
@@ skipping 26 matching lines @@
   m_loaders.erase(loader);
   loader->dispose();
 }
 
 DEFINE_TRACE(FetchManager) {
   visitor->trace(m_loaders);
   ContextLifecycleObserver::trace(visitor);
 }
 
 }  // namespace blink