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

chrome/browser/chromeos/drive/fileapi/fileapi_worker.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 "chrome/browser/chromeos/drive/fileapi/fileapi_worker.h"
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 122 matching lines @@
 
   callback.Run(base::File::FILE_OK, file_info, local_path, scope_out_policy);
 }
 
 // Runs |callback| with arguments converted from |error| and |local_path|.
 void RunCreateWritableSnapshotFileCallback(
     const CreateWritableSnapshotFileCallback& callback,
     FileError error,
     const base::FilePath& local_path,
     const base::Closure& close_callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   callback.Run(FileErrorToBaseFileError(error), local_path, close_callback);
 }
 
 // Runs |callback| with |file|.
 void RunOpenFileCallback(const OpenFileCallback& callback,
                          const base::Closure& close_callback,
                          base::File file) {
   callback.Run(file.Pass(), close_callback);
 }
 
 base::File OpenFile(const base::FilePath& path, int flags) {
   return base::File(path, flags);
 }
 
 // Part of OpenFile(). Called after FileSystem::OpenFile().
 void OpenFileAfterFileSystemOpenFile(int file_flags,
                                      const OpenFileCallback& callback,
                                      FileError error,
                                      const base::FilePath& local_path,
                                      const base::Closure& close_callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (error != FILE_ERROR_OK) {
     callback.Run(base::File(FileErrorToBaseFileError(error)), base::Closure());
     return;
   }
 
   // Here, the file should be at |local_path|, but there may be timing issue.
   // Because the file is managed by Drive file system, so, in order to avoid
   // unexpected file creation, CREATE, OPEN_ALWAYS and CREATE_ALWAYS are
   // translated into OPEN or OPEN_TRUNCATED, here. Keep OPEN and OPEN_TRUNCATED
@@ skipping 12 matching lines @@
   bool posted = base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(), FROM_HERE,
       base::Bind(&OpenFile, local_path, file_flags),
       base::Bind(&RunOpenFileCallback, callback, close_callback));
   DCHECK(posted);
 }
 
 }  // namespace
 
 FileSystemInterface* GetFileSystemFromUrl(const storage::FileSystemURL& url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   Profile* profile = util::ExtractProfileFromPath(url.path());
   return profile ? util::GetFileSystemByProfile(profile) : NULL;
 }
 
 void RunFileSystemCallback(
     const FileSystemGetter& file_system_getter,
     const base::Callback<void(FileSystemInterface*)>& callback,
     const base::Closure& on_error_callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   FileSystemInterface* file_system = file_system_getter.Run();
 
   if (!file_system) {
     if (!on_error_callback.is_null())
       on_error_callback.Run();
     return;
   }
 
   callback.Run(file_system);
 }
 
 void GetFileInfo(const base::FilePath& file_path,
                  const GetFileInfoCallback& callback,
                  FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_system->GetResourceEntry(
       file_path,
       base::Bind(&RunGetFileInfoCallback, callback));
 }
 
 void Copy(const base::FilePath& src_file_path,
           const base::FilePath& dest_file_path,
           bool preserve_last_modified,
           const StatusCallback& callback,
           FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_system->Copy(src_file_path, dest_file_path, preserve_last_modified,
                     base::Bind(&RunStatusCallbackByFileError, callback));
 }
 
 void Move(const base::FilePath& src_file_path,
           const base::FilePath& dest_file_path,
           const StatusCallback& callback,
           FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_system->Move(src_file_path, dest_file_path,
                     base::Bind(&RunStatusCallbackByFileError, callback));
 }
 
 void CopyInForeignFile(const base::FilePath& src_foreign_file_path,
                        const base::FilePath& dest_file_path,
                        const StatusCallback& callback,
                        FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_system->TransferFileFromLocalToRemote(
       src_foreign_file_path, dest_file_path,
       base::Bind(&RunStatusCallbackByFileError, callback));
 }
 
 void ReadDirectory(const base::FilePath& file_path,
                    const ReadDirectoryCallback& callback,
                    FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_system->ReadDirectory(
       file_path,
       base::Bind(&RunReadDirectoryCallbackWithEntries, callback),
       base::Bind(&RunReadDirectoryCallbackOnCompletion, callback));
 }
 
 void Remove(const base::FilePath& file_path,
             bool is_recursive,
             const StatusCallback& callback,
             FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_system->Remove(file_path, is_recursive,
                       base::Bind(&RunStatusCallbackByFileError, callback));
 }
 
 void CreateDirectory(const base::FilePath& file_path,
                      bool is_exclusive,
                      bool is_recursive,
                      const StatusCallback& callback,
                      FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_system->CreateDirectory(
       file_path, is_exclusive, is_recursive,
       base::Bind(&RunStatusCallbackByFileError, callback));
 }
 
 void CreateFile(const base::FilePath& file_path,
                 bool is_exclusive,
                 const StatusCallback& callback,
                 FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_system->CreateFile(file_path, is_exclusive,
                           std::string(),  // no mime type; guess from file_path
                           base::Bind(&RunStatusCallbackByFileError, callback));
 }
 
 void Truncate(const base::FilePath& file_path,
               int64 length,
               const StatusCallback& callback,
               FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_system->TruncateFile(
       file_path, length,
       base::Bind(&RunStatusCallbackByFileError, callback));
 }
 
 void CreateSnapshotFile(const base::FilePath& file_path,
                         const CreateSnapshotFileCallback& callback,
                         FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_system->GetFile(file_path,
                        base::Bind(&RunCreateSnapshotFileCallback, callback));
 }
 
 void CreateWritableSnapshotFile(
     const base::FilePath& file_path,
     const CreateWritableSnapshotFileCallback& callback,
     FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_system->OpenFile(
       file_path,
       OPEN_FILE,
       std::string(),  // no mime type; we never create a new file here.
       base::Bind(&RunCreateWritableSnapshotFileCallback, callback));
 }
 
 void OpenFile(const base::FilePath& file_path,
               int file_flags,
               const OpenFileCallback& callback,
               FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Returns an error if any unsupported flag is found.
   if (file_flags & ~(base::File::FLAG_OPEN |
                      base::File::FLAG_CREATE |
                      base::File::FLAG_OPEN_ALWAYS |
                      base::File::FLAG_CREATE_ALWAYS |
                      base::File::FLAG_OPEN_TRUNCATED |
                      base::File::FLAG_READ |
                      base::File::FLAG_WRITE |
                      base::File::FLAG_WRITE_ATTRIBUTES |
@@ skipping 10 matching lines @@
       file_path, GetOpenMode(file_flags),
       std::string(),  // no mime type; guess from file_path
       base::Bind(&OpenFileAfterFileSystemOpenFile, file_flags, callback));
 }
 
 void TouchFile(const base::FilePath& file_path,
                const base::Time& last_access_time,
                const base::Time& last_modified_time,
                const StatusCallback& callback,
                FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_system->TouchFile(file_path, last_access_time, last_modified_time,
                          base::Bind(&RunStatusCallbackByFileError, callback));
 
 }
 
 }  // namespace fileapi_internal
 }  // namespace drive