Made the bookmarks extension APIs aware of managed bookmarks.

chrome/test/data/extensions/api_test/bookmarks/test.js

 // 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.
 
 // bookmarks api test
 // browser_tests.exe --gtest_filter=ExtensionApiTest.Bookmarks
 
 // This is global state that is maintained across tests as a reference
 // to compare against what's fetched from the browser (using compareTrees).
 // TODO(erikkay) It would be better if each test was self-contained and
 // didn't depend on global state.
 var expected = [
   {"children": [
       {children:[], id:"1", parentId:"0", index:0, title:"Bookmarks bar"},
-      {children:[], id:"2", parentId:"0", index:1, title:"Other bookmarks"}
+      {children:[], id:"2", parentId:"0", index:1, title:"Other bookmarks"},
+      {id:"4", parentId:"0", index:3, title:"Managed bookmarks", children:[
+          {id:"5", parentId:"4", index:0, title:"Managed Bookmark",
+           url: "http://www.chromium.org/"},
+          {id:"6", parentId:"4", index:1, title:"Managed Folder", children:[]}
+        ]
+      }
     ],
    id:"0", title:""
   }
 ];
 
 function bookmarksBar() { return expected[0].children[0]; }
 function otherBookmarks() { return expected[0].children[1]; }
 
 // Some variables that are used across multiple tests.
 var node1 = {parentId:"1", title:"bar baz",
@@ skipping 97 matching lines @@
 function run() {
 chrome.test.runTests([
   function getTree() {
     verifyTreeIsExpected(pass());
   },
 
   function get() {
     chrome.bookmarks.get("1", pass(function(results) {
       chrome.test.assertTrue(compareNode(results[0], expected[0].children[0]));
     }));
+    chrome.bookmarks.get("5", pass(function(results) {
+      chrome.test.assertTrue(compareNode(
+          results[0], expected[0].children[2].children[0]));
+    }));
     chrome.bookmarks.get("42", fail("Can't find bookmark for id."));
   },
 
   function getArray() {
     chrome.bookmarks.get(["1", "2"], pass(function(results) {
       chrome.test.assertTrue(compareNode(results[0], expected[0].children[0]),
                              "get() result != expected");
       chrome.test.assertTrue(compareNode(results[1], expected[0].children[1]),
                              "get() result != expected");
     }));
@@ skipping 43 matching lines @@
                              "created node != source");
     }));
   },
 
   function createInRoot() {
     const error = "Can't modify the root bookmark folders.";
     var node = {parentId:"0", title:"g404", url:"http://www.google.com/404"};
     chrome.bookmarks.create(node, fail(error));
   },
 
+  function createInManaged() {
+    const error = "Can't modify managed bookmarks.";
+    var node = {parentId:"4", title:"g404", url:"http://www.google.com/404"};
+    chrome.bookmarks.create(node, fail(error));
+  },
+
   function createFolder() {
     var node = {parentId:"1", title:"foo bar"};  // folder
     chrome.test.listenOnce(chrome.bookmarks.onCreated, function(id, created) {
       node.id = created.id;
       node.index = 1;
       node.children = [];
       chrome.test.assertTrue(compareNode(node, created));
     });
     chrome.bookmarks.create(node, pass(function(results) {
       node.id = results.id;  // since we couldn't know this going in
@@ skipping 73 matching lines @@
       folder.parentId = results.parentId;
       folder.index = results.index;
 
       var folder2 = expected[0].children[0].children.pop();
       chrome.test.assertEq(folder2.id, folder.id);
       expected[0].children[1].children.push(folder2);
       verifyTreeIsExpected(pass());
     }));
   },
 
+  function moveToManaged() {
+    var managed_node = expected[0].children[2];
+    chrome.test.assertEq("4", managed_node.id);
+    const error = "Can't modify managed bookmarks.";
+    chrome.bookmarks.move(node1.id, {parentId:managed_node.id}, fail(error));
+    verifyTreeIsExpected(pass());
+  },
+
+  function moveFromManaged() {
+    var managed_node = expected[0].children[2];
+    var moving_node = managed_node.children[0];
+    var other = expected[0].children[1];
+    const error = "Can't modify managed bookmarks.";
+    chrome.bookmarks.move(moving_node.id, {parentId:other.id}, fail(error));
+    verifyTreeIsExpected(pass());
+  },
+
   function search() {
     chrome.bookmarks.search("baz bar", pass(function(results) {
       // matches node1 & node3
       chrome.test.assertEq(2, results.length);
     }));
     chrome.bookmarks.search("www hello", pass(function(results) {
       // matches node1 & node3
       chrome.test.assertEq(2, results.length);
     }));
     chrome.bookmarks.search("bar example",
                             pass(function(results) {
       // matches node2
       chrome.test.assertEq(1, results.length);
     }));
     chrome.bookmarks.search("foo bar", pass(function(results) {
       // matches node3 & folder "foo bar" from createFolder
       chrome.test.assertEq(2, results.length);
     }));
     chrome.bookmarks.search("quux", pass(function(results) {
       // matches node2 & node1
       chrome.test.assertEq(2, results.length);
     }));
     chrome.bookmarks.search("Bookmark Bar", pass(function(results) {
       // Does not match any node since permanent nodes are stripped from search
       chrome.test.assertEq(0, results.length);
     }));
+    chrome.bookmarks.search("Managed", pass(function(results) {
+      // Matches the Managed Bookmark and the Managed Folder but not the
+      // managed_node.
+      chrome.test.assertEq(2, results.length);
+    }));
   },
 
   function update() {
     var title = "hello world";
     chrome.test.listenOnce(chrome.bookmarks.onChanged, function(id, changes) {
       chrome.test.assertEq(title, changes.title);
     });
     chrome.bookmarks.update(node1.id, {"title": title}, pass(function(results) {
       chrome.test.assertEq(title, results.title);
     }));
@@ skipping 21 matching lines @@
         function(results) {
           chrome.bookmarks.get(node1.id, pass(function(results) {
             chrome.test.assertEq(url, results[0].url);
             chrome.test.log("URL UNCHANGED");
           }));
         })
       );
     }));
   },
 
