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

chrome/browser/chromeos/extensions/file_manager/private_api_file_system.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/extensions/file_manager/private_api_file_system.h"
 
 #include <sys/statvfs.h>
 #include <set>
 
 #include "base/posix/eintr_wrapper.h"
@@ skipping 67 matching lines @@
     // The filesystem seems not supporting statvfs(). Assume it to be a commonly
     // used bound 255, and log the failure.
     LOG(ERROR) << "Cannot statvfs() the name length limit for: " << path;
     return 255;
   }
   return stat.f_namemax;
 }
 
 // Returns EventRouter for the |profile_id| if available.
 file_manager::EventRouter* GetEventRouterByProfileId(void* profile_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // |profile_id| needs to be checked with ProfileManager::IsValidProfile
   // before using it.
   Profile* profile = reinterpret_cast<Profile*>(profile_id);
   if (!g_browser_process->profile_manager()->IsValidProfile(profile))
     return NULL;
 
   return file_manager::EventRouterFactory::GetForProfile(profile);
 }
 
 // Notifies the copy progress to extensions via event router.
 void NotifyCopyProgress(
     void* profile_id,
     storage::FileSystemOperationRunner::OperationID operation_id,
     storage::FileSystemOperation::CopyProgressType type,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url,
     int64 size) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   file_manager::EventRouter* event_router =
       GetEventRouterByProfileId(profile_id);
   if (event_router) {
     event_router->OnCopyProgress(
         operation_id, type,
         source_url.ToGURL(), destination_url.ToGURL(), size);
   }
 }
 
 // Callback invoked periodically on progress update of Copy().
 void OnCopyProgress(
     void* profile_id,
     storage::FileSystemOperationRunner::OperationID* operation_id,
     storage::FileSystemOperation::CopyProgressType type,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url,
     int64 size) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&NotifyCopyProgress,
                  profile_id, *operation_id, type,
                  source_url, destination_url, size));
 }
 
 // Notifies the copy completion to extensions via event router.
 void NotifyCopyCompletion(
     void* profile_id,
     storage::FileSystemOperationRunner::OperationID operation_id,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url,
     base::File::Error error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   file_manager::EventRouter* event_router =
       GetEventRouterByProfileId(profile_id);
   if (event_router)
     event_router->OnCopyCompleted(
         operation_id,
         source_url.ToGURL(), destination_url.ToGURL(), error);
 }
 
 // Callback invoked upon completion of Copy() (regardless of succeeded or
 // failed).
 void OnCopyCompleted(
     void* profile_id,
     storage::FileSystemOperationRunner::OperationID* operation_id,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url,
     base::File::Error error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&NotifyCopyCompletion,
                  profile_id, *operation_id,
                  source_url, destination_url, error));
 }
 
 // Starts the copy operation via FileSystemOperationRunner.
 storage::FileSystemOperationRunner::OperationID StartCopyOnIOThread(
     void* profile_id,
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Note: |operation_id| is owned by the callback for
   // FileSystemOperationRunner::Copy(). It is always called in the next message
   // loop or later, so at least during this invocation it should alive.
   storage::FileSystemOperationRunner::OperationID* operation_id =
       new storage::FileSystemOperationRunner::OperationID;
   *operation_id = file_system_context->operation_runner()->Copy(
       source_url,
       destination_url,
       storage::FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED,
       base::Bind(&OnCopyProgress, profile_id, base::Unretained(operation_id)),
       base::Bind(&OnCopyCompleted,
                  profile_id,
                  base::Owned(operation_id),
                  source_url,
                  destination_url));
   return *operation_id;
 }
 
 void OnCopyCancelled(base::File::Error error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // We just ignore the status if the copy is actually cancelled or not,
   // because failing cancellation means the operation is not running now.
   DLOG_IF(WARNING, error != base::File::FILE_OK)
       << "Failed to cancel copy: " << error;
 }
 
 // Cancels the running copy operation identified by |operation_id|.
 void CancelCopyOnIOThread(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     storage::FileSystemOperationRunner::OperationID operation_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   file_system_context->operation_runner()->Cancel(
       operation_id, base::Bind(&OnCopyCancelled));
 }
 
 // Converts a status code to a bool value and calls the |callback| with it.
 void StatusCallbackToResponseCallback(
     const base::Callback<void(bool)>& callback,
     base::File::Error result) {
   callback.Run(result == base::File::FILE_OK);
 }
 
 // Calls a response callback (on the UI thread) with a file content hash
 // computed on the IO thread.
 void ComputeChecksumRespondOnUIThread(
     const base::Callback<void(const std::string&)>& callback,
     const std::string& hash) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(callback, hash));
 }
 
 // Calls a response callback on the UI thread.
 void GetFileMetadataRespondOnUIThread(
     const storage::FileSystemOperation::GetMetadataCallback& callback,
     base::File::Error result,
     const base::File::Info& file_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(callback, result, file_info));
 }
 
 }  // namespace
 
 ExtensionFunction::ResponseAction
 FileManagerPrivateEnableExternalFileSchemeFunction::Run() {
   ChildProcessSecurityPolicy::GetInstance()->GrantScheme(
       render_view_host()->GetProcess()->GetID(), content::kExternalFileScheme);
@@ skipping 39 matching lines @@
                                           file_system_url.virtual_path());
       content::ChildProcessSecurityPolicy::GetInstance()
           ->GrantCreateReadWriteFile(render_view_host()->GetProcess()->GetID(),
                                      file_system_url.path());
     }
   }
   return RespondNow(NoArguments());
 }
 
 void FileWatchFunctionBase::Respond(bool success) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   SetResult(new base::FundamentalValue(success));
   SendResponse(success);
 }
 
 bool FileWatchFunctionBase::RunAsync() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!render_view_host() || !render_view_host()->GetProcess())
     return false;
 
   // First param is url of a file to watch.
   std::string url;
   if (!args_->GetString(0, &url) || url.empty())
     return false;
 
   scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
 
   const FileSystemURL file_system_url =
       file_system_context->CrackURL(GURL(url));
   if (file_system_url.path().empty()) {
     Respond(false);
     return true;
   }
 
   PerformFileWatchOperation(file_system_context, file_system_url,
                             extension_id());
   return true;
 }
 
 void FileManagerPrivateAddFileWatchFunction::PerformFileWatchOperation(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const storage::FileSystemURL& file_system_url,
     const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   file_manager::EventRouter* const event_router =
       file_manager::EventRouterFactory::GetForProfile(GetProfile());
 
   storage::WatcherManager* const watcher_manager =
       file_system_context->GetWatcherManager(file_system_url.type());
   if (watcher_manager) {
     watcher_manager->AddWatcher(
         file_system_url, false /* recursive */,
         base::Bind(
             &StatusCallbackToResponseCallback,
             base::Bind(&FileManagerPrivateAddFileWatchFunction::Respond, this)),
         base::Bind(&file_manager::EventRouter::OnWatcherManagerNotification,
                    event_router->GetWeakPtr(), file_system_url, extension_id));
     return;
   }
 
   // Obsolete. Fallback code if storage::WatcherManager is not implemented.
   event_router->AddFileWatch(
       file_system_url.path(), file_system_url.virtual_path(), extension_id,
       base::Bind(&FileManagerPrivateAddFileWatchFunction::Respond, this));
 }
 
 void FileManagerPrivateRemoveFileWatchFunction::PerformFileWatchOperation(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const storage::FileSystemURL& file_system_url,
     const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   file_manager::EventRouter* const event_router =
       file_manager::EventRouterFactory::GetForProfile(GetProfile());
 
   storage::WatcherManager* const watcher_manager =
       file_system_context->GetWatcherManager(file_system_url.type());
   if (watcher_manager) {
     watcher_manager->RemoveWatcher(
         file_system_url, false /* recursive */,
         base::Bind(&StatusCallbackToResponseCallback,
@@ skipping 139 matching lines @@
       volume_info.mount_path.AsUTF8Unsafe());
   SendResponse(true);
   return true;
 }
 
 // Obtains file size of URL.
 void GetFileMetadataOnIOThread(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const FileSystemURL& url,
     const storage::FileSystemOperation::GetMetadataCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   file_system_context->operation_runner()->GetMetadata(
       url, base::Bind(&GetFileMetadataRespondOnUIThread, callback));
 }
 
 // Checks if the available space of the |path| is enough for required |bytes|.
 bool CheckLocalDiskSpaceOnIOThread(const base::FilePath& path, int64 bytes) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return bytes <= base::SysInfo::AmountOfFreeDiskSpace(path) -
                       cryptohome::kMinFreeSpaceInBytes;
 }
 
 bool FileManagerPrivateStartCopyFunction::RunAsync() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   using  extensions::api::file_manager_private::StartCopy::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   if (params->source_url.empty() || params->parent.empty() ||
       params->new_name.empty()) {
     // Error code in format of DOMError.name.
     SetError("EncodingError");
     return false;
@@ skipping 34 matching lines @@
 
   return BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&FileManagerPrivateStartCopyFunction::RunAfterFreeDiskSpace,
                  this, true));
 }
 
 void FileManagerPrivateStartCopyFunction::RunAfterGetFileMetadata(
     base::File::Error result,
     const base::File::Info& file_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (result != base::File::FILE_OK) {
     SetError("NotFoundError");
     SendResponse(false);
     return;
   }
 
   drive::FileSystemInterface* const drive_file_system =
       drive::util::GetFileSystemByProfile(GetProfile());
   if (drive_file_system) {
@@ skipping 10 matching lines @@
             file_info.size),
         base::Bind(&FileManagerPrivateStartCopyFunction::RunAfterFreeDiskSpace,
                    this));
     if (!result)
       SendResponse(false);
   }
 }
 
 void FileManagerPrivateStartCopyFunction::RunAfterFreeDiskSpace(
     bool available) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!available) {
     SetError("QuotaExceededError");
     SendResponse(false);
     return;
   }
 
   scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
   const bool result = BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&StartCopyOnIOThread, GetProfile(), file_system_context,
                  source_url_, destination_url_),
       base::Bind(&FileManagerPrivateStartCopyFunction::RunAfterStartCopy,
                  this));
   if (!result)
     SendResponse(false);
 }
 
 void FileManagerPrivateStartCopyFunction::RunAfterStartCopy(
     int operation_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   SetResult(new base::FundamentalValue(operation_id));
   SendResponse(true);
 }
 
 bool FileManagerPrivateCancelCopyFunction::RunAsync() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   using extensions::api::file_manager_private::CancelCopy::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
 
   // We don't much take care about the result of cancellation.
@@ skipping 112 matching lines @@
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&FileStreamMd5Digester::GetMd5Digest,
                                      base::Unretained(digester_.get()),
                                      base::Passed(&reader), result_callback));
 
   return true;
 }
 
 void FileManagerPrivateComputeChecksumFunction::Respond(
     const std::string& hash) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SetResult(new base::StringValue(hash));
   SendResponse(true);
 }
 
 bool FileManagerPrivateSearchFilesByHashesFunction::RunAsync() {
   using api::file_manager_private::SearchFilesByHashes::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // TODO(hirono): Check the volume ID and fail the function for volumes other
@@ skipping 103 matching lines @@
   return RespondLater();
 }
 
 void FileManagerPrivateSetEntryTagFunction::OnSetEntryPropertyCompleted(
     drive::FileError result) {
   Respond(result == drive::FILE_ERROR_OK ? NoArguments()
                                          : Error("Failed to set a tag."));
 }
 
 }  // namespace extensions