Limit access to ChromeBookmarkClient to bookmarks code

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 "chrome/browser/extensions/api/bookmarks/bookmarks_api.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/i18n/time_formatting.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/bookmarks/bookmark_html_writer.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
-#include "chrome/browser/bookmarks/chrome_bookmark_client.h"
-#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h"
 #include "chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h"
 #include "chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h"
 #include "chrome/browser/importer/external_process_importer_host.h"
 #include "chrome/browser/importer/importer_uma.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/api/bookmarks.h"
@@ skipping 66 matching lines @@
   }
 
   RunAndSendResponse();
   return true;
 }
 
 BookmarkModel* BookmarksFunction::GetBookmarkModel() {
   return BookmarkModelFactory::GetForProfile(GetProfile());
 }
 
-ChromeBookmarkClient* BookmarksFunction::GetChromeBookmarkClient() {
-  return ChromeBookmarkClientFactory::GetForProfile(GetProfile());
-}
-
 bool BookmarksFunction::GetBookmarkIdAsInt64(const std::string& id_string,
                                              int64* id) {
   if (base::StringToInt64(id_string, id))
     return true;
 
   error_ = keys::kInvalidIdError;
   return false;
 }
 
 const BookmarkNode* BookmarksFunction::GetBookmarkNodeFromId(
@@ skipping 77 matching lines @@
 
 bool BookmarksFunction::CanBeModified(const BookmarkNode* node) {
   if (!node) {
     error_ = keys::kNoParentError;
     return false;
   }
   if (node->is_root()) {
     error_ = keys::kModifySpecialError;
     return false;
   }
-  ChromeBookmarkClient* client = GetChromeBookmarkClient();
-  if (::bookmarks::IsDescendantOf(node, client->managed_node()) ||
-      ::bookmarks::IsDescendantOf(node, client->supervised_node())) {
+  BookmarkModel* model = GetBookmarkModel();
+  if (::bookmarks::IsDescendantOf(node, model->managed_node()) ||
+      ::bookmarks::IsDescendantOf(node, model->supervised_node())) {
     error_ = keys::kModifyManagedError;
     return false;
   }
   return true;
 }
 
 void BookmarksFunction::BookmarkModelChanged() {
 }
 
 void BookmarksFunction::BookmarkModelLoaded(BookmarkModel* model,
                                             bool ids_reassigned) {
   model->RemoveObserver(this);
   RunAndSendResponse();
   Release();  // Balanced in RunOnReady().
 }
 
 void BookmarksFunction::RunAndSendResponse() {
   bool success = RunOnReady();
   if (success) {
     content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_BOOKMARKS_API_INVOKED,
       content::Source<const Extension>(extension()),
       content::Details<const BookmarksFunction>(this));
   }
   SendResponse(success);
 }
 
 BookmarkEventRouter::BookmarkEventRouter(Profile* profile)
     : browser_context_(profile),
-      model_(BookmarkModelFactory::GetForProfile(profile)),
-      client_(ChromeBookmarkClientFactory::GetForProfile(profile)) {
+      model_(BookmarkModelFactory::GetForProfile(profile)) {
   model_->AddObserver(this);
 }
 
 BookmarkEventRouter::~BookmarkEventRouter() {
   if (model_) {
     model_->RemoveObserver(this);
   }
 }
 
 void BookmarkEventRouter::DispatchEvent(
@@ skipping 31 matching lines @@
   DispatchEvent(
       bookmarks::OnMoved::kEventName,
       bookmarks::OnMoved::Create(base::Int64ToString(node->id()), move_info));
 }
 
 void BookmarkEventRouter::BookmarkNodeAdded(BookmarkModel* model,
                                             const BookmarkNode* parent,
                                             int index) {
   const BookmarkNode* node = parent->GetChild(index);
   scoped_ptr<BookmarkTreeNode> tree_node(
-      bookmark_api_helpers::GetBookmarkTreeNode(client_, node, false, false));
+      bookmark_api_helpers::GetBookmarkTreeNode(model_, node, false, false));
   DispatchEvent(bookmarks::OnCreated::kEventName,
                 bookmarks::OnCreated::Create(base::Int64ToString(node->id()),
                                              *tree_node));
 }
 
 void BookmarkEventRouter::BookmarkNodeRemoved(
     BookmarkModel* model,
     const BookmarkNode* parent,
     int index,
     const BookmarkNode* node,
@@ skipping 98 matching lines @@
       new BookmarkEventRouter(Profile::FromBrowserContext(browser_context_)));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 bool BookmarksGetFunction::RunOnReady() {
   scoped_ptr<bookmarks::Get::Params> params(
       bookmarks::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
-  ChromeBookmarkClient* client = GetChromeBookmarkClient();
+  BookmarkModel* model = GetBookmarkModel();
   if (params->id_or_id_list.as_strings) {
     std::vector<std::string>& ids = *params->id_or_id_list.as_strings;
     size_t count = ids.size();
     EXTENSION_FUNCTION_VALIDATE(count > 0);
     for (size_t i = 0; i < count; ++i) {
       const BookmarkNode* node = GetBookmarkNodeFromId(ids[i]);
       if (!node)
         return false;
-      bookmark_api_helpers::AddNode(client, node, &nodes, false);
+      bookmark_api_helpers::AddNode(model, node, &nodes, false);
     }
   } else {
     const BookmarkNode* node =
         GetBookmarkNodeFromId(*params->id_or_id_list.as_string);
     if (!node)
       return false;
-    bookmark_api_helpers::AddNode(client, node, &nodes, false);
+    bookmark_api_helpers::AddNode(model, node, &nodes, false);
   }
 
   results_ = bookmarks::Get::Results::Create(nodes);
   return true;
 }
 
 bool BookmarksGetChildrenFunction::RunOnReady() {
   scoped_ptr<bookmarks::GetChildren::Params> params(
       bookmarks::GetChildren::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const BookmarkNode* node = GetBookmarkNodeFromId(params->id);
   if (!node)
     return false;
 
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
   int child_count = node->child_count();
   for (int i = 0; i < child_count; ++i) {
     const BookmarkNode* child = node->GetChild(i);
-    bookmark_api_helpers::AddNode(
-        GetChromeBookmarkClient(), child, &nodes, false);
+    bookmark_api_helpers::AddNode(GetBookmarkModel(), child, &nodes, false);
   }
 
   results_ = bookmarks::GetChildren::Results::Create(nodes);
   return true;
 }
 
 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;
   ::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);
+    bookmark_api_helpers::AddNode(GetBookmarkModel(), node, &tree_nodes, false);
   }
 
   results_ = bookmarks::GetRecent::Results::Create(tree_nodes);
   return true;
 }
 
 bool BookmarksGetTreeFunction::RunOnReady() {
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
   const BookmarkNode* node =
       BookmarkModelFactory::GetForProfile(GetProfile())->root_node();
-  bookmark_api_helpers::AddNode(GetChromeBookmarkClient(), node, &nodes, true);
+  bookmark_api_helpers::AddNode(GetBookmarkModel(), node, &nodes, true);
   results_ = bookmarks::GetTree::Results::Create(nodes);
   return true;
 }
 
 bool BookmarksGetSubTreeFunction::RunOnReady() {
   scoped_ptr<bookmarks::GetSubTree::Params> params(
       bookmarks::GetSubTree::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const BookmarkNode* node = GetBookmarkNodeFromId(params->id);
   if (!node)
     return false;
 
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
-  bookmark_api_helpers::AddNode(GetChromeBookmarkClient(), node, &nodes, true);
+  bookmark_api_helpers::AddNode(GetBookmarkModel(), node, &nodes, true);
   results_ = bookmarks::GetSubTree::Results::Create(nodes);
   return true;
 }
 
 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());
