Rename LOG() to LOG_INFO()

Source/WebCore/platform/network/chromium/SocketStreamHandle.cpp

 /*
  * Copyright (C) 2009, 2012 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 41 matching lines @@
 }
 
 SocketStreamHandleInternal::~SocketStreamHandleInternal()
 {
     m_handle = 0;
 }
 
 void SocketStreamHandleInternal::connect(const KURL& url)
 {
     m_socket = adoptPtr(WebKit::Platform::current()->createSocketStreamHandle());
-    LOG(Network, "connect");
+    LOG_INFO(Network, "connect");
     ASSERT(m_socket);
     ASSERT(m_handle);
     if (m_handle->m_client)
         m_handle->m_client->willOpenSocketStream(m_handle);
     m_socket->connect(url, this);
 }
 
 int SocketStreamHandleInternal::send(const char* data, int len)
 {
-    LOG(Network, "send len=%d", len);
+    LOG_INFO(Network, "send len=%d", len);
     // FIXME: |m_socket| should not be null here, but it seems that there is the
     // case. We should figure out such a path and fix it rather than checking
     // null here.
     if (!m_socket) {
-        LOG(Network, "m_socket is null when sending. It should not be.");
+        LOG_INFO(Network, "m_socket is null when sending. It should not be.");
         return 0;
     }
     if (m_pendingAmountSent + len > m_maxPendingSendAllowed)
         len = m_maxPendingSendAllowed - m_pendingAmountSent;
 
     if (len <= 0)
         return len;
     WebKit::WebData webdata(data, len);
     if (m_socket->send(webdata)) {
         m_pendingAmountSent += len;
-        LOG(Network, "sent");
+        LOG_INFO(Network, "sent");
         return len;
     }
-    LOG(Network, "busy. buffering");
+    LOG_INFO(Network, "busy. buffering");
     return 0;
 }
 
 void SocketStreamHandleInternal::close()
 {
-    LOG(Network, "close");
+    LOG_INFO(Network, "close");
     if (m_socket)
         m_socket->close();
 }
 
 void SocketStreamHandleInternal::didOpenStream(WebKit::WebSocketStreamHandle* socketHandle, int maxPendingSendAllowed)
 {
-    LOG(Network, "SocketStreamHandleInternal::didOpen %d",
+    LOG_INFO(Network, "SocketStreamHandleInternal::didOpen %d",
         maxPendingSendAllowed);
     ASSERT(maxPendingSendAllowed > 0);
     if (m_handle && m_socket) {
         ASSERT(socketHandle == m_socket.get());
         m_maxPendingSendAllowed = maxPendingSendAllowed;
         m_handle->m_state = SocketStreamHandleBase::Open;
         if (m_handle->m_client) {
             m_handle->m_client->didOpenSocketStream(m_handle);
             return;
         }
     }
-    LOG(Network, "no m_handle or m_socket?");
+    LOG_INFO(Network, "no m_handle or m_socket?");
 }
 
 void SocketStreamHandleInternal::didSendData(WebKit::WebSocketStreamHandle* socketHandle, int amountSent)
 {
-    LOG(Network, "SocketStreamHandleInternal::didSendData %d", amountSent);
+    LOG_INFO(Network, "SocketStreamHandleInternal::didSendData %d", amountSent);
     ASSERT(amountSent > 0);
     if (m_handle && m_socket) {
         ASSERT(socketHandle == m_socket.get());
         m_pendingAmountSent -= amountSent;
         ASSERT(m_pendingAmountSent >= 0);
         m_handle->sendPendingData();
     }
 }
 
 void SocketStreamHandleInternal::didReceiveData(WebKit::WebSocketStreamHandle* socketHandle, const WebKit::WebData& data)
 {
-    LOG(Network, "didReceiveData");
+    LOG_INFO(Network, "didReceiveData");
     if (m_handle && m_socket) {
         ASSERT(socketHandle == m_socket.get());
         if (m_handle->m_client)
             m_handle->m_client->didReceiveSocketStreamData(m_handle, data.data(), data.size());
     }
 }
 
 void SocketStreamHandleInternal::didClose(WebKit::WebSocketStreamHandle* socketHandle)
 {
-    LOG(Network, "didClose");
+    LOG_INFO(Network, "didClose");
     if (m_handle && m_socket) {
         ASSERT(socketHandle == m_socket.get());
         m_socket.clear();
         SocketStreamHandle* h = m_handle;
         m_handle = 0;
         if (h->m_client)
             h->m_client->didCloseSocketStream(h);
     }
 }
 
 void SocketStreamHandleInternal::didFail(WebKit::WebSocketStreamHandle* socketHandle, const WebKit::WebSocketStreamError& err)
 {
-    LOG(Network, "didFail");
+    LOG_INFO(Network, "didFail");
     if (m_handle && m_socket) {
         ASSERT(socketHandle == m_socket.get());
         m_socket.clear();
         SocketStreamHandle* h = m_handle;
         m_handle = 0;
         if (h->m_client)
             h->m_client->didCloseSocketStream(h); // didFail(h, err);
     }
 }
 
@@ skipping 39 matching lines @@
 }
 
 void SocketStreamHandle::receivedRequestToContinueWithoutCredential(const AuthenticationChallenge& challenge)
 {
     notImplemented();
 }
 
 }  // namespace WebCore
 
 #endif  // ENABLE(WEB_SOCKETS)