Move bookmark_utils into bookmarks namespace.

chrome/browser/extensions/api/bookmarks/bookmarks_api.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 <algorithm>
 
 #include "chrome/browser/extensions/api/bookmarks/bookmarks_api.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 43 matching lines @@
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_WIN)
 #include "ui/aura/remote_window_tree_host_win.h"
 #endif
 
 namespace extensions {
 
 namespace keys = bookmark_api_constants;
 namespace bookmarks = api::bookmarks;

[sky, 2014/07/14 17:05:50]

I think we should name this to avoid confusing. Or possibly not alias it. This
can be done separately.

 
 using base::TimeDelta;
 using bookmarks::BookmarkTreeNode;
 using bookmarks::CreateDetails;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::WebContents;
 
 typedef QuotaLimitHeuristic::Bucket Bucket;
 typedef QuotaLimitHeuristic::Config Config;
@@ skipping 115 matching lines @@
   error_ = keys::kInvalidIdError;
   return false;
 }
 
 const BookmarkNode* BookmarksFunction::GetBookmarkNodeFromId(
     const std::string& id_string) {
   int64 id;
   if (!GetBookmarkIdAsInt64(id_string, &id))
     return NULL;
 
-  const BookmarkNode* node = GetBookmarkNodeByID(
+  const BookmarkNode* node = ::bookmarks::GetBookmarkNodeByID(
       BookmarkModelFactory::GetForProfile(GetProfile()), id);
   if (!node)
     error_ = keys::kNoNodeError;
 
   return node;
 }
 
 const BookmarkNode* BookmarksFunction::CreateBookmarkNode(
     BookmarkModel* model,
     const CreateDetails& details,
     const BookmarkNode::MetaInfoMap* meta_info) {
   int64 parentId;
 
   if (!details.parent_id.get()) {
     // Optional, default to "other bookmarks".
     parentId = model->other_node()->id();
   } else {
     if (!GetBookmarkIdAsInt64(*details.parent_id, &parentId))
       return NULL;
   }
-  const BookmarkNode* parent = GetBookmarkNodeByID(model, parentId);
+  const BookmarkNode* parent =
+      ::bookmarks::GetBookmarkNodeByID(model, parentId);
   if (!CanBeModified(parent))
     return NULL;
 
   int index;
   if (!details.index.get()) {  // Optional (defaults to end).
     index = parent->child_count();
   } else {
     index = *details.index;
     if (index > parent->child_count() || index < 0) {
       error_ = keys::kInvalidIndexError;
@@ skipping 298 matching lines @@
 }
 
 bool BookmarksGetRecentFunction::RunOnReady() {
   scoped_ptr<bookmarks::GetRecent::Params> params(
       bookmarks::GetRecent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   if (params->number_of_items < 1)
     return false;
 
   std::vector<const BookmarkNode*> nodes;
-  bookmark_utils::GetMostRecentlyAddedEntries(
+  ::bookmarks::GetMostRecentlyAddedEntries(
       BookmarkModelFactory::GetForProfile(GetProfile()),
       params->number_of_items,
       &nodes);
 
   std::vector<linked_ptr<BookmarkTreeNode> > tree_nodes;
   std::vector<const BookmarkNode*>::iterator i = nodes.begin();
   for (; i != nodes.end(); ++i) {
     const BookmarkNode* node = *i;
     bookmark_api_helpers::AddNode(
         GetChromeBookmarkClient(), node, &tree_nodes, false);
@@ skipping 29 matching lines @@
 
 bool BookmarksSearchFunction::RunOnReady() {
   scoped_ptr<bookmarks::Search::Params> params(
       bookmarks::Search::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   PrefService* prefs = user_prefs::UserPrefs::Get(GetProfile());
   std::string lang = prefs->GetString(prefs::kAcceptLanguages);
   std::vector<const BookmarkNode*> nodes;
   if (params->query.as_string) {
-    bookmark_utils::QueryFields query;
+    ::bookmarks::QueryFields query;
     query.word_phrase_query.reset(
         new base::string16(base::UTF8ToUTF16(*params->query.as_string)));
-    bookmark_utils::GetBookmarksMatchingProperties(
+    ::bookmarks::GetBookmarksMatchingProperties(
         BookmarkModelFactory::GetForProfile(GetProfile()),
         query,
         std::numeric_limits<int>::max(),
         lang,
         &nodes);
   } else {
     DCHECK(params->query.as_object);
     const bookmarks::Search::Params::Query::Object& object =
         *params->query.as_object;
-    bookmark_utils::QueryFields query;
+    ::bookmarks::QueryFields query;
     if (object.query) {
       query.word_phrase_query.reset(
           new base::string16(base::UTF8ToUTF16(*object.query)));
     }
     if (object.url)
       query.url.reset(new base::string16(base::UTF8ToUTF16(*object.url)));
     if (object.title)
       query.title.reset(new base::string16(base::UTF8ToUTF16(*object.title)));
-    bookmark_utils::GetBookmarksMatchingProperties(
+    ::bookmarks::GetBookmarksMatchingProperties(
         BookmarkModelFactory::GetForProfile(GetProfile()),
         query,
         std::numeric_limits<int>::max(),
         lang,
         &nodes);
   }
 
   std::vector<linked_ptr<BookmarkTreeNode> > tree_nodes;
   ChromeBookmarkClient* client = GetChromeBookmarkClient();
   for (std::vector<const BookmarkNode*>::iterator node_iter = nodes.begin();
@@ skipping 92 matching lines @@
 
   const BookmarkNode* parent = NULL;
   if (!params->destination.parent_id.get()) {
     // Optional, defaults to current parent.
     parent = node->parent();
   } else {
     int64 parentId;
     if (!GetBookmarkIdAsInt64(*params->destination.parent_id, &parentId))
       return false;
 
-    parent = GetBookmarkNodeByID(model, parentId);
+    parent = ::bookmarks::GetBookmarkNodeByID(model, parentId);
   }
   if (!CanBeModified(parent) || !CanBeModified(node))
     return false;
 
   int index;
   if (params->destination.index.get()) {  // Optional (defaults to end).
     index = *params->destination.index;
     if (index > parent->child_count() || index < 0) {
       error_ = keys::kInvalidIndexError;
       return false;
@@ skipping 102 matching lines @@
     std::string parent_id;
     if (json->HasKey(keys::kParentIdKey)) {
       if (!json->GetString(keys::kParentIdKey, &parent_id))
         return;
     }
     BookmarkModel* model = BookmarkModelFactory::GetForProfile(
         Profile::FromBrowserContext(browser_context_));
 
     int64 parent_id_int64;
     base::StringToInt64(parent_id, &parent_id_int64);
-    const BookmarkNode* parent = GetBookmarkNodeByID(model, parent_id_int64);
+    const BookmarkNode* parent =
+        ::bookmarks::GetBookmarkNodeByID(model, parent_id_int64);
     if (!parent)
       return;
 
     std::string bucket_id = base::UTF16ToUTF8(parent->GetTitle());
     std::string title;
     json->GetString(keys::kTitleKey, &title);
     std::string url_string;
     json->GetString(keys::kUrlKey, &url_string);
 
     bucket_id += title;
@@ skipping 18 matching lines @@
     IdList ids;
     bool invalid_id = false;
     if (!BookmarksRemoveFunction::ExtractIds(args, &ids, &invalid_id) ||
         invalid_id) {
       return;
     }
 
     for (IdList::iterator it = ids.begin(); it != ids.end(); ++it) {
       BookmarkModel* model = BookmarkModelFactory::GetForProfile(
           Profile::FromBrowserContext(browser_context_));
-      const BookmarkNode* node = GetBookmarkNodeByID(model, *it);
+      const BookmarkNode* node = ::bookmarks::GetBookmarkNodeByID(model, *it);
       if (!node || node->is_root())
         return;
 
       std::string bucket_id;
       bucket_id += base::UTF16ToUTF8(node->parent()->GetTitle());
       bucket_id += base::UTF16ToUTF8(node->GetTitle());
       bucket_id += node->url().spec();
       buckets->push_back(GetBucket(base::SHA1HashString(bucket_id)));
     }
   }
@@ skipping 210 matching lines @@
 void BookmarksExportFunction::FileSelected(const base::FilePath& path,
                                            int index,
                                            void* params) {
   // TODO(jgreenwald): remove ifdef once extensions are no longer built on
   // Android.
   bookmark_html_writer::WriteBookmarks(GetProfile(), path, NULL);
   Release();  // Balanced in BookmarksIOFunction::SelectFile()
 }
 
 }  // namespace extensions