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

chrome/browser/chromeos/extensions/file_manager/private_api_drive.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_drive.h"
 
 #include <map>
 #include <set>
 
 #include "base/command_line.h"
@@ skipping 154 matching lines @@
 class SingleEntryPropertiesGetterForDrive {
  public:
   typedef base::Callback<void(scoped_ptr<EntryProperties> properties,
                               base::File::Error error)> ResultCallback;
 
   // Creates an instance and starts the process.
   static void Start(const base::FilePath local_path,
                     const std::set<EntryPropertyName>& names,
                     Profile* const profile,
                     const ResultCallback& callback) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     SingleEntryPropertiesGetterForDrive* instance =
         new SingleEntryPropertiesGetterForDrive(local_path, names, profile,
                                                 callback);
     instance->StartProcess();
 
     // The instance will be destroyed by itself.
   }
 
   virtual ~SingleEntryPropertiesGetterForDrive() {}
 
  private:
   SingleEntryPropertiesGetterForDrive(
       const base::FilePath local_path,
       const std::set<EntryPropertyName>& /* names */,
       Profile* const profile,
       const ResultCallback& callback)
       : callback_(callback),
         local_path_(local_path),
         running_profile_(profile),
         properties_(new EntryProperties),
         file_owner_profile_(NULL),
         weak_ptr_factory_(this) {
     DCHECK(!callback_.is_null());
     DCHECK(profile);
   }
 
   void StartProcess() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     file_path_ = drive::util::ExtractDrivePath(local_path_);
     file_owner_profile_ = drive::util::ExtractProfileFromPath(local_path_);
 
     if (!file_owner_profile_ ||
         !g_browser_process->profile_manager()->IsValidProfile(
             file_owner_profile_)) {
       CompleteGetEntryProperties(drive::FILE_ERROR_FAILED);
       return;
     }
 
     // Start getting the file info.
     drive::FileSystemInterface* const file_system =
         drive::util::GetFileSystemByProfile(file_owner_profile_);
     if (!file_system) {
       // |file_system| is NULL if Drive is disabled or not mounted.
       CompleteGetEntryProperties(drive::FILE_ERROR_FAILED);
       return;
     }
 
     file_system->GetResourceEntry(
         file_path_,
         base::Bind(&SingleEntryPropertiesGetterForDrive::OnGetFileInfo,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnGetFileInfo(drive::FileError error,
                      scoped_ptr<drive::ResourceEntry> entry) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     if (error != drive::FILE_ERROR_OK) {
       CompleteGetEntryProperties(error);
       return;
     }
 
     DCHECK(entry);
     owner_resource_entry_.swap(entry);
 
     if (running_profile_->IsSameProfile(file_owner_profile_)) {
@@ skipping 10 matching lines @@
       return;
     }
     file_system->GetPathFromResourceId(
         owner_resource_entry_->resource_id(),
         base::Bind(&SingleEntryPropertiesGetterForDrive::OnGetRunningPath,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnGetRunningPath(drive::FileError error,
                         const base::FilePath& file_path) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     if (error != drive::FILE_ERROR_OK) {
       // The running profile does not know the file.
       StartParseFileInfo(false);
       return;
     }
 
     drive::FileSystemInterface* const file_system =
         drive::util::GetFileSystemByProfile(running_profile_);
     if (!file_system) {
       // The drive is disable for the running profile.
       StartParseFileInfo(false);
       return;
     }
 
     file_system->GetResourceEntry(
         file_path,
         base::Bind(&SingleEntryPropertiesGetterForDrive::OnGetShareInfo,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnGetShareInfo(drive::FileError error,
                       scoped_ptr<drive::ResourceEntry> entry) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     if (error != drive::FILE_ERROR_OK) {
       CompleteGetEntryProperties(error);
       return;
     }
 
     DCHECK(entry.get());
     StartParseFileInfo(entry->shared_with_me());
   }
 
   void StartParseFileInfo(bool shared_with_me) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     FillEntryPropertiesValueForDrive(
         *owner_resource_entry_, shared_with_me, properties_.get());
 
     drive::FileSystemInterface* const file_system =
         drive::util::GetFileSystemByProfile(file_owner_profile_);
     drive::DriveAppRegistry* const app_registry =
         drive::util::GetDriveAppRegistryByProfile(file_owner_profile_);
     if (!file_system || !app_registry) {
       // |file_system| or |app_registry| is NULL if Drive is disabled.
@@ skipping 34 matching lines @@
               app_info.document_icons, drive::util::kPreferredIconSize);
           properties_->custom_icon_url.reset(new std::string(doc_icon.spec()));
         }
       }
     }
 
     CompleteGetEntryProperties(drive::FILE_ERROR_OK);
   }
 
   void CompleteGetEntryProperties(drive::FileError error) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(!callback_.is_null());
 
     callback_.Run(properties_.Pass(), drive::FileErrorToBaseFileError(error));
     BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, this);
   }
 
   // Given parameters.
   const ResultCallback callback_;
   const base::FilePath local_path_;
   Profile* const running_profile_;
 
   // Values used in the process.
   scoped_ptr<EntryProperties> properties_;
   Profile* file_owner_profile_;
   base::FilePath file_path_;
   scoped_ptr<drive::ResourceEntry> owner_resource_entry_;
 
   base::WeakPtrFactory<SingleEntryPropertiesGetterForDrive> weak_ptr_factory_;
 };  // class SingleEntryPropertiesGetterForDrive
 
 class SingleEntryPropertiesGetterForFileSystemProvider {
  public:
   typedef base::Callback<void(scoped_ptr<EntryProperties> properties,
                               base::File::Error error)> ResultCallback;
 
   // Creates an instance and starts the process.
   static void Start(const storage::FileSystemURL file_system_url,
                     const std::set<EntryPropertyName>& names,
                     const ResultCallback& callback) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     SingleEntryPropertiesGetterForFileSystemProvider* instance =
         new SingleEntryPropertiesGetterForFileSystemProvider(file_system_url,
                                                              names, callback);
     instance->StartProcess();
 
     // The instance will be destroyed by itself.
   }
 
   virtual ~SingleEntryPropertiesGetterForFileSystemProvider() {}
 
  private:
   SingleEntryPropertiesGetterForFileSystemProvider(
       const storage::FileSystemURL& file_system_url,
       const std::set<EntryPropertyName>& names,
       const ResultCallback& callback)
       : callback_(callback),
         file_system_url_(file_system_url),
         names_(names),
         properties_(new EntryProperties),
         weak_ptr_factory_(this) {
     DCHECK(!callback_.is_null());
   }
 
   void StartProcess() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     FileSystemURLParser parser(file_system_url_);
     if (!parser.Parse()) {
       CompleteGetEntryProperties(base::File::FILE_ERROR_NOT_FOUND);
       return;
     }
 
     ProvidedFileSystemInterface::MetadataFieldMask field_mask =
         ProvidedFileSystemInterface::METADATA_FIELD_DEFAULT;
     // TODO(mtomasz): Add other fields. All of them should be requested on
     // demand. crbug.com/413161.
     if (names_.find(
             api::file_manager_private::ENTRY_PROPERTY_NAME_THUMBNAILURL) !=
         names_.end())
       field_mask |= ProvidedFileSystemInterface::METADATA_FIELD_THUMBNAIL;
 
     parser.file_system()->GetMetadata(
         parser.file_path(), field_mask,
         base::Bind(&SingleEntryPropertiesGetterForFileSystemProvider::
                        OnGetMetadataCompleted,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnGetMetadataCompleted(scoped_ptr<EntryMetadata> metadata,
                               base::File::Error result) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     if (result != base::File::FILE_OK) {
       CompleteGetEntryProperties(result);
       return;
     }
 
     properties_->size.reset(new double(metadata->size));
     properties_->modification_time.reset(
         new double(metadata->modification_time.ToJsTime()));
 
     if (!metadata->thumbnail.empty())
       properties_->thumbnail_url.reset(new std::string(metadata->thumbnail));
 
     CompleteGetEntryProperties(base::File::FILE_OK);
   }
 
   void CompleteGetEntryProperties(base::File::Error result) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(!callback_.is_null());
 
     callback_.Run(properties_.Pass(), result);
     BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, this);
   }
 
   // Given parameters.
   const ResultCallback callback_;
   const storage::FileSystemURL file_system_url_;
   const std::set<EntryPropertyName> names_;
