chrome/browser/bookmarks/bookmark_html_writer.cc

   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.
   4
   5 #include "chrome/browser/bookmarks/bookmark_html_writer.h"
   6
   7 #include "base/base64.h"
   8 #include "base/bind.h"
   9 #include "base/bind_helpers.h"
  10 #include "base/callback.h"
  11 #include "base/files/file.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/time/time.h"
  17 #include "base/values.h"
  18 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
  19 #include "chrome/browser/chrome_notification_types.h"
  20 #include "chrome/browser/favicon/favicon_service.h"
  21 #include "chrome/browser/favicon/favicon_service_factory.h"
  22 #include "components/bookmarks/browser/bookmark_codec.h"
  23 #include "components/bookmarks/browser/bookmark_model.h"
  24 #include "components/favicon_base/favicon_types.h"
  25 #include "content/public/browser/browser_thread.h"
  26 #include "content/public/browser/notification_source.h"
  27 #include "grit/components_strings.h"
  28 #include "net/base/escape.h"
  29 #include "ui/base/l10n/l10n_util.h"
  30 #include "ui/gfx/favicon_size.h"
  31
  32 using bookmarks::BookmarkCodec;
  33 using content::BrowserThread;
  34
  35 namespace {
  36
  37 static BookmarkFaviconFetcher* fetcher = NULL;
  38
  39 // File header.
  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"
  49     "<DL><p>\r\n";
  50
  51 // Newline separator.
  52 const char kNewline[] = "\r\n";
  53
  54 // The following are used for bookmarks.
  55
  56 // Start of a bookmark.
  57 const char kBookmarkStart[] = "<DT><A HREF=\"";
  58 // After kBookmarkStart.
  59 const char kAddDate[] = "\" ADD_DATE=\"";
  60 // After kAddDate.
  61 const char kIcon[] = "\" ICON=\"";
  62 // After kIcon.
  63 const char kBookmarkAttributeEnd[] = "\">";
  64 // End of a bookmark.
  65 const char kBookmarkEnd[] = "</A>";
  66
  67 // The following are used when writing folders.
  68
  69 // Start of a folder.
  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[] = "\">";
  77 // End of the folder.
  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>";
  83
  84 // Number of characters to indent by.
  85 const size_t kIndentSize = 4;
  86
  87 // Class responsible for the actual writing. Takes ownership of favicons_map.
  88 class Writer : public base::RefCountedThreadSafe<Writer> {
  89  public:
  90   Writer(base::Value* bookmarks,
  91          const base::FilePath& path,
  92          BookmarkFaviconFetcher::URLFaviconMap* favicons_map,
  93          BookmarksExportObserver* observer)
  94       : bookmarks_(bookmarks),
  95         path_(path),
  96         favicons_map_(favicons_map),
  97         observer_(observer) {
  98   }
  99
 100   // Writing bookmarks and favicons data to file.
 101   void DoWrite() {
 102     if (!OpenFile())
 103       return;
 104
 105     base::Value* roots = NULL;
 106     if (!Write(kHeader) ||
 107         bookmarks_->GetType() != base::Value::TYPE_DICTIONARY ||
 108         !static_cast<base::DictionaryValue*>(bookmarks_.get())->Get(
 109             BookmarkCodec::kRootsKey, &roots) ||
 110         roots->GetType() != base::Value::TYPE_DICTIONARY) {
 111       NOTREACHED();
 112       return;
 113     }
 114
 115     base::DictionaryValue* roots_d_value =
 116         static_cast<base::DictionaryValue*>(roots);
 117     base::Value* root_folder_value;
 118     base::Value* other_folder_value = NULL;
 119     base::Value* mobile_folder_value = NULL;
 120     if (!roots_d_value->Get(BookmarkCodec::kRootFolderNameKey,
 121                             &root_folder_value) ||
 122         root_folder_value->GetType() != base::Value::TYPE_DICTIONARY ||
 123         !roots_d_value->Get(BookmarkCodec::kOtherBookmarkFolderNameKey,
 124                             &other_folder_value) ||
 125         other_folder_value->GetType() != base::Value::TYPE_DICTIONARY ||
 126         !roots_d_value->Get(BookmarkCodec::kMobileBookmarkFolderNameKey,
 127                             &mobile_folder_value) ||
 128         mobile_folder_value->GetType() != base::Value::TYPE_DICTIONARY) {
 129       NOTREACHED();
 130       return;  // Invalid type for root folder and/or other folder.
 131     }
 132
 133     IncrementIndent();
 134
 135     if (!WriteNode(*static_cast<base::DictionaryValue*>(root_folder_value),
 136                    BookmarkNode::BOOKMARK_BAR) ||
 137         !WriteNode(*static_cast<base::DictionaryValue*>(other_folder_value),
 138                    BookmarkNode::OTHER_NODE) ||
 139         !WriteNode(*static_cast<base::DictionaryValue*>(mobile_folder_value),
 140                    BookmarkNode::MOBILE)) {
 141       return;
 142     }
 143
 144     DecrementIndent();
 145
 146     Write(kFolderChildrenEnd);
 147     Write(kNewline);
 148     // File close is forced so that unit test could read it.
 149     file_.reset();
 150
 151     NotifyOnFinish();
 152   }
 153
 154  private:
 155   friend class base::RefCountedThreadSafe<Writer>;
 156
 157   // Types of text being written out. The type dictates how the text is
 158   // escaped.
 159   enum TextType {
 160     // The text is the value of an html attribute, eg foo in
 161     // <a href="foo">.
 162     ATTRIBUTE_VALUE,
 163
 164     // Actual content, eg foo in <h1>foo</h2>.
 165     CONTENT
 166   };
 167
 168   ~Writer() {}
 169
 170   // Opens the file, returning true on success.
 171   bool OpenFile() {
 172     int flags = base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE;
 173     file_.reset(new base::File(path_, flags));
 174     return file_->IsValid();
 175   }
 176
 177   // Increments the indent.
 178   void IncrementIndent() {
 179     indent_.resize(indent_.size() + kIndentSize, ' ');
 180   }
 181
 182   // Decrements the indent.
 183   void DecrementIndent() {
 184     DCHECK(!indent_.empty());
 185     indent_.resize(indent_.size() - kIndentSize, ' ');
 186   }
 187
 188   // Called at the end of the export process.
 189   void NotifyOnFinish() {
 190     if (observer_ != NULL) {
 191       observer_->OnExportFinished();
 192     }
 193   }
 194
 195   // Writes raw text out returning true on success. This does not escape
 196   // the text in anyway.
 197   bool Write(const std::string& text) {
 198     if (!text.length())
 199       return true;
 200     size_t wrote = file_->WriteAtCurrentPos(text.c_str(), text.length());
 201     bool result = (wrote == text.length());
 202     DCHECK(result);
 203     return result;
 204   }
 205
 206   // Writes out the text string (as UTF8). The text is escaped based on
 207   // type.
 208   bool Write(const std::string& text, TextType type) {
 209     DCHECK(base::IsStringUTF8(text));
 210     std::string utf8_string;
 211
 212     switch (type) {
 213       case ATTRIBUTE_VALUE:
 214         // Convert " to &quot;
 215         utf8_string = text;
 216         ReplaceSubstringsAfterOffset(&utf8_string, 0, "\"", "&quot;");
 217         break;
 218
 219       case CONTENT:
 220         utf8_string = net::EscapeForHTML(text);
 221         break;
 222
 223       default:
 224         NOTREACHED();
 225     }
 226
 227     return Write(utf8_string);
 228   }
 229
 230   // Indents the current line.
 231   bool WriteIndent() {
 232     return Write(indent_);
 233   }
 234
 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()));
 242   }
 243
 244   // Writes the node and all its children, returning true on success.
 245   bool WriteNode(const base::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))  {
 253       NOTREACHED();
 254       return false;
 255     }
 256
 257     if (type_string == BookmarkCodec::kTypeURL) {
 258       std::string url_string;
 259       if (!value.GetString(BookmarkCodec::kURLKey, &url_string)) {
 260         NOTREACHED();
 261         return false;
 262       }
 263
 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_base64_encoded;
 270         base::Base64Encode(std::string(data->front_as<char>(), data->size()),
 271                            &favicon_base64_encoded);
 272         GURL favicon_url("data:image/png;base64," + favicon_base64_encoded);
 273         favicon_string = favicon_url.spec();
 274       }
 275
 276       if (!WriteIndent() ||
 277           !Write(kBookmarkStart) ||
 278           !Write(url_string, ATTRIBUTE_VALUE) ||
 279           !Write(kAddDate) ||
 280           !WriteTime(date_added_string) ||
 281           (!favicon_string.empty() &&
 282               (!Write(kIcon) ||
 283                !Write(favicon_string, ATTRIBUTE_VALUE))) ||
 284           !Write(kBookmarkAttributeEnd) ||
 285           !Write(title, CONTENT) ||
 286           !Write(kBookmarkEnd) ||
 287           !Write(kNewline)) {
 288         return false;
 289       }
 290       return true;
 291     }
 292
 293     // Folder.
 294     std::string last_modified_date;
 295     const base::Value* child_values = NULL;
 296     if (!value.GetString(BookmarkCodec::kDateModifiedKey,
 297                          &last_modified_date) ||
 298         !value.Get(BookmarkCodec::kChildrenKey, &child_values) ||
 299         child_values->GetType() != base::Value::TYPE_LIST) {
 300       NOTREACHED();
 301       return false;
 302     }
 303     if (folder_type != BookmarkNode::OTHER_NODE &&
 304         folder_type != BookmarkNode::MOBILE) {
 305       // The other/mobile folder name are not written out. This gives the effect
 306       // of making the contents of the 'other folder' be a sibling to the
 307       // bookmark bar folder.
 308       if (!WriteIndent() ||
 309           !Write(kFolderStart) ||
 310           !WriteTime(date_added_string) ||
 311           !Write(kLastModified) ||
 312           !WriteTime(last_modified_date)) {
 313         return false;
 314       }
 315       if (folder_type == BookmarkNode::BOOKMARK_BAR) {
 316         if (!Write(kBookmarkBar))
 317           return false;
 318         title = l10n_util::GetStringUTF8(IDS_BOOKMARK_BAR_FOLDER_NAME);
 319       } else if (!Write(kFolderAttributeEnd)) {
 320         return false;
 321       }
 322       if (!Write(title, CONTENT) ||
 323           !Write(kFolderEnd) ||
 324           !Write(kNewline) ||
 325           !WriteIndent() ||
 326           !Write(kFolderChildren) ||
 327           !Write(kNewline)) {
 328         return false;
 329       }
 330       IncrementIndent();
 331     }
 332
 333     // Write the children.
 334     const base::ListValue* children =
 335         static_cast<const base::ListValue*>(child_values);
 336     for (size_t i = 0; i < children->GetSize(); ++i) {
 337       const base::Value* child_value;
 338       if (!children->Get(i, &child_value) ||
 339           child_value->GetType() != base::Value::TYPE_DICTIONARY) {
 340         NOTREACHED();
 341         return false;
 342       }
 343       if (!WriteNode(*static_cast<const base::DictionaryValue*>(child_value),
 344                      BookmarkNode::FOLDER)) {
 345         return false;
 346       }
 347     }
 348     if (folder_type != BookmarkNode::OTHER_NODE &&
 349         folder_type != BookmarkNode::MOBILE) {
 350       // Close out the folder.
 351       DecrementIndent();
 352       if (!WriteIndent() ||
 353           !Write(kFolderChildrenEnd) ||
 354           !Write(kNewline)) {
 355         return false;
 356       }
 357     }
 358     return true;
 359   }
 360
 361   // The BookmarkModel as a base::Value. This value was generated from the
 362   // BookmarkCodec.
 363   scoped_ptr<base::Value> bookmarks_;
 364
 365   // Path we're writing to.
 366   base::FilePath path_;
 367
 368   // Map that stores favicon per URL.
 369   scoped_ptr<BookmarkFaviconFetcher::URLFaviconMap> favicons_map_;
 370
 371   // Observer to be notified on finish.
 372   BookmarksExportObserver* observer_;
 373
 374   // File we're writing to.
 375   scoped_ptr<base::File> file_;
 376
 377   // How much we indent when writing a bookmark/folder. This is modified
 378   // via IncrementIndent and DecrementIndent.
 379   std::string indent_;
 380
 381   DISALLOW_COPY_AND_ASSIGN(Writer);
 382 };
 383
 384 }  // namespace
 385
 386 BookmarkFaviconFetcher::BookmarkFaviconFetcher(
 387     Profile* profile,
 388     const base::FilePath& path,
 389     BookmarksExportObserver* observer)
 390     : profile_(profile),
 391       path_(path),
 392       observer_(observer) {
 393   favicons_map_.reset(new URLFaviconMap());
 394   registrar_.Add(this,
 395                  chrome::NOTIFICATION_PROFILE_DESTROYED,
 396                  content::Source<Profile>(profile_));
 397 }
 398
 399 BookmarkFaviconFetcher::~BookmarkFaviconFetcher() {
 400 }
 401
 402 void BookmarkFaviconFetcher::ExportBookmarks() {
 403   ExtractUrls(BookmarkModelFactory::GetForProfile(
 404       profile_)->bookmark_bar_node());
 405   ExtractUrls(BookmarkModelFactory::GetForProfile(profile_)->other_node());
 406   ExtractUrls(BookmarkModelFactory::GetForProfile(profile_)->mobile_node());
 407   if (!bookmark_urls_.empty())
 408     FetchNextFavicon();
 409   else
 410     ExecuteWriter();
 411 }
 412
 413 void BookmarkFaviconFetcher::Observe(
 414     int type,
 415     const content::NotificationSource& source,
 416     const content::NotificationDetails& details) {
 417   if (chrome::NOTIFICATION_PROFILE_DESTROYED == type && fetcher != NULL) {
 418     base::MessageLoop::current()->DeleteSoon(FROM_HERE, fetcher);
 419     fetcher = NULL;
 420   }
 421 }
 422
 423 void BookmarkFaviconFetcher::ExtractUrls(const BookmarkNode* node) {
 424   if (node->is_url()) {
 425     std::string url = node->url().spec();
 426     if (!url.empty())
 427       bookmark_urls_.push_back(url);
 428   } else {
 429     for (int i = 0; i < node->child_count(); ++i)
 430       ExtractUrls(node->GetChild(i));
 431   }
 432 }
 433
 434 void BookmarkFaviconFetcher::ExecuteWriter() {
 435   // BookmarkModel isn't thread safe (nor would we want to lock it down
 436   // for the duration of the write), as such we make a copy of the
 437   // BookmarkModel using BookmarkCodec then write from that.
 438   BookmarkCodec codec;
 439   BrowserThread::PostTask(
 440       BrowserThread::FILE, FROM_HERE,
 441       base::Bind(&Writer::DoWrite,
 442                  new Writer(codec.Encode(BookmarkModelFactory::GetForProfile(
 443                                 profile_)),
 444                             path_, favicons_map_.release(), observer_)));
 445   if (fetcher != NULL) {
 446     base::MessageLoop::current()->DeleteSoon(FROM_HERE, fetcher);
 447     fetcher = NULL;
 448   }
 449 }
 450
 451 bool BookmarkFaviconFetcher::FetchNextFavicon() {
 452   if (bookmark_urls_.empty()) {
 453     return false;
 454   }
 455   do {
 456     std::string url = bookmark_urls_.front();
 457     // Filter out urls that we've already got favicon for.
 458     URLFaviconMap::const_iterator iter = favicons_map_->find(url);
 459     if (favicons_map_->end() == iter) {
 460       FaviconService* favicon_service = FaviconServiceFactory::GetForProfile(
 461           profile_, Profile::EXPLICIT_ACCESS);
 462       favicon_service->GetRawFaviconForPageURL(
 463           GURL(url),
 464           favicon_base::FAVICON,
 465           gfx::kFaviconSize,
 466           base::Bind(&BookmarkFaviconFetcher::OnFaviconDataAvailable,
 467                      base::Unretained(this)),
 468           &cancelable_task_tracker_);
 469       return true;
 470     } else {
 471       bookmark_urls_.pop_front();
 472     }
 473   } while (!bookmark_urls_.empty());
 474   return false;
 475 }
 476
 477 void BookmarkFaviconFetcher::OnFaviconDataAvailable(
 478     const favicon_base::FaviconRawBitmapResult& bitmap_result) {
 479   GURL url;
 480   if (!bookmark_urls_.empty()) {
 481     url = GURL(bookmark_urls_.front());
 482     bookmark_urls_.pop_front();
 483   }
 484   if (bitmap_result.is_valid() && !url.is_empty()) {
 485     favicons_map_->insert(
 486         make_pair(url.spec(), bitmap_result.bitmap_data));
 487   }
 488
 489   if (FetchNextFavicon()) {
 490     return;
 491   }
 492   ExecuteWriter();
 493 }
 494
 495 namespace bookmark_html_writer {
 496
 497 void WriteBookmarks(Profile* profile,
 498                     const base::FilePath& path,
 499                     BookmarksExportObserver* observer) {
 500   // BookmarkModel isn't thread safe (nor would we want to lock it down
 501   // for the duration of the write), as such we make a copy of the
 502   // BookmarkModel using BookmarkCodec then write from that.
 503   if (fetcher == NULL) {
 504     fetcher = new BookmarkFaviconFetcher(profile, path, observer);
 505     fetcher->ExportBookmarks();
 506   }
 507 }
 508
 509 }  // namespace bookmark_html_writer