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

chrome/browser/chromeos/drive/drive_integration_service.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/chromeos/drive/drive_integration_service.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/prefs/pref_service.h"
@@ skipping 201 matching lines @@
     const std::string& test_mount_point_name,
     const base::FilePath& test_cache_root,
     FileSystemInterface* test_file_system)
     : profile_(profile),
       state_(NOT_INITIALIZED),
       enabled_(false),
       mount_point_name_(test_mount_point_name),
       cache_root_directory_(!test_cache_root.empty() ?
                             test_cache_root : util::GetCacheRootPath(profile)),
       weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(profile && !profile->IsOffTheRecord());
 
   logger_.reset(new EventLogger);
   base::SequencedWorkerPool* blocking_pool = BrowserThread::GetBlockingPool();
   blocking_task_runner_ = blocking_pool->GetSequencedTaskRunner(
       blocking_pool->GetSequenceToken());
 
   ProfileOAuth2TokenService* oauth_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
 
@@ skipping 41 matching lines @@
 
   if (preference_watcher) {
     preference_watcher_.reset(preference_watcher);
     preference_watcher->set_integration_service(this);
   }
 
   SetEnabled(drive::util::IsDriveEnabledForProfile(profile));
 }
 
 DriveIntegrationService::~DriveIntegrationService() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 void DriveIntegrationService::Shutdown() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   DriveNotificationManager* drive_notification_manager =
       DriveNotificationManagerFactory::FindForBrowserContext(profile_);
   if (drive_notification_manager)
     drive_notification_manager->RemoveObserver(this);
 
   RemoveDriveMountPoint();
   debug_info_collector_.reset();
@@ skipping 51 matching lines @@
   // GetRegisteredPath() returns true if the path is available.
   base::FilePath unused;
   storage::ExternalMountPoints* const mount_points =
       storage::ExternalMountPoints::GetSystemInstance();
   DCHECK(mount_points);
   return mount_points->GetRegisteredPath(mount_point_name_, &unused);
 }
 
 void DriveIntegrationService::AddObserver(
     DriveIntegrationServiceObserver* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.AddObserver(observer);
 }
 
 void DriveIntegrationService::RemoveObserver(
     DriveIntegrationServiceObserver* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.RemoveObserver(observer);
 }
 
 void DriveIntegrationService::OnNotificationReceived() {
   file_system_->CheckForUpdates();
   drive_app_registry_->Update();
 }
 
 void DriveIntegrationService::OnPushNotificationEnabled(bool enabled) {
   if (enabled)
     drive_app_registry_->Update();
 
   const char* status = (enabled ? "enabled" : "disabled");
   logger_->Log(logging::LOG_INFO, "Push notification is %s", status);
 }
 
 void DriveIntegrationService::ClearCacheAndRemountFileSystem(
     const base::Callback<void(bool)>& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (state_ != INITIALIZED) {
     callback.Run(false);
     return;
   }
 
   RemoveDriveMountPoint();
 
   state_ = REMOUNTING;
   // Reloads the Drive app registry.
   drive_app_registry_->Update();
   // Resetting the file system clears resource metadata and cache.
   file_system_->Reset(base::Bind(
       &DriveIntegrationService::AddBackDriveMountPoint,
       weak_ptr_factory_.GetWeakPtr(),
       callback));
 }
 
 void DriveIntegrationService::AddBackDriveMountPoint(
     const base::Callback<void(bool)>& callback,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   state_ = error == FILE_ERROR_OK ? INITIALIZED : NOT_INITIALIZED;
 
   if (error != FILE_ERROR_OK || !enabled_) {
     // Failed to reset, or Drive was disabled during the reset.
     callback.Run(false);
     return;
   }
 
   AddDriveMountPoint();
   callback.Run(true);
 }
 
 void DriveIntegrationService::AddDriveMountPoint() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(INITIALIZED, state_);
   DCHECK(enabled_);
 
   const base::FilePath& drive_mount_point =
       util::GetDriveMountPointPath(profile_);
   if (mount_point_name_.empty())
     mount_point_name_ = drive_mount_point.BaseName().AsUTF8Unsafe();
   storage::ExternalMountPoints* const mount_points =
       storage::ExternalMountPoints::GetSystemInstance();
   DCHECK(mount_points);
 
   bool success =
       mount_points->RegisterFileSystem(mount_point_name_,
                                        storage::kFileSystemTypeDrive,
                                        storage::FileSystemMountOption(),
                                        drive_mount_point);
 
   if (success) {
     logger_->Log(logging::LOG_INFO, "Drive mount point is added");
     FOR_EACH_OBSERVER(DriveIntegrationServiceObserver, observers_,
                       OnFileSystemMounted());
   }
 }
 
 void DriveIntegrationService::RemoveDriveMountPoint() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!mount_point_name_.empty()) {
     job_list()->CancelAllJobs();
 
     FOR_EACH_OBSERVER(DriveIntegrationServiceObserver, observers_,
                       OnFileSystemBeingUnmounted());
 
     storage::ExternalMountPoints* const mount_points =
         storage::ExternalMountPoints::GetSystemInstance();
     DCHECK(mount_points);
 
     mount_points->RevokeFileSystem(mount_point_name_);
     logger_->Log(logging::LOG_INFO, "Drive mount point is removed");
   }
 }
 
 void DriveIntegrationService::Initialize() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(NOT_INITIALIZED, state_);
   DCHECK(enabled_);
 
   state_ = INITIALIZING;
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&InitializeMetadata,
                  cache_root_directory_,
                  metadata_storage_.get(),
                  cache_.get(),
                  resource_metadata_.get(),
                  file_manager::util::GetDownloadsFolderForProfile(profile_)),
       base::Bind(&DriveIntegrationService::InitializeAfterMetadataInitialized,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DriveIntegrationService::InitializeAfterMetadataInitialized(
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(INITIALIZING, state_);
 
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile_);
   drive_service_->Initialize(signin_manager->GetAuthenticatedAccountId());
 
   if (error != FILE_ERROR_OK) {
     LOG(WARNING) << "Failed to initialize: " << FileErrorToString(error);
 
     // Cannot used Drive. Set the download destination preference out of Drive.
@@ skipping 141 matching lines @@
         profile, preference_watcher,
         NULL, std::string(), base::FilePath(), NULL);
   } else {
     service = factory_for_test_->Run(profile);
   }
 
   return service;
 }
 
 }  // namespace drive