1 // Copyright (c) 2012 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.
5 #include "chrome/browser/bookmarks/bookmark_html_writer.h"
7 #include "base/base64.h"
9 #include "base/bind_helpers.h"
10 #include "base/callback.h"
11 #include "base/memory/scoped_ptr.h"
12 #include "base/message_loop/message_loop.h"
13 #include "base/platform_file.h"
14 #include "base/strings/string_number_conversions.h"
15 #include "base/time/time.h"
16 #include "base/values.h"
17 #include "chrome/browser/bookmarks/bookmark_codec.h"
18 #include "chrome/browser/bookmarks/bookmark_model.h"
19 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
20 #include "chrome/browser/chrome_notification_types.h"
21 #include "chrome/browser/favicon/favicon_service.h"
22 #include "chrome/browser/favicon/favicon_service_factory.h"
23 #include "chrome/common/favicon/favicon_types.h"
24 #include "content/public/browser/browser_thread.h"
25 #include "content/public/browser/notification_source.h"
26 #include "grit/generated_resources.h"
27 #include "net/base/escape.h"
28 #include "net/base/file_stream.h"
29 #include "net/base/net_errors.h"
30 #include "ui/base/l10n/l10n_util.h"
31 #include "ui/gfx/favicon_size.h"
33 using content::BrowserThread;
37 static BookmarkFaviconFetcher* fetcher = NULL;
40 const char kHeader[] =
41 "<!DOCTYPE NETSCAPE-Bookmark-file-1>\r\n"
42 "<!-- This is an automatically generated file.\r\n"
43 " It will be read and overwritten.\r\n"
44 " DO NOT EDIT! -->\r\n"
45 "<META HTTP-EQUIV=\"Content-Type\""
46 " CONTENT=\"text/html; charset=UTF-8\">\r\n"
47 "<TITLE>Bookmarks</TITLE>\r\n"
48 "<H1>Bookmarks</H1>\r\n"
52 const char kNewline[] = "\r\n";
54 // The following are used for bookmarks.
56 // Start of a bookmark.
57 const char kBookmarkStart[] = "<DT><A HREF=\"";
58 // After kBookmarkStart.
59 const char kAddDate[] = "\" ADD_DATE=\"";
61 const char kIcon[] = "\" ICON=\"";
63 const char kBookmarkAttributeEnd[] = "\">";
65 const char kBookmarkEnd[] = "</A>";
67 // The following are used when writing folders.
70 const char kFolderStart[] = "<DT><H3 ADD_DATE=\"";
71 // After kFolderStart.
72 const char kLastModified[] = "\" LAST_MODIFIED=\"";
73 // After kLastModified when writing the bookmark bar.
74 const char kBookmarkBar[] = "\" PERSONAL_TOOLBAR_FOLDER=\"true\">";
75 // After kLastModified when writing a user created folder.
76 const char kFolderAttributeEnd[] = "\">";
78 const char kFolderEnd[] = "</H3>";
79 // Start of the children of a folder.
80 const char kFolderChildren[] = "<DL><p>";
81 // End of the children for a folder.
82 const char kFolderChildrenEnd[] = "</DL><p>";
84 // Number of characters to indent by.
85 const size_t kIndentSize = 4;
87 // Class responsible for the actual writing. Takes ownership of favicons_map.
88 class Writer : public base::RefCountedThreadSafe<Writer> {
90 Writer(base::Value* bookmarks,
91 const base::FilePath& path,
92 BookmarkFaviconFetcher::URLFaviconMap* favicons_map,
93 BookmarksExportObserver* observer)
94 : bookmarks_(bookmarks),
96 favicons_map_(favicons_map),
100 // Writing bookmarks and favicons data to file.
106 if (!Write(kHeader) ||
107 bookmarks_->GetType() != Value::TYPE_DICTIONARY ||
108 !static_cast<DictionaryValue*>(bookmarks_.get())->Get(
109 BookmarkCodec::kRootsKey, &roots) ||
110 roots->GetType() != Value::TYPE_DICTIONARY) {
115 DictionaryValue* roots_d_value = static_cast<DictionaryValue*>(roots);
116 Value* root_folder_value;
117 Value* other_folder_value = NULL;
118 Value* mobile_folder_value = NULL;
119 if (!roots_d_value->Get(BookmarkCodec::kRootFolderNameKey,
120 &root_folder_value) ||
121 root_folder_value->GetType() != Value::TYPE_DICTIONARY ||
122 !roots_d_value->Get(BookmarkCodec::kOtherBookmarkFolderNameKey,
123 &other_folder_value) ||
124 other_folder_value->GetType() != Value::TYPE_DICTIONARY ||
125 !roots_d_value->Get(BookmarkCodec::kMobileBookmarkFolderNameKey,
126 &mobile_folder_value) ||
127 mobile_folder_value->GetType() != Value::TYPE_DICTIONARY) {
129 return; // Invalid type for root folder and/or other folder.
134 if (!WriteNode(*static_cast<DictionaryValue*>(root_folder_value),
135 BookmarkNode::BOOKMARK_BAR) ||
136 !WriteNode(*static_cast<DictionaryValue*>(other_folder_value),
137 BookmarkNode::OTHER_NODE) ||
138 !WriteNode(*static_cast<DictionaryValue*>(mobile_folder_value),
139 BookmarkNode::MOBILE)) {
145 Write(kFolderChildrenEnd);
147 // File stream close is forced so that unit test could read it.
148 file_stream_.reset();
154 friend class base::RefCountedThreadSafe<Writer>;
156 // Types of text being written out. The type dictates how the text is
159 // The text is the value of an html attribute, eg foo in
163 // Actual content, eg foo in <h1>foo</h2>.
169 // Opens the file, returning true on success.
171 file_stream_.reset(new net::FileStream(NULL));
172 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE;
173 return (file_stream_->OpenSync(path_, flags) == net::OK);
176 // Increments the indent.
177 void IncrementIndent() {
178 indent_.resize(indent_.size() + kIndentSize, ' ');
181 // Decrements the indent.
182 void DecrementIndent() {
183 DCHECK(!indent_.empty());
184 indent_.resize(indent_.size() - kIndentSize, ' ');
187 // Called at the end of the export process.
188 void NotifyOnFinish() {
189 if (observer_ != NULL) {
190 observer_->OnExportFinished();
194 // Writes raw text out returning true on success. This does not escape
195 // the text in anyway.
196 bool Write(const std::string& text) {
197 // net::FileStream does not allow 0-byte writes.
200 size_t wrote = file_stream_->WriteSync(text.c_str(), text.length());
201 bool result = (wrote == text.length());
206 // Writes out the text string (as UTF8). The text is escaped based on
208 bool Write(const std::string& text, TextType type) {
209 DCHECK(IsStringUTF8(text));
210 std::string utf8_string;
213 case ATTRIBUTE_VALUE:
214 // Convert " to "
216 ReplaceSubstringsAfterOffset(&utf8_string, 0, "\"", """);
220 utf8_string = net::EscapeForHTML(text);
227 return Write(utf8_string);
230 // Indents the current line.
232 return Write(indent_);
235 // Converts a time string written to the JSON codec into a time_t string
236 // (used by bookmarks.html) and writes it.
237 bool WriteTime(const std::string& time_string) {
238 int64 internal_value;
239 base::StringToInt64(time_string, &internal_value);
240 return Write(base::Int64ToString(
241 base::Time::FromInternalValue(internal_value).ToTimeT()));
244 // Writes the node and all its children, returning true on success.
245 bool WriteNode(const DictionaryValue& value,
246 BookmarkNode::Type folder_type) {
247 std::string title, date_added_string, type_string;
248 if (!value.GetString(BookmarkCodec::kNameKey, &title) ||
249 !value.GetString(BookmarkCodec::kDateAddedKey, &date_added_string) ||
250 !value.GetString(BookmarkCodec::kTypeKey, &type_string) ||
251 (type_string != BookmarkCodec::kTypeURL &&
252 type_string != BookmarkCodec::kTypeFolder)) {
257 if (type_string == BookmarkCodec::kTypeURL) {
258 std::string url_string;
259 if (!value.GetString(BookmarkCodec::kURLKey, &url_string)) {
264 std::string favicon_string;
265 BookmarkFaviconFetcher::URLFaviconMap::iterator itr =
266 favicons_map_->find(url_string);
267 if (itr != favicons_map_->end()) {
268 scoped_refptr<base::RefCountedMemory> data(itr->second.get());
269 std::string favicon_data;
270 favicon_data.assign(reinterpret_cast<const char*>(data->front()),
272 std::string favicon_base64_encoded;
273 if (base::Base64Encode(favicon_data, &favicon_base64_encoded)) {
274 GURL favicon_url("data:image/png;base64," + favicon_base64_encoded);
275 favicon_string = favicon_url.spec();
279 if (!WriteIndent() ||
280 !Write(kBookmarkStart) ||
281 !Write(url_string, ATTRIBUTE_VALUE) ||
283 !WriteTime(date_added_string) ||
284 (!favicon_string.empty() &&
286 !Write(favicon_string, ATTRIBUTE_VALUE))) ||
287 !Write(kBookmarkAttributeEnd) ||
288 !Write(title, CONTENT) ||
289 !Write(kBookmarkEnd) ||
297 std::string last_modified_date;
298 const Value* child_values = NULL;
299 if (!value.GetString(BookmarkCodec::kDateModifiedKey,
300 &last_modified_date) ||
301 !value.Get(BookmarkCodec::kChildrenKey, &child_values) ||
302 child_values->GetType() != Value::TYPE_LIST) {
306 if (folder_type != BookmarkNode::OTHER_NODE &&
307 folder_type != BookmarkNode::MOBILE) {
308 // The other/mobile folder name are not written out. This gives the effect
309 // of making the contents of the 'other folder' be a sibling to the
310 // bookmark bar folder.
311 if (!WriteIndent() ||
312 !Write(kFolderStart) ||
313 !WriteTime(date_added_string) ||
314 !Write(kLastModified) ||
315 !WriteTime(last_modified_date)) {
318 if (folder_type == BookmarkNode::BOOKMARK_BAR) {
319 if (!Write(kBookmarkBar))
321 title = l10n_util::GetStringUTF8(IDS_BOOKMARK_BAR_FOLDER_NAME);
322 } else if (!Write(kFolderAttributeEnd)) {
325 if (!Write(title, CONTENT) ||
326 !Write(kFolderEnd) ||
329 !Write(kFolderChildren) ||
336 // Write the children.
337 const ListValue* children = static_cast<const ListValue*>(child_values);
338 for (size_t i = 0; i < children->GetSize(); ++i) {
339 const Value* child_value;
340 if (!children->Get(i, &child_value) ||
341 child_value->GetType() != Value::TYPE_DICTIONARY) {
345 if (!WriteNode(*static_cast<const DictionaryValue*>(child_value),
346 BookmarkNode::FOLDER)) {
350 if (folder_type != BookmarkNode::OTHER_NODE &&
351 folder_type != BookmarkNode::MOBILE) {
352 // Close out the folder.
354 if (!WriteIndent() ||
355 !Write(kFolderChildrenEnd) ||
363 // The BookmarkModel as a Value. This value was generated from the
365 scoped_ptr<Value> bookmarks_;
367 // Path we're writing to.
368 base::FilePath path_;
370 // Map that stores favicon per URL.
371 scoped_ptr<BookmarkFaviconFetcher::URLFaviconMap> favicons_map_;
373 // Observer to be notified on finish.
374 BookmarksExportObserver* observer_;
376 // File we're writing to.
377 scoped_ptr<net::FileStream> file_stream_;
379 // How much we indent when writing a bookmark/folder. This is modified
380 // via IncrementIndent and DecrementIndent.
383 DISALLOW_COPY_AND_ASSIGN(Writer);
388 BookmarkFaviconFetcher::BookmarkFaviconFetcher(
390 const base::FilePath& path,
391 BookmarksExportObserver* observer)
394 observer_(observer) {
395 favicons_map_.reset(new URLFaviconMap());
397 chrome::NOTIFICATION_PROFILE_DESTROYED,
398 content::Source<Profile>(profile_));
401 BookmarkFaviconFetcher::~BookmarkFaviconFetcher() {
404 void BookmarkFaviconFetcher::ExportBookmarks() {
405 ExtractUrls(BookmarkModelFactory::GetForProfile(
406 profile_)->bookmark_bar_node());
407 ExtractUrls(BookmarkModelFactory::GetForProfile(profile_)->other_node());
408 ExtractUrls(BookmarkModelFactory::GetForProfile(profile_)->mobile_node());
409 if (!bookmark_urls_.empty())
415 void BookmarkFaviconFetcher::Observe(
417 const content::NotificationSource& source,
418 const content::NotificationDetails& details) {
419 if (chrome::NOTIFICATION_PROFILE_DESTROYED == type && fetcher != NULL) {
420 base::MessageLoop::current()->DeleteSoon(FROM_HERE, fetcher);
425 void BookmarkFaviconFetcher::ExtractUrls(const BookmarkNode* node) {
426 if (node->is_url()) {
427 std::string url = node->url().spec();
429 bookmark_urls_.push_back(url);
431 for (int i = 0; i < node->child_count(); ++i)
432 ExtractUrls(node->GetChild(i));
436 void BookmarkFaviconFetcher::ExecuteWriter() {
437 // BookmarkModel isn't thread safe (nor would we want to lock it down
438 // for the duration of the write), as such we make a copy of the
439 // BookmarkModel using BookmarkCodec then write from that.
441 BrowserThread::PostTask(
442 BrowserThread::FILE, FROM_HERE,
443 base::Bind(&Writer::DoWrite,
444 new Writer(codec.Encode(BookmarkModelFactory::GetForProfile(
446 path_, favicons_map_.release(), observer_)));
447 if (fetcher != NULL) {
448 base::MessageLoop::current()->DeleteSoon(FROM_HERE, fetcher);
453 bool BookmarkFaviconFetcher::FetchNextFavicon() {
454 if (bookmark_urls_.empty()) {
458 std::string url = bookmark_urls_.front();
459 // Filter out urls that we've already got favicon for.
460 URLFaviconMap::const_iterator iter = favicons_map_->find(url);
461 if (favicons_map_->end() == iter) {
462 FaviconService* favicon_service = FaviconServiceFactory::GetForProfile(
463 profile_, Profile::EXPLICIT_ACCESS);
464 favicon_service->GetRawFaviconForURL(
465 FaviconService::FaviconForURLParams(
466 profile_, GURL(url), chrome::FAVICON, gfx::kFaviconSize),
467 ui::SCALE_FACTOR_100P,
468 base::Bind(&BookmarkFaviconFetcher::OnFaviconDataAvailable,
469 base::Unretained(this)),
470 &cancelable_task_tracker_);
473 bookmark_urls_.pop_front();
475 } while (!bookmark_urls_.empty());
479 void BookmarkFaviconFetcher::OnFaviconDataAvailable(
480 const chrome::FaviconBitmapResult& bitmap_result) {
482 if (!bookmark_urls_.empty()) {
483 url = GURL(bookmark_urls_.front());
484 bookmark_urls_.pop_front();
486 if (bitmap_result.is_valid() && !url.is_empty()) {
487 favicons_map_->insert(
488 make_pair(url.spec(), bitmap_result.bitmap_data));
491 if (FetchNextFavicon()) {
497 namespace bookmark_html_writer {
499 void WriteBookmarks(Profile* profile,
500 const base::FilePath& path,
501 BookmarksExportObserver* observer) {
502 // BookmarkModel isn't thread safe (nor would we want to lock it down
503 // for the duration of the write), as such we make a copy of the
504 // BookmarkModel using BookmarkCodec then write from that.
505 if (fetcher == NULL) {
506 fetcher = new BookmarkFaviconFetcher(profile, path, observer);
507 fetcher->ExportBookmarks();
511 } // namespace bookmark_html_writer