Added the "unmodifiable" property to chrome.bookmarks.BookmarkTreeNode.

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"
@@ skipping 219 matching lines @@
 void BookmarksFunction::BookmarkModelChanged() {
 }
 
 void BookmarksFunction::BookmarkModelLoaded(BookmarkModel* model,
                                             bool ids_reassigned) {
   model->RemoveObserver(this);
   RunOnReady();
   Release();  // Balanced in RunOnReady().
 }
 
-BookmarkEventRouter::BookmarkEventRouter(BrowserContext* context,
-                                         BookmarkModel* model)
-    : browser_context_(context), model_(model) {
+BookmarkEventRouter::BookmarkEventRouter(Profile* profile)
+    : browser_context_(profile),
+      model_(BookmarkModelFactory::GetForProfile(profile)),
+      client_(
+          BookmarkModelFactory::GetChromeBookmarkClientForProfile(profile)) {

[not at google - send to devlin, 2014/06/05 20:58:26]

kinda weird that BookmarkModelFactory is a BrowserContextKeyedServiceFactory yet
deals in Profiles...

[Joao da Silva, 2014/06/05 21:04:16]

The main getter is GetForProfile(), so I used this name for consistency.

I'm guessing this is fallout from the refactoring where the ProfileKeyedService
APIs were componentized. I'd leave renaming these methods to another CL, if you
don't mind.

[not at google - send to devlin, 2014/06/05 22:21:32]

I didn't mean to imply that it was something to do with your change, sorry.

   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(node, false, false));
+      bookmark_api_helpers::GetBookmarkTreeNode(client_, 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 87 matching lines @@
 static base::LazyInstance<BrowserContextKeyedAPIFactory<BookmarksAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<BookmarksAPI>*
 BookmarksAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void BookmarksAPI::OnListenerAdded(const EventListenerInfo& details) {
-  bookmark_event_router_.reset(new BookmarkEventRouter(
-      browser_context_,
-      BookmarkModelFactory::GetForProfile(
-          Profile::FromBrowserContext(browser_context_))));
+  bookmark_event_router_.reset(
+      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();
   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(node, &nodes, false);
+      bookmark_api_helpers::AddNode(client, node, &nodes, false);
     }
   } else {
     const BookmarkNode* node =
         GetBookmarkNodeFromId(*params->id_or_id_list.as_string);
     if (!node)
       return false;
-    bookmark_api_helpers::AddNode(node, &nodes, false);
+    bookmark_api_helpers::AddNode(client, 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(child, &nodes, false);
+    bookmark_api_helpers::AddNode(
+        GetChromeBookmarkClient(), 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;
   bookmark_utils::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(node, &tree_nodes, false);
+    bookmark_api_helpers::AddNode(
+        GetChromeBookmarkClient(), 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(node, &nodes, true);
+  bookmark_api_helpers::AddNode(GetChromeBookmarkClient(), 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(node, &nodes, true);
+  bookmark_api_helpers::AddNode(GetChromeBookmarkClient(), 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)));
     bookmark_utils::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();
        node_iter != nodes.end(); ++node_iter) {
-    bookmark_api_helpers::AddNode(*node_iter, &tree_nodes, false);
+    bookmark_api_helpers::AddNode(client, *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 37 matching lines @@
 
   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(node, false, false));
+  scoped_ptr<BookmarkTreeNode> ret(bookmark_api_helpers::GetBookmarkTreeNode(
+      GetChromeBookmarkClient(), 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(node, false, false));
+      bookmark_api_helpers::GetBookmarkTreeNode(
+          GetChromeBookmarkClient(), 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(node, false, false));
+      bookmark_api_helpers::GetBookmarkTreeNode(
+          GetChromeBookmarkClient(), node, false, false));
   results_ = bookmarks::Update::Results::Create(*tree_node);
   return true;
 }
 
 // Mapper superclass for BookmarkFunctions.
 template <typename BucketIdType>
 class BookmarkBucketMapper : public BucketMapper {
  public:
   virtual ~BookmarkBucketMapper() { STLDeleteValues(&buckets_); }
  protected:
@@ skipping 302 matching lines @@
 #if !defined(OS_ANDROID)
   // Android does not have support for the standard exporter.
   // TODO(jgreenwald): remove ifdef once extensions are no longer built on
   // Android.
   bookmark_html_writer::WriteBookmarks(GetProfile(), path, NULL);
 #endif
   Release();  // Balanced in BookmarksIOFunction::SelectFile()
 }
 
 }  // namespace extensions