Replace DCHECK(BrowserThread::CurrentlyOn) with DCHECK_CURRENTLY_ON in content/browser/renderer_hos…

content/browser/renderer_host/pepper/pepper_tcp_socket.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/pepper/pepper_tcp_socket.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 60 matching lines @@
   DCHECK(manager);
 }
 
 PepperTCPSocket::~PepperTCPSocket() {
   // Make sure no further callbacks from socket_.
   if (socket_)
     socket_->Disconnect();
 }
 
 void PepperTCPSocket::Connect(const std::string& host, uint16_t port) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (connection_state_ != BEFORE_CONNECT) {
     SendConnectACKError(PP_ERROR_FAILED);
     return;
   }
 
   connection_state_ = CONNECT_IN_PROGRESS;
   net::HostResolver::RequestInfo request_info(net::HostPortPair(host, port));
   resolver_.reset(
       new net::SingleRequestHostResolver(manager_->GetHostResolver()));
   int net_result = resolver_->Resolve(
       request_info,
       net::DEFAULT_PRIORITY,
       &address_list_,
       base::Bind(&PepperTCPSocket::OnResolveCompleted, base::Unretained(this)),
       net::BoundNetLog());
   if (net_result != net::ERR_IO_PENDING)
     OnResolveCompleted(net_result);
 }
 
 void PepperTCPSocket::ConnectWithNetAddress(
     const PP_NetAddress_Private& net_addr) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (connection_state_ != BEFORE_CONNECT) {
     SendConnectACKError(PP_ERROR_FAILED);
     return;
   }
 
   net::IPAddressNumber address;
   int port;
   if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(net_addr, &address,
                                                      &port)) {
     SendConnectACKError(PP_ERROR_ADDRESS_INVALID);
     return;
   }
 
   // Copy the single IPEndPoint to address_list_.
   address_list_.clear();
   address_list_.push_back(net::IPEndPoint(address, port));
   connection_state_ = CONNECT_IN_PROGRESS;
   StartConnect(address_list_);
 }
 
 void PepperTCPSocket::SSLHandshake(
     const std::string& server_name,
     uint16_t server_port,
     const std::vector<std::vector<char> >& trusted_certs,
     const std::vector<std::vector<char> >& untrusted_certs) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Allow to do SSL handshake only if currently the socket has been connected
   // and there isn't pending read or write.
   // IsConnected() includes the state that SSL handshake has been finished and
   // therefore isn't suitable here.
   if (connection_state_ != CONNECTED || read_buffer_.get() ||
       write_buffer_base_.get() || write_buffer_.get()) {
     SendSSLHandshakeACK(false);
     return;
   }
@@ skipping 18 matching lines @@
   }
 
   int net_result = socket_->Connect(
       base::Bind(&PepperTCPSocket::OnSSLHandshakeCompleted,
                  base::Unretained(this)));
   if (net_result != net::ERR_IO_PENDING)
     OnSSLHandshakeCompleted(net_result);
 }
 
 void PepperTCPSocket::Read(int32 bytes_to_read) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!IsConnected() || end_of_file_reached_) {
     SendReadACKError(PP_ERROR_FAILED);
     return;
   }
 
   if (read_buffer_.get()) {
     SendReadACKError(PP_ERROR_INPROGRESS);
     return;
   }
 
   if (bytes_to_read <= 0 ||
       bytes_to_read > ppapi::TCPSocketShared::kMaxReadSize) {
     SendReadACKError(PP_ERROR_BADARGUMENT);
     return;
   }
 
   read_buffer_ = new net::IOBuffer(bytes_to_read);
   int net_result = socket_->Read(
       read_buffer_.get(),
       bytes_to_read,
       base::Bind(&PepperTCPSocket::OnReadCompleted, base::Unretained(this)));
   if (net_result != net::ERR_IO_PENDING)
     OnReadCompleted(net_result);
 }
 
 void PepperTCPSocket::Write(const std::string& data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!IsConnected()) {
     SendWriteACKError(PP_ERROR_FAILED);
     return;
   }
 
   if (write_buffer_base_.get() || write_buffer_.get()) {
     SendWriteACKError(PP_ERROR_INPROGRESS);
     return;
   }
 
   size_t data_size = data.size();
   if (data_size == 0 ||
       data_size > static_cast<size_t>(ppapi::TCPSocketShared::kMaxWriteSize)) {
     SendWriteACKError(PP_ERROR_BADARGUMENT);
     return;
   }
 
   write_buffer_base_ = new net::IOBuffer(data_size);
   memcpy(write_buffer_base_->data(), data.data(), data_size);
   write_buffer_ =
       new net::DrainableIOBuffer(write_buffer_base_.get(), data_size);
   DoWrite();
 }
 
 void PepperTCPSocket::SetOption(PP_TCPSocket_Option name,
                                 const ppapi::SocketOptionData& value) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!IsConnected() || IsSsl()) {
     SendSetOptionACK(PP_ERROR_FAILED);
     return;
   }
 
   net::TCPClientSocket* tcp_socket =
       static_cast<net::TCPClientSocket*>(socket_.get());
   DCHECK(tcp_socket);
 
@@ skipping 281 matching lines @@
 
   int net_result = socket_->Write(
       write_buffer_.get(),
       write_buffer_->BytesRemaining(),
       base::Bind(&PepperTCPSocket::OnWriteCompleted, base::Unretained(this)));
   if (net_result != net::ERR_IO_PENDING)
     OnWriteCompleted(net_result);
 }
 
 }  // namespace content