components/policy/core/browser/managed_bookmarks_tracker.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/policy/core/browser/managed_bookmarks_tracker.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/callback.h"
  12 #include "base/logging.h"
  13 #include "base/prefs/pref_service.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "base/values.h"
  16 #include "components/bookmarks/browser/bookmark_model.h"
  17 #include "components/bookmarks/browser/bookmark_node.h"
  18 #include "components/bookmarks/common/bookmark_pref_names.h"
  19 #include "grit/components_strings.h"
  20 #include "ui/base/l10n/l10n_util.h"
  21 #include "url/gurl.h"
  22
  23 using bookmarks::BookmarkModel;
  24 using bookmarks::BookmarkNode;
  25 using bookmarks::BookmarkPermanentNode;
  26
  27 namespace policy {
  28
  29 const char ManagedBookmarksTracker::kName[] = "name";
  30 const char ManagedBookmarksTracker::kUrl[] = "url";
  31 const char ManagedBookmarksTracker::kChildren[] = "children";
  32
  33 ManagedBookmarksTracker::ManagedBookmarksTracker(
  34     BookmarkModel* model,
  35     PrefService* prefs,
  36     bool is_supervised,
  37     const GetManagementDomainCallback& callback)
  38     : model_(model),
  39       is_supervised_(is_supervised),
  40       managed_node_(NULL),
  41       prefs_(prefs),
  42       get_management_domain_callback_(callback) {
  43 }
  44
  45 ManagedBookmarksTracker::~ManagedBookmarksTracker() {}
  46
  47 scoped_ptr<base::ListValue>
  48 ManagedBookmarksTracker::GetInitialManagedBookmarks() {
  49   const base::ListValue* list = prefs_->GetList(GetPrefName());
  50   return make_scoped_ptr(list->DeepCopy());
  51 }
  52
  53 // static
  54 int64 ManagedBookmarksTracker::LoadInitial(BookmarkNode* folder,
  55                                            const base::ListValue* list,
  56                                            int64 next_node_id) {
  57   for (size_t i = 0; i < list->GetSize(); ++i) {
  58     // Extract the data for the next bookmark from the |list|.
  59     base::string16 title;
  60     GURL url;
  61     const base::ListValue* children = NULL;
  62     if (!LoadBookmark(list, i, &title, &url, &children))
  63       continue;
  64
  65     BookmarkNode* child = new BookmarkNode(next_node_id++, url);
  66     child->SetTitle(title);
  67     folder->Add(child, folder->child_count());
  68     if (children) {
  69       child->set_type(BookmarkNode::FOLDER);
  70       child->set_date_folder_modified(base::Time::Now());
  71       next_node_id = LoadInitial(child, children, next_node_id);
  72     } else {
  73       child->set_type(BookmarkNode::URL);
  74       child->set_date_added(base::Time::Now());
  75     }
  76   }
  77
  78   return next_node_id;
  79 }
  80
  81 void ManagedBookmarksTracker::Init(BookmarkPermanentNode* managed_node) {
  82   managed_node_ = managed_node;
  83   registrar_.Init(prefs_);
  84   registrar_.Add(GetPrefName(),
  85                  base::Bind(&ManagedBookmarksTracker::ReloadManagedBookmarks,
  86                             base::Unretained(this)));
  87   // Reload now just in case something changed since the initial load started.
  88   ReloadManagedBookmarks();
  89 }
  90
  91 // static
  92 const char* ManagedBookmarksTracker::GetPrefName(bool is_supervised) {
  93   return is_supervised ? bookmarks::prefs::kSupervisedBookmarks
  94                        : bookmarks::prefs::kManagedBookmarks;
  95 }
  96
  97 const char* ManagedBookmarksTracker::GetPrefName() const {
  98   return GetPrefName(is_supervised_);
  99 }
 100
 101 base::string16 ManagedBookmarksTracker::GetBookmarksFolderTitle() const {
 102   if (is_supervised_) {
 103     return l10n_util::GetStringUTF16(
 104         IDS_BOOKMARK_BAR_SUPERVISED_FOLDER_DEFAULT_NAME);
 105   } else {
 106     const std::string domain = get_management_domain_callback_.Run();
 107     if (domain.empty()) {
 108       return l10n_util::GetStringUTF16(
 109           IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME);
 110     } else {
 111       return l10n_util::GetStringFUTF16(
 112           IDS_BOOKMARK_BAR_MANAGED_FOLDER_DOMAIN_NAME,
 113           base::UTF8ToUTF16(domain));
 114     }
 115   }
 116 }
 117
 118 void ManagedBookmarksTracker::ReloadManagedBookmarks() {
 119   // In case the user just signed into or out of the account.
 120   model_->SetTitle(managed_node_, GetBookmarksFolderTitle());
 121
 122   // Recursively update all the managed bookmarks and folders.
 123   const base::ListValue* list = prefs_->GetList(GetPrefName());
 124   UpdateBookmarks(managed_node_, list);
 125
 126   // The managed bookmarks folder isn't visible when that pref isn't present.
 127   managed_node_->set_visible(!managed_node_->empty());
 128 }
 129
 130 void ManagedBookmarksTracker::UpdateBookmarks(const BookmarkNode* folder,
 131                                               const base::ListValue* list) {
 132   int folder_index = 0;
 133   for (size_t i = 0; i < list->GetSize(); ++i) {
 134     // Extract the data for the next bookmark from the |list|.
 135     base::string16 title;
 136     GURL url;
 137     const base::ListValue* children = NULL;
 138     if (!LoadBookmark(list, i, &title, &url, &children)) {
 139       // Skip this bookmark from |list| but don't advance |folder_index|.
 140       continue;
 141     }
 142
 143     // Look for a bookmark at |folder_index| or ahead that matches the current
 144     // bookmark from the pref.
 145     const BookmarkNode* existing = NULL;
 146     for (int k = folder_index; k < folder->child_count(); ++k) {
 147       const BookmarkNode* node = folder->GetChild(k);
 148       if (node->GetTitle() == title &&
 149           ((children && node->is_folder()) ||
 150            (!children && node->url() == url))) {
 151         existing = node;
 152         break;
 153       }
 154     }
 155
 156     if (existing) {
 157       // Reuse the existing node. The Move() is a nop if |existing| is already
 158       // at |folder_index|.
 159       model_->Move(existing, folder, folder_index);
 160       if (children)
 161         UpdateBookmarks(existing, children);
 162     } else {
 163       // Create a new node for this bookmark now.
 164       if (children) {
 165         const BookmarkNode* sub =
 166             model_->AddFolder(folder, folder_index, title);
 167         UpdateBookmarks(sub, children);
 168       } else {
 169         model_->AddURL(folder, folder_index, title, url);
 170       }
 171     }
 172
 173     // The |folder_index| index of |folder| has been updated, so advance it.
 174     ++folder_index;
 175   }
 176
 177   // Remove any extra children of |folder| that haven't been reused.
 178   while (folder->child_count() != folder_index)
 179     model_->Remove(folder, folder_index);
 180 }
 181
 182 // static
 183 bool ManagedBookmarksTracker::LoadBookmark(const base::ListValue* list,
 184                                            size_t index,
 185                                            base::string16* title,
 186                                            GURL* url,
 187                                            const base::ListValue** children) {
 188   std::string spec;
 189   *url = GURL();
 190   *children = NULL;
 191   const base::DictionaryValue* dict = NULL;
 192   if (!list->GetDictionary(index, &dict) ||
 193       !dict->GetString(kName, title) ||
 194       (!dict->GetString(kUrl, &spec) &&
 195        !dict->GetList(kChildren, children))) {
 196     // Should never happen after policy validation.
 197     NOTREACHED();
 198     return false;
 199   }
 200   if (!*children) {
 201     *url = GURL(spec);
 202     DCHECK(url->is_valid());
 203   }
 204   return true;
 205 }
 206
 207 }  // namespace policy