+  function updateManaged() {
+    var managed_node = expected[0].children[2];
+    var updating_node = managed_node.children[0];
+    const error = "Can't modify managed bookmarks.";
+    chrome.bookmarks.update(updating_node.id, {"title": "New"}, fail(error));
+  },
+
   function remove() {
     var parentId = node1.parentId;
     chrome.test.listenOnce(chrome.bookmarks.onRemoved,
                            function(id, removeInfo) {
       chrome.test.assertEq(id, node1.id);
       chrome.test.assertEq(removeInfo.parentId, parentId);
       chrome.test.assertEq(removeInfo.index, node1.index);
     });
     chrome.bookmarks.remove(node1.id, pass(function() {
       // Update expected to match.
       // We removed node1, which means that the index of the other two nodes
       // changes as well.
       expected[0].children[1].children[1].children.shift();
       expected[0].children[1].children[1].children[0].index = 0;
       expected[0].children[1].children[1].children[1].index = 1;
       verifyTreeIsExpected(pass());
     }));
   },
 
+  function removeManaged() {
+    var managed_node = expected[0].children[2];
+    var removing_node = managed_node.children[0];
+    const error = "Can't modify managed bookmarks.";
+    chrome.bookmarks.remove(removing_node.id, fail(error));
+  },
+
   function searchRemoved() {
       // Search for deleted node
       chrome.bookmarks.search("baz bar", pass(function(results) {
         // matches only node3 since node1 was removed
         chrome.test.assertEq(1, results.length);
       }));
   },
 
   function removeTree() {
     var parentId = node2.parentId;
     var folder = expected[0].children[1].children[1];
     chrome.test.listenOnce(chrome.bookmarks.onRemoved,
                            function(id, removeInfo) {
       chrome.test.assertEq(id, folder.id);
       chrome.test.assertEq(removeInfo.parentId, folder.parentId);
       chrome.test.assertEq(removeInfo.index, folder.index);
     });
     chrome.bookmarks.removeTree(parentId, pass(function(){
       // Update expected to match.
       expected[0].children[1].children.pop();
       verifyTreeIsExpected(pass());
     }));
   },
 
+  function removeManagedTree() {
+    var managed_node = expected[0].children[2];
+    var managed_folder = managed_node.children[1];
+    const error = "Can't modify managed bookmarks.";
+    chrome.bookmarks.removeTree(managed_folder.id, fail(error));
+  },
+
   function searchRemovedTree() {
     // Search for deleted folder and enclosed node3
     chrome.bookmarks.search("foo bar", pass(function(results) {
       // Does not match anything since folder was removed with node3 in it
       chrome.test.assertEq(0, results.length);
     }));
   },
 
   function quotaLimitedCreate() {
     var node = {parentId:"1", title:"quotacreate", url:"http://www.quota.com/"};
@@ skipping 77 matching lines @@
   function getRecent() {
     var failed = false;
     try {
       chrome.bookmarks.getRecent(0, function() {});
     } catch (ex) {
       failed = true;
     }
     chrome.test.assertTrue(failed, "Calling with 0 should fail");
 
     chrome.bookmarks.getRecent(10000, pass(function(results) {
-      chrome.test.assertEq(3, results.length,
+      // Should include the "Managed Bookmark".
+      chrome.test.assertEq(4, results.length,
                            "Should have gotten all recent bookmarks");
     }));
 
     chrome.bookmarks.getRecent(2, pass(function(results) {
       chrome.test.assertEq(2, results.length,
                            "Should only get the last 2 bookmarks");
 
       chrome.test.assertTrue(compareNode(node3, results[0]));
       chrome.test.assertTrue(compareNode(node2, results[1]));
     }));
@@ skipping 13 matching lines @@
           function(result) {
         chrome.test.assertEq(newTitle, result.title);
         chrome.test.assertFalse('url' in result)
       }));
     });
   }
 ]);
 }
 
 run();