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

chrome/browser/chromeos/drive/directory_loader.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/directory_loader.h"
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 88 matching lines @@
       : loader_(loader),
         directory_fetch_info_(directory_fetch_info),
         root_folder_id_(root_folder_id),
         weak_ptr_factory_(this) {
   }
 
   ~FeedFetcher() {
   }
 
   void Run(const FileOperationCallback& callback) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(!callback.is_null());
     DCHECK(!directory_fetch_info_.resource_id().empty());
 
     // Remember the time stamp for usage stats.
     start_time_ = base::TimeTicks::Now();
 
     loader_->scheduler_->GetFileListInDirectory(
         directory_fetch_info_.resource_id(),
         base::Bind(&FeedFetcher::OnFileListFetched,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
  private:
   void OnFileListFetched(const FileOperationCallback& callback,
                          google_apis::DriveApiErrorCode status,
                          scoped_ptr<google_apis::FileList> file_list) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(!callback.is_null());
 
     FileError error = GDataToFileError(status);
     if (error != FILE_ERROR_OK) {
       callback.Run(error);
       return;
     }
 
     DCHECK(file_list);
     scoped_ptr<ChangeList> change_list(new ChangeList(*file_list));
@@ skipping 15 matching lines @@
                    callback,
                    next_url,
                    base::Owned(entries))));
   }
 
   void OnDirectoryRefreshed(
       const FileOperationCallback& callback,
       const GURL& next_url,
       const std::vector<ResourceEntry>* refreshed_entries,
       FileError error) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(!callback.is_null());
 
     if (error != FILE_ERROR_OK) {
       callback.Run(error);
       return;
     }
 
     loader_->SendEntries(directory_fetch_info_.local_id(), *refreshed_entries);
 
     if (!next_url.is_empty()) {
@@ skipping 36 matching lines @@
       about_resource_loader_(about_resource_loader),
       loader_controller_(loader_controller),
       weak_ptr_factory_(this) {
 }
 
 DirectoryLoader::~DirectoryLoader() {
   STLDeleteElements(&fast_fetch_feed_fetcher_set_);
 }
 
 void DirectoryLoader::AddObserver(ChangeListLoaderObserver* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.AddObserver(observer);
 }
 
 void DirectoryLoader::RemoveObserver(ChangeListLoaderObserver* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.RemoveObserver(observer);
 }
 
 void DirectoryLoader::ReadDirectory(
     const base::FilePath& directory_path,
     const ReadDirectoryEntriesCallback& entries_callback,
     const FileOperationCallback& completion_callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!completion_callback.is_null());
 
   ResourceEntry* entry = new ResourceEntry;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ResourceMetadata::GetResourceEntryByPath,
                  base::Unretained(resource_metadata_),
                  directory_path,
                  entry),
       base::Bind(&DirectoryLoader::ReadDirectoryAfterGetEntry,
                  weak_ptr_factory_.GetWeakPtr(),
                  directory_path,
                  entries_callback,
                  completion_callback,
                  true,  // should_try_loading_parent
                  base::Owned(entry)));
 }
 
 void DirectoryLoader::ReadDirectoryAfterGetEntry(
     const base::FilePath& directory_path,
     const ReadDirectoryEntriesCallback& entries_callback,
     const FileOperationCallback& completion_callback,
     bool should_try_loading_parent,
     const ResourceEntry* entry,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!completion_callback.is_null());
 
   if (error == FILE_ERROR_NOT_FOUND &&
       should_try_loading_parent &&
       util::GetDriveGrandRootPath().IsParent(directory_path)) {
     // This entry may be found after loading the parent.
     ReadDirectory(directory_path.DirName(),
                   ReadDirectoryEntriesCallback(),
                   base::Bind(&DirectoryLoader::ReadDirectoryAfterLoadParent,
                              weak_ptr_factory_.GetWeakPtr(),
@@ skipping 31 matching lines @@
   about_resource_loader_->GetAboutResource(
       base::Bind(&DirectoryLoader::ReadDirectoryAfterGetAboutResource,
                  weak_ptr_factory_.GetWeakPtr(), local_id));
 }
 
 void DirectoryLoader::ReadDirectoryAfterLoadParent(
     const base::FilePath& directory_path,
     const ReadDirectoryEntriesCallback& entries_callback,
     const FileOperationCallback& completion_callback,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!completion_callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     completion_callback.Run(error);
     return;
   }
 
   ResourceEntry* entry = new ResourceEntry;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ResourceMetadata::GetResourceEntryByPath,
                  base::Unretained(resource_metadata_),
                  directory_path,
                  entry),
       base::Bind(&DirectoryLoader::ReadDirectoryAfterGetEntry,
                  weak_ptr_factory_.GetWeakPtr(),
                  directory_path,
                  entries_callback,
                  completion_callback,
                  false,  // should_try_loading_parent
                  base::Owned(entry)));
 }
 
 void DirectoryLoader::ReadDirectoryAfterGetAboutResource(
     const std::string& local_id,
     google_apis::DriveApiErrorCode status,
     scoped_ptr<google_apis::AboutResource> about_resource) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   FileError error = GDataToFileError(status);
   if (error != FILE_ERROR_OK) {
     OnDirectoryLoadComplete(local_id, error);
     return;
   }
 
   DCHECK(about_resource);
 
   // Check the current status of local metadata, and start loading if needed.
