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