Removes MessageLoop::Type checks in favor of IsCurrent on MessageLoops.

net/socket_stream/socket_stream.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.
 //
 // TODO(ukai): code is similar with http_network_transaction.cc.  We should
 //   think about ways to share code, if possible.
 
 #include "net/socket_stream/socket_stream.h"
 
 #include <set>
@@ skipping 93 matching lines @@
       io_callback_(base::Bind(&SocketStream::OnIOCompleted,
                               base::Unretained(this))),
       read_buf_(NULL),
       current_write_buf_(NULL),
       waiting_for_write_completion_(false),
       closing_(false),
       server_closed_(false),
       metrics_(new SocketStreamMetrics(url)) {
   DCHECK(base::MessageLoop::current())
       << "The current base::MessageLoop must exist";
-  DCHECK_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type())
+  DCHECK(base::MessageLoopForIO::IsCurrent())
       << "The current base::MessageLoop must be TYPE_IO";
   DCHECK(delegate_);
 }
 
 SocketStream::UserData* SocketStream::GetUserData(
     const void* key) const {
   UserDataMap::const_iterator found = user_data_.find(key);
   if (found != user_data_.end())
     return found->second.get();
   return NULL;
@@ skipping 38 matching lines @@
     privacy_mode_ = enable ? kPrivacyModeEnabled : kPrivacyModeDisabled;
     // Disable Channel ID if privacy mode is enabled.
     if (enable)
       server_ssl_config_.channel_id_enabled = false;
   }
 }
 
 void SocketStream::Connect() {
   DCHECK(base::MessageLoop::current())
       << "The current base::MessageLoop must exist";
-  DCHECK_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type())
+  DCHECK(base::MessageLoopForIO::IsCurrent())
       << "The current base::MessageLoop must be TYPE_IO";
   if (context_) {
     context_->ssl_config_service()->GetSSLConfig(&server_ssl_config_);
     proxy_ssl_config_ = server_ssl_config_;
   }
   CheckPrivacyMode();
 
   DCHECK_EQ(next_state_, STATE_NONE);
 
   AddRef();  // Released in Finish()
@@ skipping 12 matching lines @@
   for (PendingDataQueue::const_iterator iter = pending_write_bufs_.begin();
        iter != pending_write_bufs_.end();
        ++iter)
     total_size += (*iter)->size();
   return total_size;
 }
 
 bool SocketStream::SendData(const char* data, int len) {
   DCHECK(base::MessageLoop::current())
       << "The current base::MessageLoop must exist";
-  DCHECK_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type())
+  DCHECK(base::MessageLoopForIO::IsCurrent())
       << "The current base::MessageLoop must be TYPE_IO";
   DCHECK_GT(len, 0);
 
   if (!connection_->socket() ||
       !connection_->socket()->IsConnected() || next_state_ == STATE_NONE) {
     return false;
   }
 
   int total_buffered_bytes = len;
   if (current_write_buf_.get()) {
@@ skipping 26 matching lines @@
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&SocketStream::DoLoop, this, OK));
   }
 
   return true;
 }
 
 void SocketStream::Close() {
   DCHECK(base::MessageLoop::current())
       << "The current base::MessageLoop must exist";
-  DCHECK_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type())
+  DCHECK(base::MessageLoopForIO::IsCurrent())
       << "The current base::MessageLoop must be TYPE_IO";
   // If next_state_ is STATE_NONE, the socket was not opened, or already
   // closed.  So, return immediately.
   // Otherwise, it might call Finish() more than once, so breaks balance
   // of AddRef() and Release() in Connect() and Finish(), respectively.
   if (next_state_ == STATE_NONE)
     return;
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&SocketStream::DoClose, this));
 }
 
 void SocketStream::RestartWithAuth(const AuthCredentials& credentials) {
   DCHECK(base::MessageLoop::current())
       << "The current base::MessageLoop must exist";
-  DCHECK_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type())
+  DCHECK(base::MessageLoopForIO::IsCurrent())
       << "The current base::MessageLoop must be TYPE_IO";
   DCHECK(proxy_auth_controller_.get());
   if (!connection_->socket()) {
     DVLOG(1) << "Socket is closed before restarting with auth.";
     return;
   }
 
   proxy_auth_controller_->ResetAuth(credentials);
 
   base::MessageLoop::current()->PostTask(
@@ skipping 72 matching lines @@
   if (next_state_ == STATE_READ_WRITE && !current_write_buf_.get())
     DoLoop(ERR_ABORTED);
 
   // In other next_state_, we'll wait for callback of other APIs, such as
   // ResolveProxy().
 }
 
 void SocketStream::Finish(int result) {
   DCHECK(base::MessageLoop::current())
       << "The current base::MessageLoop must exist";
-  DCHECK_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type())
+  DCHECK(base::MessageLoopForIO::IsCurrent())
       << "The current base::MessageLoop must be TYPE_IO";
   DCHECK_LE(result, OK);
   if (result == OK)
     result = ERR_CONNECTION_CLOSED;
   DCHECK_EQ(next_state_, STATE_NONE);
   DVLOG(1) << "Finish result=" << ErrorToString(result);
 
   metrics_->OnClose();
 
   if (result != ERR_CONNECTION_CLOSED && delegate_)
@@ skipping 964 matching lines @@
       context_->transport_security_state()->GetDomainState(url_.host(),
           SSLConfigService::IsSNIAvailable(context_->ssl_config_service()),
           &domain_state) &&
       domain_state.ShouldSSLErrorsBeFatal();
 
   delegate_->OnSSLCertificateError(this, ssl_info, fatal);
   return ERR_IO_PENDING;
 }
 
 }  // namespace net