@@ skipping 10 matching lines @@
 FileManagerPrivateGetEntryPropertiesFunction::
     FileManagerPrivateGetEntryPropertiesFunction()
     : processed_count_(0) {
 }
 
 FileManagerPrivateGetEntryPropertiesFunction::
     ~FileManagerPrivateGetEntryPropertiesFunction() {
 }
 
 bool FileManagerPrivateGetEntryPropertiesFunction::RunAsync() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   using api::file_manager_private::GetEntryProperties::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());
 
   properties_list_.resize(params->file_urls.size());
@@ skipping 29 matching lines @@
   }
 
   return true;
 }
 
 void FileManagerPrivateGetEntryPropertiesFunction::CompleteGetEntryProperties(
     size_t index,
     const storage::FileSystemURL& url,
     scoped_ptr<EntryProperties> properties,
     base::File::Error error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(0 <= processed_count_ && processed_count_ < properties_list_.size());
 
   properties_list_[index] = make_linked_ptr(properties.release());
   if (error == base::File::FILE_OK) {
     properties_list_[index]->external_file_url.reset(
         new std::string(chromeos::FileSystemURLToExternalFileURL(url).spec()));
   }
 
   processed_count_++;
   if (processed_count_ < properties_list_.size())
     return;
 
   results_ = extensions::api::file_manager_private::GetEntryProperties::
       Results::Create(properties_list_);
   SendResponse(true);
 }
 
 bool FileManagerPrivatePinDriveFileFunction::RunAsync() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   using extensions::api::file_manager_private::PinDriveFile::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(GetProfile());
   if (!file_system)  // |file_system| is NULL if Drive is disabled.
     return false;
 
   const base::FilePath drive_path =
       drive::util::ExtractDrivePath(file_manager::util::GetLocalPathFromURL(
           render_view_host(), GetProfile(), GURL(params->file_url)));
   if (params->pin) {
     file_system->Pin(drive_path,
                      base::Bind(&FileManagerPrivatePinDriveFileFunction::
                                     OnPinStateSet, this));
   } else {
     file_system->Unpin(drive_path,
                        base::Bind(&FileManagerPrivatePinDriveFileFunction::
                                       OnPinStateSet, this));
   }
   return true;
 }
 
 void FileManagerPrivatePinDriveFileFunction::
     OnPinStateSet(drive::FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (error == drive::FILE_ERROR_OK) {
     SendResponse(true);
   } else {
     SetError(drive::FileErrorToString(error));
     SendResponse(false);
   }
 }
 
 bool FileManagerPrivateCancelFileTransfersFunction::RunAsync() {
@@ skipping 424 matching lines @@
   file_system->GetResourceEntry(
       file_path,
       base::Bind(&FileManagerPrivateGetDownloadUrlFunction::OnGetResourceEntry,
                  this));
   return true;
 }
 
 void FileManagerPrivateGetDownloadUrlFunction::OnGetResourceEntry(
     drive::FileError error,
     scoped_ptr<drive::ResourceEntry> entry) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (error != drive::FILE_ERROR_OK) {
     SetError("Download Url for this item is not available.");
     SetResult(new base::StringValue(""));  // Intentionally returns a blank.
     SendResponse(false);
     return;
   }
 
   download_url_ =
       google_apis::DriveApiUrlGenerator::kBaseDownloadUrlForProduction +
@@ skipping 26 matching lines @@
     return;
   }
 
   const std::string url = download_url_ + "?access_token=" + access_token;
   SetResult(new base::StringValue(url));
 
   SendResponse(true);
 }
 
 }  // namespace extensions