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

chrome/browser/android/provider/chrome_browser_provider.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/android/provider/chrome_browser_provider.h"
 
 #include <cmath>
 #include <list>
 #include <utility>
 
@@ skipping 198 matching lines @@
                    model(), title, url, is_folder, parent_id, &result));
     return result;
   }
 
   static void RunOnUIThread(BookmarkModel* model,
                             const base::string16& title,
                             const base::string16& url,
                             const bool is_folder,
                             const int64 parent_id,
                             int64* result) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(result);
     GURL gurl = ParseAndMaybeAppendScheme(url, kDefaultUrlScheme);
 
     // Check if the bookmark already exists.
     const BookmarkNode* node = model->GetMostRecentlyAddedUserNodeForURL(gurl);
     if (!node) {
       const BookmarkNode* parent_node = NULL;
       if (parent_id >= 0)
         parent_node = bookmarks::GetBookmarkNodeByID(model, parent_id);
       if (!parent_node)
@@ skipping 22 matching lines @@
   ~RemoveBookmarkTask() override {}
 
   int Run(const int64 id) {
     id_to_delete_ = id;
     RunOnUIThreadBlocking::Run(
         base::Bind(&RemoveBookmarkTask::RunOnUIThread, model(), id));
     return deleted_;
   }
 
   static void RunOnUIThread(BookmarkModel* model, const int64 id) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     const BookmarkNode* node = bookmarks::GetBookmarkNodeByID(model, id);
     if (node && node->parent()) {
       const BookmarkNode* parent_node = node->parent();
       model->Remove(parent_node, parent_node->GetIndexOf(node));
     }
   }
 
   // Verify that the bookmark was actually removed. Called synchronously.
   void BookmarkNodeRemoved(BookmarkModel* bookmark_model,
                            const BookmarkNode* parent,
@@ skipping 18 matching lines @@
       : BookmarkModelObserverTask(model) {}
 
   ~RemoveAllUserBookmarksTask() override {}
 
   void Run() {
     RunOnUIThreadBlocking::Run(
         base::Bind(&RemoveAllUserBookmarksTask::RunOnUIThread, model()));
   }
 
   static void RunOnUIThread(BookmarkModel* model) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     LOG(ERROR) << "begin model->RemoveAllUserBookmarks";
     model->RemoveAllUserBookmarks();
     LOG(ERROR) << "after model->RemoveAllUserBookmarks";
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RemoveAllUserBookmarksTask);
 };
 
 // Utility method to update a bookmark.
@@ skipping 14 matching lines @@
         base::Bind(&UpdateBookmarkTask::RunOnUIThread,
                    model(), id, title, url, parent_id));
     return updated_;
   }
 
   static void RunOnUIThread(BookmarkModel* model,
                             const int64 id,
                             const base::string16& title,
                             const base::string16& url,
                             const int64 parent_id) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     const BookmarkNode* node = bookmarks::GetBookmarkNodeByID(model, id);
     if (node) {
       if (node->GetTitle() != title)
         model->SetTitle(node, title);
 
       if (node->type() == BookmarkNode::URL) {
         GURL bookmark_url = ParseAndMaybeAppendScheme(url, kDefaultUrlScheme);
         if (bookmark_url != node->url())
           model->SetURL(node, bookmark_url);
       }
@@ skipping 34 matching lines @@
     bool result = false;
     RunOnUIThreadBlocking::Run(
         base::Bind(&BookmarkNodeExistsTask::RunOnUIThread,
                    model(), id, &result));
     return result;
   }
 
   static void RunOnUIThread(BookmarkModel* model,
                             const int64 id,
                             bool* result) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(result);
     *result = bookmarks::GetBookmarkNodeByID(model, id) != NULL;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BookmarkNodeExistsTask);
 };
 
 // Checks if a node belongs to the Mobile Bookmarks hierarchy branch.
 class IsInMobileBookmarksBranchTask : public BookmarkModelTask {
  public:
   explicit IsInMobileBookmarksBranchTask(BookmarkModel* model)
       : BookmarkModelTask(model) {}
 
   bool Run(const int64 id) {
     bool result = false;
     RunOnUIThreadBlocking::Run(
         base::Bind(&IsInMobileBookmarksBranchTask::RunOnUIThread,
                    model(), id, &result));
     return result;
   }
 
   static void RunOnUIThread(BookmarkModel* model,
                             const int64 id,
                             bool *result) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(result);
     const BookmarkNode* node = bookmarks::GetBookmarkNodeByID(model, id);
     const BookmarkNode* mobile_node = model->mobile_node();
     while (node && node != mobile_node)
       node = node->parent();
 
     *result = node == mobile_node;
   }
 
  private:
@@ skipping 13 matching lines @@
     RunOnUIThreadBlocking::Run(
         base::Bind(&CreateBookmarksFolderOnceTask::RunOnUIThread,
                    model(), title, parent_id, &result));
     return result;
   }
 
   static void RunOnUIThread(BookmarkModel* model,
                             const base::string16& title,
                             const int64 parent_id,
                             int64* result) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(result);
 
     // Invalid ids are assumed to refer to the Mobile Bookmarks folder.
     const BookmarkNode* parent =
         parent_id >= 0 ? bookmarks::GetBookmarkNodeByID(model, parent_id)
                        : model->mobile_node();
     DCHECK(parent);
 
     bool in_mobile_bookmarks;
     IsInMobileBookmarksBranchTask::RunOnUIThread(model, parent->id(),
@@ skipping 27 matching lines @@
 
   void Run(ScopedJavaGlobalRef<jobject>* jroot) {
     RunOnUIThreadBlocking::Run(
         base::Bind(&GetEditableBookmarkFoldersTask::RunOnUIThread,
                    client_, model(), jroot));
   }
 
   static void RunOnUIThread(ChromeBookmarkClient* client,
                             BookmarkModel* model,
                             ScopedJavaGlobalRef<jobject>* jroot) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     const BookmarkNode* root = model->root_node();
     if (!root || !root->is_folder())
       return;
 
     // The iterative approach is not possible because ScopedGlobalJavaRefs
     // cannot be copy-constructed, and therefore not used in STL containers.
     ConvertFolderSubtree(client, AttachCurrentThread(), root,
                          ScopedJavaLocalRef<jobject>(), jroot);
   }
 