@@ skipping 16 matching lines @@
                  base::Owned(entry),
                  base::Owned(local_changestamp)));
 }
 
 void DirectoryLoader::ReadDirectoryAfterCheckLocalState(
     scoped_ptr<google_apis::AboutResource> about_resource,
     const std::string& local_id,
     const ResourceEntry* entry,
     const int64* local_changestamp,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(about_resource);
 
   if (error != FILE_ERROR_OK) {
     OnDirectoryLoadComplete(local_id, error);
     return;
   }
   // This entry does not exist on the server.
   if (entry->resource_id().empty()) {
     OnDirectoryLoadComplete(local_id, FILE_ERROR_OK);
     return;
@@ skipping 17 matching lines @@
     OnDirectoryLoadComplete(local_id, FILE_ERROR_OK);
   } else {
     // Start fetching the directory content, and mark it with the changestamp
     // |remote_changestamp|.
     LoadDirectoryFromServer(directory_fetch_info);
   }
 }
 
 void DirectoryLoader::OnDirectoryLoadComplete(const std::string& local_id,
                                               FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   LoadCallbackMap::iterator it = pending_load_callback_.find(local_id);
   if (it == pending_load_callback_.end())
     return;
 
   // No need to read metadata when no one needs entries.
   bool needs_to_send_entries = false;
   for (size_t i = 0; i < it->second.size(); ++i) {
     const ReadDirectoryCallbackState& callback_state = it->second[i];
     if (!callback_state.entries_callback.is_null())
@@ skipping 54 matching lines @@
         callback_state->sent_entry_names.insert(entry.base_name());
         entries_to_send->push_back(entry);
       }
     }
     callback_state->entries_callback.Run(entries_to_send.Pass());
   }
 }
 
 void DirectoryLoader::LoadDirectoryFromServer(
     const DirectoryFetchInfo& directory_fetch_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!directory_fetch_info.empty());
   DVLOG(1) << "Start loading directory: " << directory_fetch_info.ToString();
 
   const google_apis::AboutResource* about_resource =
       about_resource_loader_->cached_about_resource();
   DCHECK(about_resource);
 
   logger_->Log(logging::LOG_INFO,
                "Fast-fetch start: %s; Server changestamp: %s",
                directory_fetch_info.ToString().c_str(),
                base::Int64ToString(
                    about_resource->largest_change_id()).c_str());
 
   FeedFetcher* fetcher = new FeedFetcher(this,
                                          directory_fetch_info,
                                          about_resource->root_folder_id());
   fast_fetch_feed_fetcher_set_.insert(fetcher);
   fetcher->Run(
       base::Bind(&DirectoryLoader::LoadDirectoryFromServerAfterLoad,
                  weak_ptr_factory_.GetWeakPtr(),
                  directory_fetch_info,
                  fetcher));
 }
 
 void DirectoryLoader::LoadDirectoryFromServerAfterLoad(
     const DirectoryFetchInfo& directory_fetch_info,
     FeedFetcher* fetcher,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!directory_fetch_info.empty());
 
   // Delete the fetcher.
   fast_fetch_feed_fetcher_set_.erase(fetcher);
   delete fetcher;
 
   logger_->Log(logging::LOG_INFO,
                "Fast-fetch complete: %s => %s",
                directory_fetch_info.ToString().c_str(),
                FileErrorToString(error).c_str());
@@ skipping 19 matching lines @@
           &DirectoryLoader::LoadDirectoryFromServerAfterUpdateChangestamp,
           weak_ptr_factory_.GetWeakPtr(),
           directory_fetch_info,
           base::Owned(directory_path)));
 }
 
 void DirectoryLoader::LoadDirectoryFromServerAfterUpdateChangestamp(
     const DirectoryFetchInfo& directory_fetch_info,
     const base::FilePath* directory_path,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DVLOG(1) << "Directory loaded: " << directory_fetch_info.ToString();
   OnDirectoryLoadComplete(directory_fetch_info.local_id(), error);
 
   // Also notify the observers.
   if (error == FILE_ERROR_OK && !directory_path->empty()) {
     FOR_EACH_OBSERVER(ChangeListLoaderObserver,
                       observers_,
                       OnDirectoryReloaded(*directory_path));
   }
 }
 
 }  // namespace internal
 }  // namespace drive