@@ skipping 24 matching lines @@
       query.title.reset(new base::string16(base::UTF8ToUTF16(*object.title)));
     ::bookmarks::GetBookmarksMatchingProperties(
         BookmarkModelFactory::GetForProfile(GetProfile()),
         query,
         std::numeric_limits<int>::max(),
         lang,
         &nodes);
   }
 
   std::vector<linked_ptr<BookmarkTreeNode> > tree_nodes;
-  ChromeBookmarkClient* client = GetChromeBookmarkClient();
+  BookmarkModel* model = GetBookmarkModel();
   for (std::vector<const BookmarkNode*>::iterator node_iter = nodes.begin();
        node_iter != nodes.end(); ++node_iter) {
-    bookmark_api_helpers::AddNode(client, *node_iter, &tree_nodes, false);
+    bookmark_api_helpers::AddNode(model, *node_iter, &tree_nodes, false);
   }
 
   results_ = bookmarks::Search::Results::Create(tree_nodes);
   return true;
 }
 
 // static
 bool BookmarksRemoveFunction::ExtractIds(const base::ListValue* args,
                                          std::list<int64>* ids,
                                          bool* invalid_id) {
@@ skipping 18 matching lines @@
 
   int64 id;
   if (!GetBookmarkIdAsInt64(params->id, &id))
     return false;
 
   bool recursive = false;
   if (name() == BookmarksRemoveTreeFunction::function_name())
     recursive = true;
 
   BookmarkModel* model = GetBookmarkModel();
-  ChromeBookmarkClient* client = GetChromeBookmarkClient();
-  if (!bookmark_api_helpers::RemoveNode(model, client, id, recursive, &error_))
+  if (!bookmark_api_helpers::RemoveNode(model, id, recursive, &error_))
     return false;
 
   return true;
 }
 
 bool BookmarksCreateFunction::RunOnReady() {
   if (!EditBookmarksEnabled())
     return false;
 
   scoped_ptr<bookmarks::Create::Params> params(
       bookmarks::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
   const BookmarkNode* node = CreateBookmarkNode(model, params->bookmark, NULL);
   if (!node)
     return false;
 
-  scoped_ptr<BookmarkTreeNode> ret(bookmark_api_helpers::GetBookmarkTreeNode(
-      GetChromeBookmarkClient(), node, false, false));
+  scoped_ptr<BookmarkTreeNode> ret(
+      bookmark_api_helpers::GetBookmarkTreeNode(model, node, false, false));
   results_ = bookmarks::Create::Results::Create(*ret);
 
   return true;
 }
 
 // static
 bool BookmarksMoveFunction::ExtractIds(const base::ListValue* args,
                                        std::list<int64>* ids,
                                        bool* invalid_id) {
   // For now, Move accepts ID parameters in the same way as an Update.
@@ skipping 39 matching lines @@
       error_ = keys::kInvalidIndexError;
       return false;
     }
   } else {
     index = parent->child_count();
   }
 
   model->Move(node, parent, index);
 
   scoped_ptr<BookmarkTreeNode> tree_node(
-      bookmark_api_helpers::GetBookmarkTreeNode(
-          GetChromeBookmarkClient(), node, false, false));
+      bookmark_api_helpers::GetBookmarkTreeNode(model, node, false, false));
   results_ = bookmarks::Move::Results::Create(*tree_node);
 
   return true;
 }
 
 // static
 bool BookmarksUpdateFunction::ExtractIds(const base::ListValue* args,
                                          std::list<int64>* ids,
                                          bool* invalid_id) {
   // For now, Update accepts ID parameters in the same way as an Remove.
@@ skipping 34 matching lines @@
   if (model->is_permanent_node(node)) {
     error_ = keys::kModifySpecialError;
     return false;
   }
   if (has_title)
     model->SetTitle(node, title);
   if (!url.is_empty())
     model->SetURL(node, url);
 
   scoped_ptr<BookmarkTreeNode> tree_node(
-      bookmark_api_helpers::GetBookmarkTreeNode(
-          GetChromeBookmarkClient(), node, false, false));
+      bookmark_api_helpers::GetBookmarkTreeNode(model, node, false, false));
   results_ = bookmarks::Update::Results::Create(*tree_node);
   return true;
 }
 
 BookmarksIOFunction::BookmarksIOFunction() {}
 
 BookmarksIOFunction::~BookmarksIOFunction() {
   // There may be pending file dialogs, we need to tell them that we've gone
   // away so they don't try and call back to us.
   if (select_file_dialog_.get())
@@ skipping 102 matching lines @@
 }
 
 void BookmarksExportFunction::FileSelected(const base::FilePath& path,
                                            int index,
                                            void* params) {
   bookmark_html_writer::WriteBookmarks(GetProfile(), path, NULL);
   Release();  // Balanced in BookmarksIOFunction::SelectFile()
 }
 
 }  // namespace extensions