@@ skipping 45 matching lines @@
     return RunOnUIThreadBlocking::Run(
         base::Bind(&GetBookmarkNodeTask::RunOnUIThread,
                    model(), id, get_parent, get_children, jnode));
   }
 
   static void RunOnUIThread(BookmarkModel* model,
                             const int64 id,
                             bool get_parent,
                             bool get_children,
                             ScopedJavaGlobalRef<jobject>* jnode) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     const BookmarkNode* node = bookmarks::GetBookmarkNodeByID(model, id);
     if (!node || !jnode)
       return;
 
     ScopedJavaGlobalRef<jobject> jparent;
     if (get_parent) {
       ConvertBookmarkNode(node->parent(), ScopedJavaLocalRef<jobject>(),
                           &jparent);
     }
 
@@ skipping 34 matching lines @@
 
   const BookmarkNode* Run() {
     const BookmarkNode* result = NULL;
     RunOnUIThreadBlocking::Run(
         base::Bind(&GetMobileBookmarksNodeTask::RunOnUIThread,
                    model(), &result));
     return result;
   }
 
   static void RunOnUIThread(BookmarkModel* model, const BookmarkNode** result) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(result);
     *result = model->mobile_node();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GetMobileBookmarksNodeTask);
 };
 
 // ------------- Aynchronous requests classes ------------- //
 
@@ skipping 258 matching lines @@
 class SearchTermTask : public HistoryProviderTask {
  protected:
   SearchTermTask(AndroidHistoryProviderService* service,
                  base::CancelableTaskTracker* cancelable_tracker,
                  Profile* profile)
       : HistoryProviderTask(service, cancelable_tracker), profile_(profile) {}
 
   // Fill SearchRow's keyword_id and url fields according the given
   // search_term. Return true if succeeded.
   void BuildSearchRow(history::SearchRow* row) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     TemplateURLService* template_service =
         TemplateURLServiceFactory::GetForProfile(profile_);
     template_service->Load();
 
     const TemplateURL* search_engine =
         template_service->GetDefaultSearchProvider();
     if (search_engine) {
       const TemplateURLRef* search_url = &search_engine->url_ref();
       TemplateURLRef::SearchTermsArgs search_terms_args(row->search_term());
@@ skipping 23 matching lines @@
 
   history::URLID Run(const history::SearchRow& row) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AddSearchTermFromAPITask::MakeRequestOnUIThread,
                    base::Unretained(this), row));
     return result_;
   }
 
  private:
   void MakeRequestOnUIThread(const history::SearchRow& row) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     history::SearchRow internal_row = row;
     BuildSearchRow(&internal_row);
     service()->InsertSearchTerm(
         internal_row,
         base::Bind(&AddSearchTermFromAPITask::OnSearchTermInserted,
                    base::Unretained(this)),
         cancelable_tracker());
   }
 
   void OnSearchTermInserted(history::URLID id) {
@@ skipping 61 matching lines @@
         base::Bind(&UpdateSearchTermsFromAPITask::MakeRequestOnUIThread,
                    base::Unretained(this), row, selection, selection_args));
     return result_;
   }
 
  private:
   void MakeRequestOnUIThread(
       const history::SearchRow& row,
       const std::string& selection,
       const std::vector<base::string16>& selection_args) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     history::SearchRow internal_row = row;
     BuildSearchRow(&internal_row);
     service()->UpdateSearchTerms(
         internal_row,
         selection,
         selection_args,
         base::Bind(&UpdateSearchTermsFromAPITask::OnSearchTermsUpdated,
                    base::Unretained(this)),
         cancelable_tracker());
   }
@@ skipping 122 matching lines @@
 }
 
 bool ChromeBrowserProvider::RegisterChromeBrowserProvider(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 ChromeBrowserProvider::ChromeBrowserProvider(JNIEnv* env, jobject obj)
     : weak_java_provider_(env, obj),
       history_service_observer_(this),
       handling_extensive_changes_(false) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   profile_ = g_browser_process->profile_manager()->GetLastUsedProfile();
   bookmark_model_ = BookmarkModelFactory::GetForProfile(profile_);
   top_sites_ = TopSitesFactory::GetForProfile(profile_);
   favicon_service_ = FaviconServiceFactory::GetForProfile(
       profile_, ServiceAccessType::EXPLICIT_ACCESS),
   service_.reset(new AndroidHistoryProviderService(profile_));
 
   // Register as observer for service we are interested.
   bookmark_model_->AddObserver(this);
   history_service_observer_.Add(HistoryServiceFactory::GetForProfile(
@@ skipping 467 matching lines @@
   ScopedJavaLocalRef<jobject> obj = weak_java_provider_.get(env);
   if (obj.is_null())
     return;
   Java_ChromeBrowserProvider_onSearchTermChanged(env, obj.obj());
 }
 
 void ChromeBrowserProvider::OnKeywordSearchTermDeleted(
     history::HistoryService* history_service,
     history::URLID url_id) {
 }