Move bookmark_utils into bookmarks namespace.

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 206 matching lines @@
                             int64* result) {
     DCHECK(BrowserThread::CurrentlyOn(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 = GetBookmarkNodeByID(model, parent_id);
+        parent_node = bookmarks::GetBookmarkNodeByID(model, parent_id);
       if (!parent_node)
         parent_node = model->bookmark_bar_node();
 
       if (is_folder)
         node = model->AddFolder(parent_node, parent_node->child_count(), title);
       else
         node = model->AddURL(parent_node, 0, title, gurl);
     }
 
     *result = node ? node ->id() : kInvalidBookmarkId;
@@ skipping 14 matching lines @@
 
   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));
-    const BookmarkNode* node = GetBookmarkNodeByID(model, id);
+    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.
   virtual void BookmarkNodeRemoved(
       BookmarkModel* bookmark_model,
       const BookmarkNode* parent,
@@ skipping 52 matching lines @@
                    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));
-    const BookmarkNode* node = GetBookmarkNodeByID(model, id);
+    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);
       }
 
       if (parent_id >= 0 &&
           (!node->parent() || parent_id != node->parent()->id())) {
-        const BookmarkNode* new_parent = GetBookmarkNodeByID(model, parent_id);
+        const BookmarkNode* new_parent =
+            bookmarks::GetBookmarkNodeByID(model, parent_id);
 
         if (new_parent)
           model->Move(node, new_parent, 0);
       }
     }
   }
 
   // Verify that the bookmark was actually updated. Called synchronously.
   virtual void BookmarkNodeChanged(BookmarkModel* bookmark_model,
                                    const BookmarkNode* node) OVERRIDE {
@@ skipping 21 matching lines @@
         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(result);
-    *result = GetBookmarkNodeByID(model, id) != NULL;
+    *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(result);
-    const BookmarkNode* node = GetBookmarkNodeByID(model, id);
+    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:
   DISALLOW_COPY_AND_ASSIGN(IsInMobileBookmarksBranchTask);
 };
@@ skipping 15 matching lines @@
   }
 
   static void RunOnUIThread(BookmarkModel* model,
                             const base::string16& title,
                             const int64 parent_id,
                             int64* result) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(result);
 
     // Invalid ids are assumed to refer to the Mobile Bookmarks folder.
-    const BookmarkNode* parent = parent_id >= 0 ?
-        GetBookmarkNodeByID(model, parent_id) : model->mobile_node();
+    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(),
                                                  &in_mobile_bookmarks);
     if (!in_mobile_bookmarks) {
       // The parent folder must be inside the Mobile Bookmarks folder.
       *result = kInvalidBookmarkId;
       return;
     }
@@ skipping 88 matching lines @@
         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));
-    const BookmarkNode* node = GetBookmarkNodeByID(model, id);
+    const BookmarkNode* node = bookmarks::GetBookmarkNodeByID(model, id);
     if (!node || !jnode)
       return;
 
     ScopedJavaGlobalRef<jobject> jparent;
     if (get_parent) {
       ConvertBookmarkNode(node->parent(), ScopedJavaLocalRef<jobject>(),
                           &jparent);
     }
 
     ConvertBookmarkNode(node, jparent, jnode);
@@ skipping 1057 matching lines @@
     Java_ChromeBrowserProvider_onBookmarkChanged(env, obj.obj());
   } else if (type ==
       chrome::NOTIFICATION_HISTORY_KEYWORD_SEARCH_TERM_UPDATED) {
     JNIEnv* env = AttachCurrentThread();
     ScopedJavaLocalRef<jobject> obj = weak_java_provider_.get(env);
     if (obj.is_null())
       return;
     Java_ChromeBrowserProvider_onSearchTermChanged(env, obj.obj());
   }
 }