DevTools: Rename InspectorInstrumentation:: namespace into probe::

third_party/WebKit/Source/modules/websockets/DocumentWebSocketChannel.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * 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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 188 matching lines @@
   }
   m_handle->connect(url, protocols, m_loadingContext->getSecurityOrigin(),
                     m_loadingContext->firstPartyForCookies(),
                     m_loadingContext->userAgent(), this);
 
   flowControlIfNecessary();
   TRACE_EVENT_INSTANT1("devtools.timeline", "WebSocketCreate",
                        TRACE_EVENT_SCOPE_THREAD, "data",
                        InspectorWebSocketCreateEvent::data(
                            document(), m_identifier, url, protocol));
-  InspectorInstrumentation::didCreateWebSocket(document(), m_identifier, url,
-                                               protocol);
+  probe::didCreateWebSocket(document(), m_identifier, url, protocol);
   return true;
 }
 
 void DocumentWebSocketChannel::send(const CString& message) {
   NETWORK_DVLOG(1) << this << " sendText(" << message << ")";
   // FIXME: Change the inspector API to show the entire message instead
   // of individual frames.
-  InspectorInstrumentation::didSendWebSocketFrame(
-      document(), m_identifier, WebSocketFrame::OpCodeText, true,
-      message.data(), message.length());
+  probe::didSendWebSocketFrame(document(), m_identifier,
+                               WebSocketFrame::OpCodeText, true, message.data(),
+                               message.length());
   m_messages.append(new Message(message));
   processSendQueue();
 }
 
 void DocumentWebSocketChannel::send(PassRefPtr<BlobDataHandle> blobDataHandle) {
   NETWORK_DVLOG(1) << this << " sendBlob(" << blobDataHandle->uuid() << ", "
                    << blobDataHandle->type() << ", " << blobDataHandle->size()
                    << ")";
   // FIXME: Change the inspector API to show the entire message instead
   // of individual frames.
   // FIXME: We can't access the data here.
   // Since Binary data are not displayed in Inspector, this does not
   // affect actual behavior.
-  InspectorInstrumentation::didSendWebSocketFrame(
-      document(), m_identifier, WebSocketFrame::OpCodeBinary, true, "", 0);
+  probe::didSendWebSocketFrame(document(), m_identifier,
+                               WebSocketFrame::OpCodeBinary, true, "", 0);
   m_messages.append(new Message(std::move(blobDataHandle)));
   processSendQueue();
 }
 
 void DocumentWebSocketChannel::send(const DOMArrayBuffer& buffer,
                                     unsigned byteOffset,
                                     unsigned byteLength) {
   NETWORK_DVLOG(1) << this << " sendArrayBuffer(" << buffer.data() << ", "
                    << byteOffset << ", " << byteLength << ")";
   // FIXME: Change the inspector API to show the entire message instead
   // of individual frames.
-  InspectorInstrumentation::didSendWebSocketFrame(
+  probe::didSendWebSocketFrame(
       document(), m_identifier, WebSocketFrame::OpCodeBinary, true,
       static_cast<const char*>(buffer.data()) + byteOffset, byteLength);
   // buffer.slice copies its contents.
   // FIXME: Reduce copy by sending the data immediately when we don't need to
   // queue the data.
   m_messages.append(
       new Message(buffer.slice(byteOffset, byteOffset + byteLength)));
   processSendQueue();
 }
 
 void DocumentWebSocketChannel::sendTextAsCharVector(
     std::unique_ptr<Vector<char>> data) {
   NETWORK_DVLOG(1) << this << " sendTextAsCharVector("
                    << static_cast<void*>(data.get()) << ", " << data->size()
                    << ")";
   // FIXME: Change the inspector API to show the entire message instead
   // of individual frames.
-  InspectorInstrumentation::didSendWebSocketFrame(
-      document(), m_identifier, WebSocketFrame::OpCodeText, true, data->data(),
-      data->size());
+  probe::didSendWebSocketFrame(document(), m_identifier,
+                               WebSocketFrame::OpCodeText, true, data->data(),
+                               data->size());
   m_messages.append(new Message(std::move(data), MessageTypeTextAsCharVector));
   processSendQueue();
 }
 
 void DocumentWebSocketChannel::sendBinaryAsCharVector(
     std::unique_ptr<Vector<char>> data) {
   NETWORK_DVLOG(1) << this << " sendBinaryAsCharVector("
                    << static_cast<void*>(data.get()) << ", " << data->size()
                    << ")";
   // FIXME: Change the inspector API to show the entire message instead
   // of individual frames.
-  InspectorInstrumentation::didSendWebSocketFrame(
-      document(), m_identifier, WebSocketFrame::OpCodeBinary, true,
-      data->data(), data->size());
+  probe::didSendWebSocketFrame(document(), m_identifier,
+                               WebSocketFrame::OpCodeBinary, true, data->data(),
+                               data->size());
   m_messages.append(
       new Message(std::move(data), MessageTypeBinaryAsCharVector));
   processSendQueue();
 }
 
 void DocumentWebSocketChannel::close(int code, const String& reason) {
   NETWORK_DVLOG(1) << this << " close(" << code << ", " << reason << ")";
   DCHECK(m_handle);
   unsigned short codeToSend = static_cast<unsigned short>(
       code == CloseEventCodeNotSpecified ? CloseEventCodeNoStatusRcvd : code);
   m_messages.append(new Message(codeToSend, reason));
   processSendQueue();
 }
 
 void DocumentWebSocketChannel::fail(const String& reason,
                                     MessageLevel level,
                                     std::unique_ptr<SourceLocation> location) {
   NETWORK_DVLOG(1) << this << " fail(" << reason << ")";
   // m_handle and m_client can be null here.
 
   connection_handle_for_scheduler_.reset();
 
   if (document()) {
-    InspectorInstrumentation::didReceiveWebSocketFrameError(
-        document(), m_identifier, reason);
+    probe::didReceiveWebSocketFrameError(document(), m_identifier, reason);
     const String message = "WebSocket connection to '" + m_url.elidedString() +
                            "' failed: " + reason;
     document()->addConsoleMessage(ConsoleMessage::create(
         JSMessageSource, level, message, std::move(location)));
   }
 
   if (m_client)
     m_client->didError();
   // |reason| is only for logging and should not be provided for scripts,
   // hence close reason must be empty.
   handleDidClose(false, CloseEventCodeAbnormalClosure, String());
   // handleDidClose may delete this object.
 }
 
 void DocumentWebSocketChannel::disconnect() {
   NETWORK_DVLOG(1) << this << " disconnect()";
   if (m_identifier) {
     TRACE_EVENT_INSTANT1(
         "devtools.timeline", "WebSocketDestroy", TRACE_EVENT_SCOPE_THREAD,
         "data", InspectorWebSocketEvent::data(document(), m_identifier));
-    InspectorInstrumentation::didCloseWebSocket(document(), m_identifier);
+    probe::didCloseWebSocket(document(), m_identifier);
   }
   connection_handle_for_scheduler_.reset();
   abortAsyncOperations();
   m_handle.reset();
   m_client = nullptr;
   m_identifier = 0;
 }
 
 DocumentWebSocketChannel::Message::Message(const CString& text)
     : type(MessageTypeText), text(text) {}
@@ skipping 154 matching lines @@
   NETWORK_DVLOG(1) << this << " didStartOpeningHandshake(" << handle << ")";
 
   DCHECK(m_handle);
   DCHECK_EQ(handle, m_handle.get());
 
   if (document()) {
     TRACE_EVENT_INSTANT1(
         "devtools.timeline", "WebSocketSendHandshakeRequest",
         TRACE_EVENT_SCOPE_THREAD, "data",
         InspectorWebSocketEvent::data(document(), m_identifier));
-    InspectorInstrumentation::willSendWebSocketHandshakeRequest(
-        document(), m_identifier, request.get());
+    probe::willSendWebSocketHandshakeRequest(document(), m_identifier,
+                                             request.get());
   }
   m_handshakeRequest = request;
 }
 
 void DocumentWebSocketChannel::didFinishOpeningHandshake(
     WebSocketHandle* handle,
     const WebSocketHandshakeResponse* response) {
   NETWORK_DVLOG(1) << this << " didFinishOpeningHandshake(" << handle << ")";
 
   DCHECK(m_handle);
   DCHECK_EQ(handle, m_handle.get());
 
   if (document()) {
     TRACE_EVENT_INSTANT1(
         "devtools.timeline", "WebSocketReceiveHandshakeResponse",
         TRACE_EVENT_SCOPE_THREAD, "data",
         InspectorWebSocketEvent::data(document(), m_identifier));
-    InspectorInstrumentation::didReceiveWebSocketHandshakeResponse(
+    probe::didReceiveWebSocketHandshakeResponse(
         document(), m_identifier, m_handshakeRequest.get(), response);
   }
   m_handshakeRequest.clear();
 }
 
 void DocumentWebSocketChannel::didFail(WebSocketHandle* handle,
                                        const String& message) {
   NETWORK_DVLOG(1) << this << " didFail(" << handle << ", " << String(message)
                    << ")";
 
@@ skipping 45 matching lines @@
     return;
   }
   // FIXME: Change the inspector API to show the entire message instead
   // of individual frames.
   WebSocketFrame::OpCode opcode = m_receivingMessageTypeIsText
                                       ? WebSocketFrame::OpCodeText
                                       : WebSocketFrame::OpCodeBinary;
   WebSocketFrame frame(opcode, m_receivingMessageData.data(),
                        m_receivingMessageData.size(), WebSocketFrame::Final);
   if (document()) {
-    InspectorInstrumentation::didReceiveWebSocketFrame(
-        document(), m_identifier, frame.opCode, frame.masked, frame.payload,
-        frame.payloadLength);
+    probe::didReceiveWebSocketFrame(document(), m_identifier, frame.opCode,
+                                    frame.masked, frame.payload,
+                                    frame.payloadLength);
   }
   if (m_receivingMessageTypeIsText) {
     String message = m_receivingMessageData.isEmpty()
                          ? emptyString
                          : String::fromUTF8(m_receivingMessageData.data(),
                                             m_receivingMessageData.size());
     m_receivingMessageData.clear();
     if (message.isNull()) {
       failAsError("Could not decode a text frame as UTF-8.");
       // failAsError may delete this object.
@@ skipping 19 matching lines @@
 
   DCHECK(m_handle);
   DCHECK_EQ(handle, m_handle.get());
 
   m_handle.reset();
 
   if (m_identifier && document()) {
     TRACE_EVENT_INSTANT1(
         "devtools.timeline", "WebSocketDestroy", TRACE_EVENT_SCOPE_THREAD,
         "data", InspectorWebSocketEvent::data(document(), m_identifier));
-    InspectorInstrumentation::didCloseWebSocket(document(), m_identifier);
+    probe::didCloseWebSocket(document(), m_identifier);
     m_identifier = 0;
   }
 
   handleDidClose(wasClean, code, reason);
   // handleDidClose may delete this object.
 }
 
 void DocumentWebSocketChannel::didReceiveFlowControl(WebSocketHandle* handle,
                                                      int64_t quota) {
   NETWORK_DVLOG(1) << this << " didReceiveFlowControl(" << handle << ", "
@@ skipping 49 matching lines @@
   WebSocketChannel::trace(visitor);
 }
 
 std::ostream& operator<<(std::ostream& ostream,
                          const DocumentWebSocketChannel* channel) {
   return ostream << "DocumentWebSocketChannel "
                  << static_cast<const void*>(channel);
 }
 
 }  // namespace blink