favor DCHECK_CURRENTLY_ON for better logs in chrome/browser/chromeos/

chrome/browser/chromeos/drive/file_system/open_file_operation.cc

 // Copyright 2013 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/chromeos/drive/file_system/open_file_operation.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/files/file_path.h"
@@ skipping 32 matching lines @@
       weak_ptr_factory_(this) {
 }
 
 OpenFileOperation::~OpenFileOperation() {
 }
 
 void OpenFileOperation::OpenFile(const base::FilePath& file_path,
                                  OpenMode open_mode,
                                  const std::string& mime_type,
                                  const OpenFileCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   switch (open_mode) {
     case OPEN_FILE:
       // It is not necessary to create a new file even if not exists.
       // So call OpenFileAfterCreateFile directly with FILE_ERROR_OK
       // to skip file creation.
       OpenFileAfterCreateFile(file_path, callback, FILE_ERROR_OK);
       break;
     case CREATE_FILE:
@@ skipping 12 matching lines @@
           base::Bind(&OpenFileOperation::OpenFileAfterCreateFile,
                      weak_ptr_factory_.GetWeakPtr(), file_path, callback));
       break;
   }
 }
 
 void OpenFileOperation::OpenFileAfterCreateFile(
     const base::FilePath& file_path,
     const OpenFileCallback& callback,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     callback.Run(error, base::FilePath(), base::Closure());
     return;
   }
 
   download_operation_->EnsureFileDownloadedByPath(
       file_path,
       ClientContext(USER_INITIATED),
       GetFileContentInitializedCallback(),
       google_apis::GetContentCallback(),
       base::Bind(
           &OpenFileOperation::OpenFileAfterFileDownloaded,
           weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void OpenFileOperation::OpenFileAfterFileDownloaded(
     const OpenFileCallback& callback,
     FileError error,
     const base::FilePath& local_file_path,
     scoped_ptr<ResourceEntry> entry) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (error == FILE_ERROR_OK) {
     DCHECK(entry);
     DCHECK(entry->has_file_specific_info());
     if (entry->file_specific_info().is_hosted_document())
       // No support for opening a hosted document.
       error = FILE_ERROR_INVALID_OPERATION;
   }
 
@@ skipping 18 matching lines @@
                  callback,
                  base::Owned(file_closer)));
 }
 
 void OpenFileOperation::OpenFileAfterOpenForWrite(
     const base::FilePath& local_file_path,
     const std::string& local_id,
     const OpenFileCallback& callback,
     scoped_ptr<base::ScopedClosureRunner>* file_closer,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     callback.Run(error, base::FilePath(), base::Closure());
     return;
   }
 
   ++open_files_[local_id];
   callback.Run(error, local_file_path,
                base::Bind(&OpenFileOperation::CloseFile,
                           weak_ptr_factory_.GetWeakPtr(),
                           local_id,
                           base::Passed(file_closer)));
 }
 
 void OpenFileOperation::CloseFile(
     const std::string& local_id,
     scoped_ptr<base::ScopedClosureRunner> file_closer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_GT(open_files_[local_id], 0);
 
   if (--open_files_[local_id] == 0) {
     // All clients closes this file, so notify to upload the file.
     open_files_.erase(local_id);
     delegate_->OnEntryUpdatedByOperation(ClientContext(USER_INITIATED),
                                          local_id);
 
     // Clients may have enlarged the file. By FreeDiskpSpaceIfNeededFor(0),
     // we try to ensure (0 + the-minimum-safe-margin = 512MB as of now) space.
     blocking_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(
             base::Bind(&internal::FileCache::FreeDiskSpaceIfNeededFor,
                        base::Unretained(cache_),
                        0))));
   }
 }
 
 }  // namespace file_system
 }  // namespace drive