Home | History | Annotate | Download | only in bookmarks 
      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/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"
     32 
     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     Value* roots = NULL;
    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) {
    111       NOTREACHED();
    112       return;
    113     }
    114 
    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) {
    128       NOTREACHED();
    129       return;  // Invalid type for root folder and/or other folder.
    130     }
    131 
    132     IncrementIndent();
    133 
    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)) {
    140       return;
    141     }
    142 
    143     DecrementIndent();
    144 
    145     Write(kFolderChildrenEnd);
    146     Write(kNewline);
    147     // File stream close is forced so that unit test could read it.
    148     file_stream_.reset();
    149 
    150     NotifyOnFinish();
    151   }
    152 
    153  private:
    154   friend class base::RefCountedThreadSafe<Writer>;
    155 
    156   // Types of text being written out. The type dictates how the text is
    157   // escaped.
    158   enum TextType {
    159     // The text is the value of an html attribute, eg foo in
    160     // <a href="foo">.
    161     ATTRIBUTE_VALUE,
    162 
    163     // Actual content, eg foo in <h1>foo</h2>.
    164     CONTENT
    165   };
    166 
    167   ~Writer() {}
    168 
    169   // Opens the file, returning true on success.
    170   bool OpenFile() {
    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);
    174   }
    175 
    176   // Increments the indent.
    177   void IncrementIndent() {
    178     indent_.resize(indent_.size() + kIndentSize, ' ');
    179   }
    180 
    181   // Decrements the indent.
    182   void DecrementIndent() {
    183     DCHECK(!indent_.empty());
    184     indent_.resize(indent_.size() - kIndentSize, ' ');
    185   }
    186 
    187   // Called at the end of the export process.
    188   void NotifyOnFinish() {
    189     if (observer_ != NULL) {
    190       observer_->OnExportFinished();
    191     }
    192   }
    193 
    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.
    198     if (!text.length())
    199       return true;
    200     size_t wrote = file_stream_->WriteSync(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(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 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_data;
    270         favicon_data.assign(reinterpret_cast<const char*>(data->front()),
    271                             data->size());
    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();
    276         }
    277       }
    278 
    279       if (!WriteIndent() ||
    280           !Write(kBookmarkStart) ||
    281           !Write(url_string, ATTRIBUTE_VALUE) ||
    282           !Write(kAddDate) ||
    283           !WriteTime(date_added_string) ||
    284           (!favicon_string.empty() &&
    285               (!Write(kIcon) ||
    286                !Write(favicon_string, ATTRIBUTE_VALUE))) ||
    287           !Write(kBookmarkAttributeEnd) ||
    288           !Write(title, CONTENT) ||
    289           !Write(kBookmarkEnd) ||
    290           !Write(kNewline)) {
    291         return false;
    292       }
    293       return true;
    294     }
    295 
    296     // Folder.
    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) {
    303       NOTREACHED();
    304       return false;
    305     }
    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)) {
    316         return false;
    317       }
    318       if (folder_type == BookmarkNode::BOOKMARK_BAR) {
    319         if (!Write(kBookmarkBar))
    320           return false;
    321         title = l10n_util::GetStringUTF8(IDS_BOOKMARK_BAR_FOLDER_NAME);
    322       } else if (!Write(kFolderAttributeEnd)) {
    323         return false;
    324       }
    325       if (!Write(title, CONTENT) ||
    326           !Write(kFolderEnd) ||
    327           !Write(kNewline) ||
    328           !WriteIndent() ||
    329           !Write(kFolderChildren) ||
    330           !Write(kNewline)) {
    331         return false;
    332       }
    333       IncrementIndent();
    334     }
    335 
    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) {
    342         NOTREACHED();
    343         return false;
    344       }
    345       if (!WriteNode(*static_cast<const DictionaryValue*>(child_value),
    346                      BookmarkNode::FOLDER)) {
    347         return false;
    348       }
    349     }
    350     if (folder_type != BookmarkNode::OTHER_NODE &&
    351         folder_type != BookmarkNode::MOBILE) {
    352       // Close out the folder.
    353       DecrementIndent();
    354       if (!WriteIndent() ||
    355           !Write(kFolderChildrenEnd) ||
    356           !Write(kNewline)) {
    357         return false;
    358       }
    359     }
    360     return true;
    361   }
    362 
    363   // The BookmarkModel as a Value. This value was generated from the
    364   // BookmarkCodec.
    365   scoped_ptr<Value> bookmarks_;
    366 
    367   // Path we're writing to.
    368   base::FilePath path_;
    369 
    370   // Map that stores favicon per URL.
    371   scoped_ptr<BookmarkFaviconFetcher::URLFaviconMap> favicons_map_;
    372 
    373   // Observer to be notified on finish.
    374   BookmarksExportObserver* observer_;
    375 
    376   // File we're writing to.
    377   scoped_ptr<net::FileStream> file_stream_;
    378 
    379   // How much we indent when writing a bookmark/folder. This is modified
    380   // via IncrementIndent and DecrementIndent.
    381   std::string indent_;
    382 
    383   DISALLOW_COPY_AND_ASSIGN(Writer);
    384 };
    385 
    386 }  // namespace
    387 
    388 BookmarkFaviconFetcher::BookmarkFaviconFetcher(
    389     Profile* profile,
    390     const base::FilePath& path,
    391     BookmarksExportObserver* observer)
    392     : profile_(profile),
    393       path_(path),
    394       observer_(observer) {
    395   favicons_map_.reset(new URLFaviconMap());
    396   registrar_.Add(this,
    397                  chrome::NOTIFICATION_PROFILE_DESTROYED,
    398                  content::Source<Profile>(profile_));
    399 }
    400 
    401 BookmarkFaviconFetcher::~BookmarkFaviconFetcher() {
    402 }
    403 
    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())
    410     FetchNextFavicon();
    411   else
    412     ExecuteWriter();
    413 }
    414 
    415 void BookmarkFaviconFetcher::Observe(
    416     int type,
    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);
    421     fetcher = NULL;
    422   }
    423 }
    424 
    425 void BookmarkFaviconFetcher::ExtractUrls(const BookmarkNode* node) {
    426   if (node->is_url()) {
    427     std::string url = node->url().spec();
    428     if (!url.empty())
    429       bookmark_urls_.push_back(url);
    430   } else {
    431     for (int i = 0; i < node->child_count(); ++i)
    432       ExtractUrls(node->GetChild(i));
    433   }
    434 }
    435 
    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.
    440   BookmarkCodec codec;
    441   BrowserThread::PostTask(
    442       BrowserThread::FILE, FROM_HERE,
    443       base::Bind(&Writer::DoWrite,
    444                  new Writer(codec.Encode(BookmarkModelFactory::GetForProfile(
    445                                 profile_)),
    446                             path_, favicons_map_.release(), observer_)));
    447   if (fetcher != NULL) {
    448     base::MessageLoop::current()->DeleteSoon(FROM_HERE, fetcher);
    449     fetcher = NULL;
    450   }
    451 }
    452 
    453 bool BookmarkFaviconFetcher::FetchNextFavicon() {
    454   if (bookmark_urls_.empty()) {
    455     return false;
    456   }
    457   do {
    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_);
    471       return true;
    472     } else {
    473       bookmark_urls_.pop_front();
    474     }
    475   } while (!bookmark_urls_.empty());
    476   return false;
    477 }
    478 
    479 void BookmarkFaviconFetcher::OnFaviconDataAvailable(
    480     const chrome::FaviconBitmapResult& bitmap_result) {
    481   GURL url;
    482   if (!bookmark_urls_.empty()) {
    483     url = GURL(bookmark_urls_.front());
    484     bookmark_urls_.pop_front();
    485   }
    486   if (bitmap_result.is_valid() && !url.is_empty()) {
    487     favicons_map_->insert(
    488         make_pair(url.spec(), bitmap_result.bitmap_data));
    489   }
    490 
    491   if (FetchNextFavicon()) {
    492     return;
    493   }
    494   ExecuteWriter();
    495 }
    496 
    497 namespace bookmark_html_writer {
    498 
    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();
    508   }
    509 }
    510 
    511 }  // namespace bookmark_html_writer
    512