OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/bookmarks/chrome_bookmark_client.h" | 5 #include "chrome/browser/bookmarks/chrome_bookmark_client.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/bind_helpers.h" | 8 #include "base/bind_helpers.h" |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "base/values.h" | 10 #include "base/values.h" |
(...skipping 25 matching lines...) Expand all Loading... | |
36 if (bitmap_result.is_valid()) { | 36 if (bitmap_result.is_valid()) { |
37 result.image = gfx::Image::CreateFrom1xPNGBytes( | 37 result.image = gfx::Image::CreateFrom1xPNGBytes( |
38 bitmap_result.bitmap_data->front(), bitmap_result.bitmap_data->size()); | 38 bitmap_result.bitmap_data->front(), bitmap_result.bitmap_data->size()); |
39 result.icon_url = bitmap_result.icon_url; | 39 result.icon_url = bitmap_result.icon_url; |
40 callback.Run(result); | 40 callback.Run(result); |
41 return; | 41 return; |
42 } | 42 } |
43 callback.Run(result); | 43 callback.Run(result); |
44 } | 44 } |
45 | 45 |
46 bool IsDescendantOf(const BookmarkNode* node, const BookmarkNode* root) { | |
47 return node && node->HasAncestor(root); | |
48 } | |
49 | |
50 // Returns true if any node in |list| is a descendant of |root|. | |
51 bool HasDescendantsOf(const std::vector<const BookmarkNode*>& list, | |
52 const BookmarkNode* root) { | |
53 for (size_t i = 0; i < list.size(); ++i) { | |
sky
2015/02/04 18:36:58
nit: use new for loop
Marc Treib
2015/02/05 12:57:06
Done.
| |
54 if (IsDescendantOf(list[i], root)) | |
55 return true; | |
56 } | |
57 return false; | |
58 } | |
59 | |
60 void LoadInitialContents(BookmarkPermanentNode* node, | |
61 base::ListValue* initial_bookmarks, | |
62 int64* next_node_id) { | |
63 // Load the initial contents of the |node| now, and assign it an unused ID. | |
64 int64 id = *next_node_id; | |
65 node->set_id(id); | |
66 *next_node_id = policy::ManagedBookmarksTracker::LoadInitial( | |
67 node, initial_bookmarks, id + 1); | |
68 node->set_visible(!node->empty()); | |
69 } | |
70 | |
46 } // namespace | 71 } // namespace |
47 | 72 |
48 ChromeBookmarkClient::ChromeBookmarkClient(Profile* profile) | 73 ChromeBookmarkClient::ChromeBookmarkClient(Profile* profile) |
49 : profile_(profile), | 74 : profile_(profile), |
50 history_service_(NULL), | 75 history_service_(NULL), |
51 model_(NULL), | 76 model_(NULL), |
52 managed_node_(NULL) { | 77 managed_node_(NULL), |
78 supervised_node_(NULL) { | |
53 } | 79 } |
54 | 80 |
55 ChromeBookmarkClient::~ChromeBookmarkClient() { | 81 ChromeBookmarkClient::~ChromeBookmarkClient() { |
56 } | 82 } |
57 | 83 |
58 void ChromeBookmarkClient::Init(BookmarkModel* model) { | 84 void ChromeBookmarkClient::Init(BookmarkModel* model) { |
59 DCHECK(model); | 85 DCHECK(model); |
60 DCHECK(!model_); | 86 DCHECK(!model_); |
61 model_ = model; | 87 model_ = model; |
62 model_->AddObserver(this); | 88 model_->AddObserver(this); |
63 | 89 |
64 managed_bookmarks_tracker_.reset(new policy::ManagedBookmarksTracker( | 90 managed_bookmarks_tracker_.reset(new policy::ManagedBookmarksTracker( |
65 model_, | 91 model_, |
66 profile_->GetPrefs(), | 92 profile_->GetPrefs(), |
93 false, | |
67 base::Bind(&ChromeBookmarkClient::GetManagedBookmarksDomain, | 94 base::Bind(&ChromeBookmarkClient::GetManagedBookmarksDomain, |
68 base::Unretained(this)))); | 95 base::Unretained(this)))); |
96 supervised_bookmarks_tracker_.reset(new policy::ManagedBookmarksTracker( | |
97 model_, | |
98 profile_->GetPrefs(), | |
99 true, | |
100 base::Callback<std::string()>())); | |
69 } | 101 } |
70 | 102 |
71 void ChromeBookmarkClient::Shutdown() { | 103 void ChromeBookmarkClient::Shutdown() { |
72 favicon_changed_subscription_.reset(); | 104 favicon_changed_subscription_.reset(); |
73 if (model_) { | 105 if (model_) { |
74 model_->RemoveObserver(this); | 106 model_->RemoveObserver(this); |
75 model_ = NULL; | 107 model_ = NULL; |
76 } | 108 } |
77 BookmarkClient::Shutdown(); | 109 BookmarkClient::Shutdown(); |
78 } | 110 } |
79 | 111 |
80 bool ChromeBookmarkClient::IsDescendantOfManagedNode(const BookmarkNode* node) { | 112 bool ChromeBookmarkClient::IsDescendantOfManagedNode(const BookmarkNode* node) { |
81 return node && node->HasAncestor(managed_node_); | 113 return IsDescendantOf(node, managed_node_); |
82 } | 114 } |
83 | 115 |
84 bool ChromeBookmarkClient::HasDescendantsOfManagedNode( | 116 bool ChromeBookmarkClient::HasDescendantsOfManagedNode( |
85 const std::vector<const BookmarkNode*>& list) { | 117 const std::vector<const BookmarkNode*>& list) { |
86 for (size_t i = 0; i < list.size(); ++i) { | 118 return HasDescendantsOf(list, managed_node_); |
87 if (IsDescendantOfManagedNode(list[i])) | 119 } |
88 return true; | 120 |
89 } | 121 bool ChromeBookmarkClient::IsDescendantOfSupervisedNode( |
90 return false; | 122 const BookmarkNode* node) { |
123 return IsDescendantOf(node, supervised_node_); | |
124 } | |
125 | |
126 bool ChromeBookmarkClient::HasDescendantsOfSupervisedNode( | |
127 const std::vector<const BookmarkNode*>& list) { | |
128 return HasDescendantsOf(list, supervised_node_); | |
129 } | |
130 | |
131 bool ChromeBookmarkClient::IsDescendantOfManagedOrSupervisedNode( | |
132 const BookmarkNode* node) { | |
133 return IsDescendantOfManagedNode(node) || IsDescendantOfSupervisedNode(node); | |
134 } | |
135 | |
136 bool ChromeBookmarkClient::HasDescendantsOfManagedOrSupervisedNode( | |
137 const std::vector<const BookmarkNode*>& list) { | |
138 return HasDescendantsOfManagedNode(list) || | |
139 HasDescendantsOfSupervisedNode(list); | |
91 } | 140 } |
92 | 141 |
93 bool ChromeBookmarkClient::PreferTouchIcon() { | 142 bool ChromeBookmarkClient::PreferTouchIcon() { |
94 #if !defined(OS_IOS) | 143 #if !defined(OS_IOS) |
95 return false; | 144 return false; |
96 #else | 145 #else |
97 return true; | 146 return true; |
98 #endif | 147 #endif |
99 } | 148 } |
100 | 149 |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
143 NodeTypedCountPair pair(*i, typed_count); | 192 NodeTypedCountPair pair(*i, typed_count); |
144 node_typed_count_pairs->push_back(pair); | 193 node_typed_count_pairs->push_back(pair); |
145 } | 194 } |
146 } | 195 } |
147 | 196 |
148 bool ChromeBookmarkClient::IsPermanentNodeVisible( | 197 bool ChromeBookmarkClient::IsPermanentNodeVisible( |
149 const BookmarkPermanentNode* node) { | 198 const BookmarkPermanentNode* node) { |
150 DCHECK(node->type() == BookmarkNode::BOOKMARK_BAR || | 199 DCHECK(node->type() == BookmarkNode::BOOKMARK_BAR || |
151 node->type() == BookmarkNode::OTHER_NODE || | 200 node->type() == BookmarkNode::OTHER_NODE || |
152 node->type() == BookmarkNode::MOBILE || | 201 node->type() == BookmarkNode::MOBILE || |
153 node == managed_node_); | 202 node == managed_node_ || |
154 if (node == managed_node_) | 203 node == supervised_node_); |
204 if (node == managed_node_ || node == supervised_node_) | |
155 return false; | 205 return false; |
156 #if !defined(OS_IOS) | 206 #if !defined(OS_IOS) |
157 return node->type() != BookmarkNode::MOBILE; | 207 return node->type() != BookmarkNode::MOBILE; |
158 #else | 208 #else |
159 return node->type() == BookmarkNode::MOBILE; | 209 return node->type() == BookmarkNode::MOBILE; |
160 #endif | 210 #endif |
161 } | 211 } |
162 | 212 |
163 void ChromeBookmarkClient::RecordAction(const base::UserMetricsAction& action) { | 213 void ChromeBookmarkClient::RecordAction(const base::UserMetricsAction& action) { |
164 content::RecordAction(action); | 214 content::RecordAction(action); |
165 } | 215 } |
166 | 216 |
167 bookmarks::LoadExtraCallback ChromeBookmarkClient::GetLoadExtraNodesCallback() { | 217 bookmarks::LoadExtraCallback ChromeBookmarkClient::GetLoadExtraNodesCallback() { |
168 // Create the managed_node now; it will be populated in the LoadExtraNodes | 218 // Create the managed_node_ and supervised_node_ now; they will be populated |
169 // callback. | 219 // in the LoadExtraNodes callback. |
170 // The ownership of managed_node_ is in limbo until LoadExtraNodes runs, | 220 // The ownership of managed_node_ and supervised_node_ is in limbo until |
171 // so we leave it in the care of the closure meanwhile. | 221 // LoadExtraNodes runs, so we leave them in the care of the closure meanwhile. |
172 scoped_ptr<BookmarkPermanentNode> managed(new BookmarkPermanentNode(0)); | 222 scoped_ptr<BookmarkPermanentNode> managed(new BookmarkPermanentNode(0)); |
173 managed_node_ = managed.get(); | 223 managed_node_ = managed.get(); |
224 scoped_ptr<BookmarkPermanentNode> supervised(new BookmarkPermanentNode(1)); | |
sky
2015/02/04 18:36:58
This conflicts with the id of the bookmark bar.
Marc Treib
2015/02/05 12:57:06
Where is that defined, and what ID can I use inste
sky
2015/02/05 17:57:11
From BookmarkNode:
// Returns an unique id for
Marc Treib
2015/02/06 13:40:37
I've taken another look, and I don't think that's
| |
225 supervised_node_ = supervised.get(); | |
174 | 226 |
175 return base::Bind( | 227 return base::Bind( |
176 &ChromeBookmarkClient::LoadExtraNodes, | 228 &ChromeBookmarkClient::LoadExtraNodes, |
177 base::Passed(&managed), | 229 base::Passed(&managed), |
178 base::Passed(managed_bookmarks_tracker_->GetInitialManagedBookmarks())); | 230 base::Passed(managed_bookmarks_tracker_->GetInitialManagedBookmarks()), |
231 base::Passed(&supervised), | |
232 base::Passed( | |
233 supervised_bookmarks_tracker_->GetInitialManagedBookmarks())); | |
179 } | 234 } |
180 | 235 |
181 bool ChromeBookmarkClient::CanSetPermanentNodeTitle( | 236 bool ChromeBookmarkClient::CanSetPermanentNodeTitle( |
182 const BookmarkNode* permanent_node) { | 237 const BookmarkNode* permanent_node) { |
183 // The |managed_node_| can have its title updated if the user signs in or | 238 // The |managed_node_| can have its title updated if the user signs in or |
184 // out. | 239 // out, since the name of the managed domain can appear in it. The |
185 return !IsDescendantOfManagedNode(permanent_node) || | 240 // |supervised_node_| has a fixed title which can never be updated. |
241 return !IsDescendantOfManagedOrSupervisedNode(permanent_node) || | |
186 permanent_node == managed_node_; | 242 permanent_node == managed_node_; |
187 } | 243 } |
188 | 244 |
189 bool ChromeBookmarkClient::CanSyncNode(const BookmarkNode* node) { | 245 bool ChromeBookmarkClient::CanSyncNode(const BookmarkNode* node) { |
190 return !IsDescendantOfManagedNode(node); | 246 return !IsDescendantOfManagedOrSupervisedNode(node); |
191 } | 247 } |
192 | 248 |
193 bool ChromeBookmarkClient::CanBeEditedByUser(const BookmarkNode* node) { | 249 bool ChromeBookmarkClient::CanBeEditedByUser(const BookmarkNode* node) { |
194 return !IsDescendantOfManagedNode(node); | 250 return !IsDescendantOfManagedOrSupervisedNode(node); |
195 } | 251 } |
196 | 252 |
197 void ChromeBookmarkClient::SetHistoryService(HistoryService* history_service) { | 253 void ChromeBookmarkClient::SetHistoryService(HistoryService* history_service) { |
198 DCHECK(history_service); | 254 DCHECK(history_service); |
199 history_service_ = history_service; | 255 history_service_ = history_service; |
200 favicon_changed_subscription_ = history_service_->AddFaviconChangedCallback( | 256 favicon_changed_subscription_ = history_service_->AddFaviconChangedCallback( |
201 base::Bind(&BookmarkModel::OnFaviconChanged, base::Unretained(model_))); | 257 base::Bind(&BookmarkModel::OnFaviconChanged, base::Unretained(model_))); |
202 } | 258 } |
203 | 259 |
204 void ChromeBookmarkClient::BookmarkModelChanged() { | 260 void ChromeBookmarkClient::BookmarkModelChanged() { |
(...skipping 11 matching lines...) Expand all Loading... | |
216 | 272 |
217 void ChromeBookmarkClient::BookmarkAllUserNodesRemoved( | 273 void ChromeBookmarkClient::BookmarkAllUserNodesRemoved( |
218 BookmarkModel* model, | 274 BookmarkModel* model, |
219 const std::set<GURL>& removed_urls) { | 275 const std::set<GURL>& removed_urls) { |
220 if (history_service_) | 276 if (history_service_) |
221 history_service_->URLsNoLongerBookmarked(removed_urls); | 277 history_service_->URLsNoLongerBookmarked(removed_urls); |
222 } | 278 } |
223 | 279 |
224 void ChromeBookmarkClient::BookmarkModelLoaded(BookmarkModel* model, | 280 void ChromeBookmarkClient::BookmarkModelLoaded(BookmarkModel* model, |
225 bool ids_reassigned) { | 281 bool ids_reassigned) { |
226 // Start tracking the managed bookmarks. This will detect any changes that | 282 // Start tracking the managed and supervised bookmarks. This will detect any |
227 // may have occurred while the initial managed bookmarks were being loaded | 283 // changes that may have occurred while the initial managed and supervised |
228 // on the background. | 284 // bookmarks were being loaded on the background. |
229 managed_bookmarks_tracker_->Init(managed_node_); | 285 managed_bookmarks_tracker_->Init(managed_node_); |
286 supervised_bookmarks_tracker_->Init(supervised_node_); | |
230 } | 287 } |
231 | 288 |
232 // static | 289 // static |
233 bookmarks::BookmarkPermanentNodeList ChromeBookmarkClient::LoadExtraNodes( | 290 bookmarks::BookmarkPermanentNodeList ChromeBookmarkClient::LoadExtraNodes( |
234 scoped_ptr<BookmarkPermanentNode> managed_node, | 291 scoped_ptr<BookmarkPermanentNode> managed_node, |
235 scoped_ptr<base::ListValue> initial_managed_bookmarks, | 292 scoped_ptr<base::ListValue> initial_managed_bookmarks, |
293 scoped_ptr<BookmarkPermanentNode> supervised_node, | |
294 scoped_ptr<base::ListValue> initial_supervised_bookmarks, | |
236 int64* next_node_id) { | 295 int64* next_node_id) { |
237 // Load the initial contents of the |managed_node| now, and assign it an | 296 LoadInitialContents( |
238 // unused ID. | 297 managed_node.get(), initial_managed_bookmarks.get(), next_node_id); |
239 int64 managed_id = *next_node_id; | 298 managed_node->SetTitle(l10n_util::GetStringUTF16( |
240 managed_node->set_id(managed_id); | 299 IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME)); |
241 *next_node_id = policy::ManagedBookmarksTracker::LoadInitial( | 300 |
242 managed_node.get(), initial_managed_bookmarks.get(), managed_id + 1); | 301 LoadInitialContents( |
243 managed_node->set_visible(!managed_node->empty()); | 302 supervised_node.get(), initial_supervised_bookmarks.get(), next_node_id); |
244 managed_node->SetTitle( | 303 supervised_node->SetTitle(l10n_util::GetStringUTF16( |
245 l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME)); | 304 IDS_BOOKMARK_BAR_SUPERVISED_FOLDER_DEFAULT_NAME)); |
246 | 305 |
247 bookmarks::BookmarkPermanentNodeList extra_nodes; | 306 bookmarks::BookmarkPermanentNodeList extra_nodes; |
248 // Ownership of the managed node passed to the caller. | 307 // Ownership of the managed and supervised nodes passed to the caller. |
249 extra_nodes.push_back(managed_node.release()); | 308 extra_nodes.push_back(managed_node.release()); |
309 extra_nodes.push_back(supervised_node.release()); | |
250 | 310 |
251 return extra_nodes.Pass(); | 311 return extra_nodes.Pass(); |
252 } | 312 } |
253 | 313 |
254 std::string ChromeBookmarkClient::GetManagedBookmarksDomain() { | 314 std::string ChromeBookmarkClient::GetManagedBookmarksDomain() { |
255 policy::ProfilePolicyConnector* connector = | 315 policy::ProfilePolicyConnector* connector = |
256 policy::ProfilePolicyConnectorFactory::GetForProfile(profile_); | 316 policy::ProfilePolicyConnectorFactory::GetForProfile(profile_); |
257 if (connector->IsPolicyFromCloudPolicy(policy::key::kManagedBookmarks)) | 317 if (connector->IsPolicyFromCloudPolicy(policy::key::kManagedBookmarks)) |
258 return connector->GetManagementDomain(); | 318 return connector->GetManagementDomain(); |
259 return std::string(); | 319 return std::string(); |
260 } | 320 } |
OLD | NEW |