Replace DCHECK(BrowserThread::CurrentlyOn) with DCHECK_CURRENTLY_ON in extensions.

chrome/browser/extensions/api/messaging/native_message_process_host.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 "chrome/browser/extensions/api/messaging/native_message_process_host.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
@@ skipping 91 matching lines @@
       native_host_name_(native_host_name),
       destination_port_(destination_port),
       launcher_(launcher.Pass()),
       closed_(false),
       process_handle_(base::kNullProcessHandle),
 #if defined(OS_POSIX)
       read_file_(base::kInvalidPlatformFileValue),
 #endif
       read_pending_(false),
       write_pending_(false) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // It's safe to use base::Unretained() here because NativeMessagePort always
   // deletes us on the IO thread.
   content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
       base::Bind(&NativeMessageProcessHost::LaunchHostProcess,
                  base::Unretained(this)));
 }
 
 NativeMessageProcessHost::~NativeMessageProcessHost() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   Close(std::string());
 }
 
 // static
 scoped_ptr<NativeMessageProcessHost> NativeMessageProcessHost::Create(
     gfx::NativeView native_view,
     base::WeakPtr<Client> weak_client_ui,
     const std::string& source_extension_id,
     const std::string& native_host_name,
     int destination_port,
     bool allow_user_level) {
   return CreateWithLauncher(weak_client_ui, source_extension_id,
                             native_host_name, destination_port,
                             NativeProcessLauncher::CreateDefault(
                                 allow_user_level, native_view));
 }
 
 // static
 scoped_ptr<NativeMessageProcessHost>
 NativeMessageProcessHost::CreateWithLauncher(
     base::WeakPtr<Client> weak_client_ui,
     const std::string& source_extension_id,
     const std::string& native_host_name,
     int destination_port,
     scoped_ptr<NativeProcessLauncher> launcher) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   scoped_ptr<NativeMessageProcessHost> process(new NativeMessageProcessHost(
       weak_client_ui, source_extension_id, native_host_name,
       destination_port, launcher.Pass()));
 
   return process.Pass();
 }
 
 void NativeMessageProcessHost::LaunchHostProcess() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   GURL origin(std::string(kExtensionScheme) + "://" + source_extension_id_);
   launcher_->Launch(origin, native_host_name_,
                     base::Bind(&NativeMessageProcessHost::OnHostProcessLaunched,
                                base::Unretained(this)));
 }
 
 void NativeMessageProcessHost::OnHostProcessLaunched(
     NativeProcessLauncher::LaunchResult result,
     base::ProcessHandle process_handle,
     base::File read_file,
     base::File write_file) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   switch (result) {
     case NativeProcessLauncher::RESULT_INVALID_NAME:
       Close(kInvalidNameError);
       return;
     case NativeProcessLauncher::RESULT_NOT_FOUND:
       Close(kNotFoundError);
       return;
     case NativeProcessLauncher::RESULT_FORBIDDEN:
       Close(kForbiddenError);
@@ skipping 23 matching lines @@
   write_stream_.reset(new net::FileStream(
       write_file.TakePlatformFile(),
       base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_ASYNC, NULL,
       task_runner));
 
   WaitRead();
   DoWrite();
 }
 
 void NativeMessageProcessHost::Send(const std::string& json) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (closed_)
     return;
 
   // Allocate new buffer for the message.
   scoped_refptr<net::IOBufferWithSize> buffer =
       new net::IOBufferWithSize(json.size() + kMessageHeaderSize);
 
   // Copy size and content of the message to the buffer.
   COMPILE_ASSERT(sizeof(uint32) == kMessageHeaderSize, incorrect_header_size);
