DevTools: Rename InspectorInstrumentation:: namespace into probe::

third_party/WebKit/Source/modules/eventsource/EventSource.cpp

 /*
  * Copyright (C) 2009, 2012 Ericsson AB. All rights reserved.
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2011, Code Aurora Forum. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 105 matching lines @@
   source->scheduleInitialConnect();
   return source;
 }
 
 EventSource::~EventSource() {
   DCHECK_EQ(kClosed, m_state);
   DCHECK(!m_loader);
 }
 
 void EventSource::dispose() {
-  InspectorInstrumentation::detachClientRequest(getExecutionContext(), this);
+  probe::detachClientRequest(getExecutionContext(), this);
 }
 
 void EventSource::scheduleInitialConnect() {
   DCHECK_EQ(kConnecting, m_state);
   DCHECK(!m_loader);
 
   m_connectTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void EventSource::connect() {
@@ skipping 35 matching lines @@
   resourceLoaderOptions.allowCredentials =
       (origin->canRequestNoSuborigin(m_currentURL) || m_withCredentials)
           ? AllowStoredCredentials
           : DoNotAllowStoredCredentials;
   resourceLoaderOptions.credentialsRequested =
       m_withCredentials ? ClientRequestedCredentials
                         : ClientDidNotRequestCredentials;
   resourceLoaderOptions.dataBufferingPolicy = DoNotBufferData;
   resourceLoaderOptions.securityOrigin = origin;
 
-  InspectorInstrumentation::willSendEventSourceRequest(&executionContext, this);
-  // InspectorInstrumentation::documentThreadableLoaderStartedLoadingForClient
+  probe::willSendEventSourceRequest(&executionContext, this);
+  // probe::documentThreadableLoaderStartedLoadingForClient
   // will be called synchronously.
   m_loader = ThreadableLoader::create(executionContext, this, options,
                                       resourceLoaderOptions);
   m_loader->start(request);
 }
 
 void EventSource::networkRequestEnded() {
-  InspectorInstrumentation::didFinishEventSourceRequest(getExecutionContext(),
-                                                        this);
+  probe::didFinishEventSourceRequest(getExecutionContext(), this);
 
   m_loader = nullptr;
 
   if (m_state != kClosed)
     scheduleReconnect();
 }
 
 void EventSource::scheduleReconnect() {
   m_state = kConnecting;
   m_connectTimer.startOneShot(m_reconnectDelay / 1000.0, BLINK_FROM_HERE);
@@ skipping 143 matching lines @@
   abortConnectionAttempt();
 }
 
 void EventSource::onMessageEvent(const AtomicString& eventType,
                                  const String& data,
                                  const AtomicString& lastEventId) {
   MessageEvent* e = MessageEvent::create();
   e->initMessageEvent(eventType, false, false, data, m_eventStreamOrigin,
                       lastEventId, 0, nullptr);
 
-  InspectorInstrumentation::willDispatchEventSourceEvent(
-      getExecutionContext(), this, eventType, lastEventId, data);
+  probe::willDispatchEventSourceEvent(getExecutionContext(), this, eventType,
+                                      lastEventId, data);
   dispatchEvent(e);
 }
 
 void EventSource::onReconnectionTimeSet(unsigned long long reconnectionTime) {
   m_reconnectDelay = reconnectionTime;
 }
 
 void EventSource::abortConnectionAttempt() {
   DCHECK_EQ(kConnecting, m_state);
 
   m_loader = nullptr;
   m_state = kClosed;
   networkRequestEnded();
 
   dispatchEvent(Event::create(EventTypeNames::error));
 }
 
 void EventSource::contextDestroyed(ExecutionContext*) {
-  InspectorInstrumentation::detachClientRequest(getExecutionContext(), this);
+  probe::detachClientRequest(getExecutionContext(), this);
   close();
 }
 
 bool EventSource::hasPendingActivity() const {
   return m_state != kClosed;
 }
 
 DEFINE_TRACE(EventSource) {
   visitor->trace(m_parser);
   visitor->trace(m_loader);
   EventTargetWithInlineData::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
   EventSourceParser::Client::trace(visitor);
 }
 
 }  // namespace blink