Managed bookmarks for supervised users

components/policy/core/browser/managed_bookmarks_tracker.cc

 // Copyright 2014 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 "components/policy/core/browser/managed_bookmarks_tracker.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 10 matching lines @@
 
 namespace policy {
 
 const char ManagedBookmarksTracker::kName[] = "name";
 const char ManagedBookmarksTracker::kUrl[] = "url";
 const char ManagedBookmarksTracker::kChildren[] = "children";
 
 ManagedBookmarksTracker::ManagedBookmarksTracker(
     BookmarkModel* model,
     PrefService* prefs,
+    bool is_supervised,
     const GetManagementDomainCallback& callback)
     : model_(model),
+      is_supervised_(is_supervised),
       managed_node_(NULL),
       prefs_(prefs),
       get_management_domain_callback_(callback) {
 }
 
 ManagedBookmarksTracker::~ManagedBookmarksTracker() {}
 
 scoped_ptr<base::ListValue>
 ManagedBookmarksTracker::GetInitialManagedBookmarks() {
-  const base::ListValue* list =
-      prefs_->GetList(bookmarks::prefs::kManagedBookmarks);
+  const base::ListValue* list = prefs_->GetList(GetPrefName());
   return make_scoped_ptr(list->DeepCopy());
 }
 
 // static
 int64 ManagedBookmarksTracker::LoadInitial(BookmarkNode* folder,
                                            const base::ListValue* list,
                                            int64 next_node_id) {
   for (size_t i = 0; i < list->GetSize(); ++i) {
     // Extract the data for the next bookmark from the |list|.
     base::string16 title;
@@ skipping 14 matching lines @@
       child->set_date_added(base::Time::Now());
     }
   }
 
   return next_node_id;
 }
 
 void ManagedBookmarksTracker::Init(BookmarkPermanentNode* managed_node) {
   managed_node_ = managed_node;
   registrar_.Init(prefs_);
-  registrar_.Add(bookmarks::prefs::kManagedBookmarks,
+  registrar_.Add(GetPrefName(),
                  base::Bind(&ManagedBookmarksTracker::ReloadManagedBookmarks,
                             base::Unretained(this)));
   // Reload now just in case something changed since the initial load started.
   ReloadManagedBookmarks();
 }
 
+// static
+const char* ManagedBookmarksTracker::GetPrefName(bool is_supervised) {
+  return is_supervised ? bookmarks::prefs::kSupervisedBookmarks
+                       : bookmarks::prefs::kManagedBookmarks;
+}
+
+const char* ManagedBookmarksTracker::GetPrefName() const {
+  return GetPrefName(is_supervised_);
+}
+
+base::string16 ManagedBookmarksTracker::GetBookmarksFolderTitle() const {
+  if (is_supervised_) {
+    return l10n_util::GetStringUTF16(
+        IDS_BOOKMARK_BAR_SUPERVISED_FOLDER_DEFAULT_NAME);
+  } else {
+    std::string domain = get_management_domain_callback_.Run();
+    if (domain.empty()) {
+      return l10n_util::GetStringUTF16(
+          IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME);
+    } else {
+      return l10n_util::GetStringFUTF16(
+          IDS_BOOKMARK_BAR_MANAGED_FOLDER_DOMAIN_NAME,
+          base::UTF8ToUTF16(domain));
+    }
+  }
+}
+
 void ManagedBookmarksTracker::ReloadManagedBookmarks() {
-  // Update the managed bookmarks folder title, in case the user just signed
-  // into or out of a managed account.
-  base::string16 title;
-  std::string domain = get_management_domain_callback_.Run();
-  if (domain.empty()) {
-    title =
-        l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME);
-  } else {
-    title = l10n_util::GetStringFUTF16(
-        IDS_BOOKMARK_BAR_MANAGED_FOLDER_DOMAIN_NAME, base::UTF8ToUTF16(domain));
-  }
-  model_->SetTitle(managed_node_, title);
+  // In case the user just signed into or out of a managed account.
+  model_->SetTitle(managed_node_, GetBookmarksFolderTitle());
 
   // Recursively update all the managed bookmarks and folders.
-  const base::ListValue* list =
-      prefs_->GetList(bookmarks::prefs::kManagedBookmarks);
+  const base::ListValue* list = prefs_->GetList(GetPrefName());
   UpdateBookmarks(managed_node_, list);
 
   // The managed bookmarks folder isn't visible when that policy isn't present.
   managed_node_->set_visible(!managed_node_->empty());
 }
 
 void ManagedBookmarksTracker::UpdateBookmarks(const BookmarkNode* folder,
                                               const base::ListValue* list) {
   int folder_index = 0;
   for (size_t i = 0; i < list->GetSize(); ++i) {
@@ skipping 56 matching lines @@
   *children = NULL;
   const base::DictionaryValue* dict = NULL;
   if (!list->GetDictionary(index, &dict) ||
       !dict->GetString(kName, title) ||
       (!dict->GetString(kUrl, &spec) &&
        !dict->GetList(kChildren, children))) {
     // Should never happen after policy validation.
     NOTREACHED();
     return false;
   }
-  if (!*children)
+  if (!*children) {
     *url = GURL(spec);
+    if (!url->is_valid())
+      return false;

[Pam (message me for reviews), 2015/01/14 14:03:37]

Adding validation to an existing set of users' data may have unintended side
effects. Will this trip on JS bookmarklets, for example? Or is anyone using the
bookmark system to push random other snippets of text to their users?

[Marc Treib, 2015/01/14 16:40:50]

The policy checks for valid URLs elsewhere, so this shouldn't ever get
triggered. Our code didn't (it does now), and putting an invalid URL here
resulted in a crash somewhere in the bookmarks code, which is why I added this
check.
I've replaced it with a DCHECK.

+  }
   return true;
 }
 
 }  // namespace policy