@@ skipping 38 matching lines @@
 #if defined(OS_POSIX)
   base::MessageLoopForIO::current()->WatchFileDescriptor(
     read_file_, false /* persistent */,
     base::MessageLoopForIO::WATCH_READ, &read_watcher_, this);
 #else  // defined(OS_POSIX)
   DoRead();
 #endif  // defined(!OS_POSIX)
 }
 
 void NativeMessageProcessHost::DoRead() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   while (!closed_ && !read_pending_) {
     read_buffer_ = new net::IOBuffer(kReadBufferSize);
     int result = read_stream_->Read(
         read_buffer_.get(),
         kReadBufferSize,
         base::Bind(&NativeMessageProcessHost::OnRead, base::Unretained(this)));
     HandleReadResult(result);
   }
 }
 
 void NativeMessageProcessHost::OnRead(int result) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(read_pending_);
   read_pending_ = false;
 
   HandleReadResult(result);
   WaitRead();
 }
 
 void NativeMessageProcessHost::HandleReadResult(int result) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (closed_)
     return;
 
   if (result > 0) {
     ProcessIncomingData(read_buffer_->data(), result);
   } else if (result == net::ERR_IO_PENDING) {
     read_pending_ = true;
   } else if (result == 0 || result == net::ERR_CONNECTION_RESET) {
     // On Windows we get net::ERR_CONNECTION_RESET for a broken pipe, while on
     // Posix read() returns 0 in that case.
     Close(kNativeHostExited);
   } else {
     LOG(ERROR) << "Error when reading from Native Messaging host: " << result;
     Close(kHostInputOuputError);
   }
 }
 
 void NativeMessageProcessHost::ProcessIncomingData(
     const char* data, int data_size) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   incoming_data_.append(data, data_size);
 
   while (true) {
     if (incoming_data_.size() < kMessageHeaderSize)
       return;
 
     size_t message_size =
         *reinterpret_cast<const uint32*>(incoming_data_.data());
 
@@ skipping 10 matching lines @@
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
         base::Bind(&Client::PostMessageFromNativeProcess, weak_client_ui_,
             destination_port_,
             incoming_data_.substr(kMessageHeaderSize, message_size)));
 
     incoming_data_.erase(0, kMessageHeaderSize + message_size);
   }
 }
 
 void NativeMessageProcessHost::DoWrite() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   while (!write_pending_ && !closed_) {
     if (!current_write_buffer_.get() ||
         !current_write_buffer_->BytesRemaining()) {
       if (write_queue_.empty())
         return;
       current_write_buffer_ = new net::DrainableIOBuffer(
           write_queue_.front().get(), write_queue_.front()->size());
       write_queue_.pop();
     }
 
     int result =
         write_stream_->Write(current_write_buffer_.get(),
                              current_write_buffer_->BytesRemaining(),
                              base::Bind(&NativeMessageProcessHost::OnWritten,
                                         base::Unretained(this)));
     HandleWriteResult(result);
   }
 }
 
 void NativeMessageProcessHost::HandleWriteResult(int result) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (result <= 0) {
     if (result == net::ERR_IO_PENDING) {
       write_pending_ = true;
     } else {
       LOG(ERROR) << "Error when writing to Native Messaging host: " << result;
       Close(kHostInputOuputError);
     }
     return;
   }
 
   current_write_buffer_->DidConsume(result);
 }
 
 void NativeMessageProcessHost::OnWritten(int result) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   DCHECK(write_pending_);
   write_pending_ = false;
 
   HandleWriteResult(result);
   DoWrite();
 }
 
 void NativeMessageProcessHost::Close(const std::string& error_message) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (!closed_) {
     closed_ = true;
     read_stream_.reset();
     write_stream_.reset();
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
         base::Bind(&Client::CloseChannel, weak_client_ui_,
                    destination_port_, error_message));
   }
 
   if (process_handle_ != base::kNullProcessHandle) {
     // Kill the host process if necessary to make sure we don't leave zombies.
     // On OSX base::EnsureProcessTerminated() may block, so we have to post a
     // task on the blocking pool.
 #if defined(OS_MACOSX)
     content::BrowserThread::PostBlockingPoolTask(
         FROM_HERE, base::Bind(&base::EnsureProcessTerminated, process_handle_));
 #else
     base::EnsureProcessTerminated(process_handle_);
 #endif
     process_handle_ = base::kNullProcessHandle;
   }
 }
 
 }  // namespace extensions