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

chrome/browser/extensions/api/file_system/file_system_api.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/file_system/file_system_api.h"
 
 #include "apps/app_window.h"
 #include "apps/app_window_registry.h"
 #include "apps/saved_files_service.h"
 #include "base/bind.h"
@@ skipping 266 matching lines @@
   return true;
 }
 
 FileSystemEntryFunction::FileSystemEntryFunction()
     : multiple_(false),
       is_directory_(false),
       response_(NULL) {}
 
 void FileSystemEntryFunction::CheckWritableFiles(
     const std::vector<base::FilePath>& paths) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   app_file_handler_util::CheckWritableFiles(
       paths,
       GetProfile(),
       is_directory_,
       base::Bind(&FileSystemEntryFunction::RegisterFileSystemsAndSendResponse,
                  this,
                  paths),
       base::Bind(&FileSystemEntryFunction::HandleWritableFileError, this));
 }
 
 void FileSystemEntryFunction::RegisterFileSystemsAndSendResponse(
     const std::vector<base::FilePath>& paths) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!render_view_host_)
     return;
 
   CreateResponse();
   for (std::vector<base::FilePath>::const_iterator it = paths.begin();
        it != paths.end(); ++it) {
     AddEntryToResponse(*it, "");
   }
   SendResponse(true);
 }
@@ skipping 28 matching lines @@
   if (id_override.empty())
     entry->SetString("id", file_entry.id);
   else
     entry->SetString("id", id_override);
   entry->SetBoolean("isDirectory", is_directory_);
   entries->Append(entry);
 }
 
 void FileSystemEntryFunction::HandleWritableFileError(
     const base::FilePath& error_path) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   error_ = base::StringPrintf(kWritableFileErrorFormat,
                               error_path.BaseName().AsUTF8Unsafe().c_str());
   SendResponse(false);
 }
 
 bool FileSystemGetWritableEntryFunction::RunImpl() {
   std::string filesystem_name;
   std::string filesystem_path;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &filesystem_name));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_path));
@@ skipping 16 matching lines @@
       base::Bind(
           &FileSystemGetWritableEntryFunction::SetIsDirectoryOnFileThread,
           this),
       base::Bind(
           &FileSystemGetWritableEntryFunction::CheckPermissionAndSendResponse,
           this));
   return true;
 }
 
 void FileSystemGetWritableEntryFunction::CheckPermissionAndSendResponse() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (is_directory_ &&
       !extension_->HasAPIPermission(APIPermission::kFileSystemDirectory)) {
     error_ = kRequiresFileSystemDirectoryError;
     SendResponse(false);
   }
   std::vector<base::FilePath> paths;
   paths.push_back(path_);
   CheckWritableFiles(paths);
 }
 
 void FileSystemGetWritableEntryFunction::SetIsDirectoryOnFileThread() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   if (base::DirectoryExists(path_)) {
     is_directory_ = true;
   }
 }
 
 bool FileSystemIsWritableEntryFunction::RunImpl() {
   std::string filesystem_name;
   std::string filesystem_path;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &filesystem_name));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_path));
@@ skipping 223 matching lines @@
   fileapi::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
       name,
       fileapi::kFileSystemTypeNativeLocal,
       fileapi::FileSystemMountOption(),
       path);
 }
 
 void FileSystemChooseEntryFunction::SetInitialPathOnFileThread(
     const base::FilePath& suggested_name,
     const base::FilePath& previous_path) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   if (!previous_path.empty() && base::DirectoryExists(previous_path)) {
     initial_path_ = previous_path.Append(suggested_name);
   } else {
     base::FilePath documents_dir;
     if (PathService::Get(chrome::DIR_USER_DOCUMENTS, &documents_dir)) {
       initial_path_ = documents_dir.Append(suggested_name);
     } else {
       initial_path_ = suggested_name;
     }
   }
@@ skipping 324 matching lines @@
   if (needs_new_entry) {
     is_directory_ = file_entry->is_directory;
     CreateResponse();
     AddEntryToResponse(file_entry->path, file_entry->id);
   }
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions