favor DCHECK_CURRENTLY_ON for better logs in content/browser/[f-p]*

content/browser/gpu/browser_gpu_memory_buffer_manager.cc

 // Copyright 2014 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/gpu/browser_gpu_memory_buffer_manager.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 108 matching lines @@
   return request.result.Pass();
 }
 
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess(
     const gfx::Size& size,
     gfx::GpuMemoryBuffer::Format format,
     gfx::GpuMemoryBuffer::Usage usage,
     base::ProcessHandle child_process_handle,
     int child_client_id,
     const AllocationCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   gfx::GpuMemoryBufferId new_id = g_next_gpu_memory_buffer_id.GetNext();
 
   BufferMap& buffers = clients_[child_client_id];
   DCHECK(buffers.find(new_id) == buffers.end());
 
   // Fallback to shared memory buffer if |format| and |usage| are not supported
   // by factory.
   if (!gpu_memory_buffer_factory_host_->IsGpuMemoryBufferConfigurationSupported(
           format, usage)) {
@@ skipping 35 matching lines @@
     uint32 sync_point) {
   static_cast<GpuMemoryBufferImpl*>(buffer)
       ->set_destruction_sync_point(sync_point);
 }
 
 void BrowserGpuMemoryBufferManager::ChildProcessDeletedGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     base::ProcessHandle child_process_handle,
     int child_client_id,
     uint32 sync_point) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(clients_.find(child_client_id) != clients_.end());
 
   BufferMap& buffers = clients_[child_client_id];
 
   BufferMap::iterator buffer_it = buffers.find(id);
   if (buffer_it == buffers.end()) {
     LOG(ERROR) << "Invalid GpuMemoryBuffer ID for child process.";
     return;
   }
 
@@ skipping 11 matching lines @@
                                                             child_client_id,
                                                             sync_point);
   }
 
   buffers.erase(buffer_it);
 }
 
 void BrowserGpuMemoryBufferManager::ProcessRemoved(
     base::ProcessHandle process_handle,
     int client_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ClientMap::iterator client_it = clients_.find(client_id);
   if (client_it == clients_.end())
     return;
 
   for (auto &buffer_it : client_it->second) {
     // This might happen if buffer is currenlty in the process of being
     // allocated. The buffer will in that case be cleaned up when allocation
     // completes.
     if (buffer_it.second == gfx::EMPTY_BUFFER)
@@ skipping 18 matching lines @@
   gpu_memory_buffer_factory_host_->CreateGpuMemoryBuffer(
       g_next_gpu_memory_buffer_id.GetNext(), request->size, request->format,
       request->usage, request->client_id, request->surface_id,
       base::Bind(&BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedOnIO,
                  base::Unretained(this), base::Unretained(request)));
 }
 
 void BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedOnIO(
     AllocateGpuMemoryBufferRequest* request,
     const gfx::GpuMemoryBufferHandle& handle) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Early out if factory failed to allocate the buffer.
   if (handle.is_null()) {
     request->event.Signal();
     return;
   }
 
   DCHECK_NE(handle.type, gfx::SHARED_MEMORY_BUFFER);
   request->result = GpuMemoryBufferImpl::CreateFromHandle(
       handle,
@@ skipping 12 matching lines @@
     uint32 sync_point) {
   gpu_memory_buffer_factory_host_->DestroyGpuMemoryBuffer(id,
                                                           client_id,
                                                           sync_point);
 }
 
 void BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedForChildProcess(
     int child_client_id,
     const AllocationCallback& callback,
     const gfx::GpuMemoryBufferHandle& handle) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ClientMap::iterator client_it = clients_.find(child_client_id);
 
   // This can happen if the child process is removed while the buffer is being
   // allocated.
   if (client_it == clients_.end()) {
     if (!handle.is_null()) {
       gpu_memory_buffer_factory_host_->DestroyGpuMemoryBuffer(
           handle.id, child_client_id, 0);
     }
@@ skipping 17 matching lines @@
   DCHECK_NE(handle.type, gfx::SHARED_MEMORY_BUFFER);
 
   // Store the type of this buffer so it can be cleaned up if the child
   // process is removed.
   buffer_it->second = handle.type;
 
   callback.Run(handle);
 }
 
 }  // namespace content